1(* ========================================================================= *) 2(* *) 3(* Henstock-Kurzweil (gauge) Integration (univariate) *) 4(* *) 5(* (c) Copyright, John Harrison 1998-2008 *) 6(* (c) Copyright, Marco Maggesi 2014 *) 7(* (c) Copyright 2015, *) 8(* Muhammad Qasim, *) 9(* Osman Hasan, *) 10(* Hardware Verification Group, *) 11(* Concordia University *) 12(* Contact: <m_qasi@ece.concordia.ca> *) 13(* *) 14(* Note: This theory was ported from HOL Light *) 15(* *) 16(* ========================================================================= *) 17 18open HolKernel Parse boolLib bossLib; 19 20open numTheory numLib unwindLib tautLib Arith prim_recTheory pairTheory 21 combinTheory quotientTheory arithmeticTheory pred_setTheory realTheory 22 realLib jrhUtils seqTheory limTheory transcTheory listTheory mesonLib 23 topologyTheory optionTheory RealArith pred_setLib cardinalTheory; 24 25open hurdUtils iterateTheory productTheory real_topologyTheory derivativeTheory; 26 27val _ = new_theory "integration"; 28 29fun MESON ths tm = prove(tm,MESON_TAC ths); 30fun METIS ths tm = prove(tm,METIS_TAC ths); 31 32val DISC_RW_KILL = DISCH_TAC THEN ONCE_ASM_REWRITE_TAC [] THEN 33 POP_ASSUM K_TAC; 34 35fun ASSERT_TAC tm = SUBGOAL_THEN tm STRIP_ASSUME_TAC; 36val ASM_ARITH_TAC = REPEAT (POP_ASSUM MP_TAC) THEN ARITH_TAC; 37 38(* Minimal hol-light compatibility layer *) 39val ASM_REAL_ARITH_TAC = REAL_ASM_ARITH_TAC; (* RealArith *) 40val IMP_CONJ = CONJ_EQ_IMP; (* cardinalTheory *) 41val FINITE_SUBSET = SUBSET_FINITE_I; (* pred_setTheory *) 42val LE_0 = ZERO_LESS_EQ; (* arithmeticTheory *) 43 44(* --------------------------------------------------------------------- *) 45(* STRONG_DISJ2_TAC : tactic *) 46(* *) 47(* If the goal is (asms, A \/ B) then the tactic returns a subgoal of *) 48(* the form ((~A)::asms, B) *) 49(* --------------------------------------------------------------------- *) 50local 51 val th = prove (``!a b. (~a ==> b) ==> a \/ b``, PROVE_TAC []) 52in 53 val STRONG_DISJ2_TAC :tactic = MATCH_MP_TAC th >> DISCH_TAC 54end; 55 56(* ------------------------------------------------------------------------- *) 57(* Some useful lemmas about intervals. *) 58(* ------------------------------------------------------------------------- *) 59 60val INTERIOR_SUBSET_UNION_INTERVALS = store_thm ("INTERIOR_SUBSET_UNION_INTERVALS", 61 ``!s i j. (?a b:real. i = interval[a,b]) /\ (?c d. j = interval[c,d]) /\ 62 ~(interior j = {}) /\ 63 i SUBSET j UNION s /\ 64 (interior(i) INTER interior(j) = {}) 65 ==> interior i SUBSET interior s``, 66 REPEAT STRIP_TAC THEN FULL_SIMP_TAC std_ss [] THEN 67 MATCH_MP_TAC INTERIOR_MAXIMAL THEN REWRITE_TAC[OPEN_INTERIOR] THEN 68 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 69 ASM_REWRITE_TAC [] THEN REPEAT STRIP_TAC THEN 70 RULE_ASSUM_TAC(REWRITE_RULE[INTERIOR_CLOSED_INTERVAL]) THEN 71 SUBGOAL_THEN ``interval(a:real,b) INTER interval[c,d] = {}`` ASSUME_TAC THENL 72 [ASM_SIMP_TAC std_ss [INTER_INTERVAL_MIXED_EQ_EMPTY], 73 MP_TAC(ISPECL [``a:real``, ``b:real``] INTERVAL_OPEN_SUBSET_CLOSED) THEN 74 REWRITE_TAC[INTERIOR_CLOSED_INTERVAL] THEN 75 REPEAT(POP_ASSUM MP_TAC) THEN SET_TAC[]]); 76 77val lemma1 = Q.prove ( 78 `(abs(d:real) = e / &2) ==> 79 dist(x + d,y) < e / &2 ==> dist(x,y) < e`, 80 GEN_REWR_TAC LAND_CONV [EQ_SYM_EQ] THEN DISCH_TAC THEN 81 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [GSYM REAL_HALF_DOUBLE] THEN 82 ASM_REWRITE_TAC [dist] THEN REAL_ARITH_TAC); 83 84val lemma2 = Q.prove ( 85 `!x:real. (-x/2) = -(x/2)`, 86 GEN_TAC THEN ONCE_REWRITE_TAC [REAL_NEG_MINUS1] THEN 87 REWRITE_TAC [real_div, REAL_MUL_ASSOC]); 88 89val INTER_INTERIOR_BIGUNION_INTERVALS = store_thm ("INTER_INTERIOR_BIGUNION_INTERVALS", 90 ``!s f. FINITE f /\ open s /\ 91 (!t. t IN f ==> ?a b:real. (t = interval[a,b])) /\ 92 (!t. t IN f ==> (s INTER (interior t) = {})) 93 ==> (s INTER interior(BIGUNION f) = {})``, 94 ONCE_REWRITE_TAC[TAUT 95 `a /\ b /\ c /\ d ==> e <=> a /\ b /\ c ==> ~e ==> ~d`] THEN 96 SIMP_TAC std_ss [NOT_FORALL_THM, NOT_IMP, GSYM MEMBER_NOT_EMPTY] THEN 97 SIMP_TAC std_ss [OPEN_CONTAINS_BALL_EQ, OPEN_INTER, OPEN_INTERIOR] THEN 98 SIMP_TAC std_ss [OPEN_SUBSET_INTERIOR, OPEN_BALL, SUBSET_INTER] THEN 99 REWRITE_TAC[GSYM SUBSET_INTER] THEN 100 GEN_TAC THEN ONCE_REWRITE_TAC[GSYM AND_IMP_INTRO] THEN GEN_TAC THEN 101 KNOW_TAC ``(open s /\ (!t. t IN f ==> ?a b. t = interval [(a,b)]) ==> 102 (?x e. 0 < e /\ ball (x,e) SUBSET s INTER BIGUNION f) ==> 103 ?t. t IN f /\ ?x e. 0 < e /\ ball (x,e) SUBSET s INTER t) = 104 (\f. (open s /\ (!t. t IN f ==> ?a b. t = interval [(a,b)]) ==> 105 (?x e. 0 < e /\ ball (x,e) SUBSET s INTER BIGUNION f) ==> 106 ?t. t IN f /\ ?x e. 0 < e /\ ball (x,e) SUBSET s INTER t))f`` THENL 107 [FULL_SIMP_TAC std_ss [], ALL_TAC] THEN DISC_RW_KILL THEN 108 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN CONJ_TAC THENL 109 [REWRITE_TAC[BIGUNION_EMPTY, INTER_EMPTY, SUBSET_EMPTY] THEN 110 MESON_TAC[CENTRE_IN_BALL, NOT_IN_EMPTY], 111 ALL_TAC] THEN 112 SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM] THEN 113 MAP_EVERY X_GEN_TAC [``f:(real->bool)->bool``, ``i:real->bool``] THEN 114 DISCH_TAC THEN DISCH_TAC THEN 115 REWRITE_TAC[BIGUNION_INSERT, IN_INSERT] THEN 116 REWRITE_TAC[TAUT `(a \/ b) ==> c <=> (a ==> c) /\ (b ==> c)`] THEN 117 SIMP_TAC std_ss [RIGHT_AND_OVER_OR, FORALL_AND_THM, EXISTS_OR_THM] THEN 118 SIMP_TAC std_ss [GSYM CONJ_ASSOC, UNWIND_THM2] THEN 119 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 120 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC STRIP_ASSUME_TAC) THEN 121 DISCH_THEN(X_CHOOSE_THEN ``a:real`` (X_CHOOSE_THEN ``b:real`` 122 SUBST_ALL_TAC)) THEN 123 FIRST_X_ASSUM(CONJUNCTS_THEN2 STRIP_ASSUME_TAC MP_TAC) THEN 124 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC(TAUT 125 `(r ==> s \/ p) ==> (p ==> q) ==> r ==> s \/ q`) THEN 126 POP_ASSUM_LIST(K ALL_TAC) THEN 127 DISCH_THEN (X_CHOOSE_TAC ``x:real``) THEN POP_ASSUM MP_TAC THEN 128 DISCH_THEN (X_CHOOSE_TAC ``e:real``) THEN FULL_SIMP_TAC std_ss [] THEN 129 ASM_CASES_TAC ``(x:real) IN interval[a,b]`` THENL 130 [ALL_TAC, 131 SUBGOAL_THEN 132 ``?d. &0 < d /\ ball(x,d) SUBSET (univ(:real) DIFF interval[a,b])`` 133 STRIP_ASSUME_TAC THENL 134 [ASM_MESON_TAC[closed_def, OPEN_CONTAINS_BALL, CLOSED_INTERVAL, 135 IN_DIFF, IN_UNIV], ALL_TAC] THEN 136 DISJ2_TAC THEN MAP_EVERY EXISTS_TAC [``x:real``, ``min d e:real``] THEN 137 ASM_REWRITE_TAC[REAL_LT_MIN, SUBSET_DEF] THEN 138 POP_ASSUM MP_TAC THEN GEN_REWR_TAC LAND_CONV [SUBSET_DEF] THEN 139 UNDISCH_TAC ``ball (x,e) SUBSET s INTER (interval [(a,b)] UNION BIGUNION f)`` THEN 140 GEN_REWR_TAC LAND_CONV [SUBSET_DEF] THEN 141 SIMP_TAC std_ss [IN_BALL, REAL_LT_MIN, IN_DIFF, IN_INTER, IN_UNIV, IN_UNION] THEN 142 ASM_MESON_TAC[]] THEN 143 ASM_CASES_TAC ``(x:real) IN interval(a,b)`` THENL 144 [DISJ1_TAC THEN 145 SUBGOAL_THEN 146 ``?d. &0 < d /\ ball(x:real,d) SUBSET interval(a,b)`` 147 STRIP_ASSUME_TAC THENL 148 [ASM_MESON_TAC[OPEN_CONTAINS_BALL, OPEN_INTERVAL], ALL_TAC] THEN 149 MAP_EVERY EXISTS_TAC [``x:real``, ``min d e:real``] THEN 150 ASM_REWRITE_TAC[REAL_LT_MIN, SUBSET_DEF] THEN 151 POP_ASSUM MP_TAC THEN GEN_REWR_TAC LAND_CONV [SUBSET_DEF] THEN 152 UNDISCH_TAC ``ball (x,e) SUBSET s INTER (interval [(a,b)] UNION BIGUNION f)`` THEN 153 GEN_REWR_TAC LAND_CONV [SUBSET_DEF] THEN 154 SIMP_TAC std_ss [IN_BALL, REAL_LT_MIN, IN_DIFF, IN_INTER, IN_UNIV, IN_UNION] THEN 155 ASM_MESON_TAC[INTERVAL_OPEN_SUBSET_CLOSED, SUBSET_DEF], 156 ALL_TAC] THEN 157 POP_ASSUM MP_TAC THEN GEN_REWR_TAC (LAND_CONV o RAND_CONV) [IN_INTERVAL] THEN 158 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 159 REWRITE_TAC[GSYM REAL_LT_LE, DE_MORGAN_THM] THEN 160 STRIP_TAC THEN DISJ2_TAC THENL 161 [EXISTS_TAC ``x + -e / &2:real``, 162 EXISTS_TAC ``x + e / &2:real``] THEN 163 EXISTS_TAC ``e / &2:real`` THEN ASM_REWRITE_TAC[REAL_LT_HALF1] THEN 164 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (SET_RULE 165 ``b1 SUBSET k INTER (i UNION s) 166 ==> b2 SUBSET b1 /\ (b2 INTER i = {}) 167 ==> b2 SUBSET k INTER s``)) THEN 168 (CONJ_TAC THENL 169 [REWRITE_TAC[SUBSET_DEF, IN_BALL] THEN 170 GEN_TAC THEN MATCH_MP_TAC lemma1 THEN REWRITE_TAC [lemma2, ABS_NEG, ABS_REFL] THEN 171 UNDISCH_TAC ``&0 < e:real`` THEN ONCE_REWRITE_TAC [GSYM REAL_LT_HALF1] THEN 172 ASM_SIMP_TAC std_ss [REAL_LE_LT], 173 ALL_TAC]) THEN 174 REWRITE_TAC[EXTENSION, IN_INTER, IN_INTERVAL, NOT_IN_EMPTY] THEN 175 X_GEN_TAC ``y:real`` THEN REWRITE_TAC[IN_BALL, dist] THEN 176 DISCH_TAC THEN FULL_SIMP_TAC std_ss [REAL_NOT_LT, lemma2] THEN 177 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN REWRITE_TAC [AND_IMP_INTRO] THEN 178 POP_ASSUM MP_TAC THEN UNDISCH_TAC ``0 < e:real`` THENL 179 [KNOW_TAC ``a = x:real`` THENL [METIS_TAC [REAL_LE_ANTISYM], ALL_TAC], 180 KNOW_TAC ``b = x:real`` THENL [METIS_TAC [REAL_LE_ANTISYM], ALL_TAC]] THEN 181 DISC_RW_KILL THEN REAL_ARITH_TAC); 182 183(* ------------------------------------------------------------------------- *) 184(* This lemma about iterations comes up in a few places. *) 185(* ------------------------------------------------------------------------- *) 186 187val ITERATE_NONZERO_IMAGE_LEMMA = store_thm ("ITERATE_NONZERO_IMAGE_LEMMA", 188 ``!op s f g a. 189 monoidal op /\ FINITE s /\ (g(a) = neutral op) /\ 190 (!x y. x IN s /\ y IN s /\ (f x = f y) /\ ~(x = y) ==> (g(f x) = neutral op)) 191 ==> (iterate op {f x | x | x IN s /\ ~(f x = a)} g = 192 iterate op s (g o f))``, 193 REPEAT STRIP_TAC THEN 194 GEN_REWR_TAC RAND_CONV [GSYM ITERATE_SUPPORT] THEN 195 REWRITE_TAC [support] THEN 196 ONCE_REWRITE_TAC[SET_RULE ``{f x |x| x IN s /\ ~(f x = a)} = 197 IMAGE f {x | x IN s /\ ~(f x = a)}``] THEN 198 KNOW_TAC ``(!x y. 199 x IN {x | x IN s /\ ~((g o f) x = neutral op)} /\ 200 y IN {x | x IN s /\ ~((g o f) x = neutral op)} /\ 201 (f x = f y) ==> (x = y)) 202 ==> (iterate (op:'a->'a->'a) (IMAGE (f:'b->'c) {x | x IN s /\ ~((g o f) x = neutral op)}) g = 203 iterate op {x | x IN s /\ ~((g o f) x = neutral op)} ((g:'c->'a) o f))`` THENL 204 [SRW_TAC [][ITERATE_IMAGE], ALL_TAC] THEN 205 KNOW_TAC ``(!x y. 206 x IN {x | x IN s /\ ((g:'c->'a) o (f:'b->'c)) x <> neutral op} /\ 207 y IN {x | x IN s /\ (g o f) x <> neutral op} /\ 208 (f x = f y) ==> (x = y))`` THENL 209 [SIMP_TAC std_ss [GSPECIFICATION, o_THM] THEN ASM_MESON_TAC[], 210 DISCH_TAC THEN ASM_REWRITE_TAC []] THEN 211 DISCH_THEN(SUBST1_TAC o SYM) THEN 212 KNOW_TAC ``IMAGE f {x | x IN s /\ ~(((g:'c->'a) o (f:'b->'c)) x = neutral op)} SUBSET 213 IMAGE f {x | x IN s /\ ~(f x = a)} /\ 214 (!x. x IN IMAGE f {x | x IN s /\ ~(f x = a)} /\ 215 ~(x IN IMAGE f {x | x IN s /\ ~((g o f) x = neutral op)}) 216 ==> (g x = neutral (op:'a->'a->'a)))`` THENL 217 [ALL_TAC, METIS_TAC [ITERATE_SUPERSET]] THEN 218 ASM_SIMP_TAC std_ss [IMAGE_FINITE, FINITE_RESTRICT] THEN 219 SIMP_TAC std_ss [IMP_CONJ, FORALL_IN_IMAGE, SUBSET_DEF] THEN 220 SIMP_TAC std_ss [GSPECIFICATION, IN_IMAGE, o_THM] THEN 221 ASM_MESON_TAC[]); 222 223(* ------------------------------------------------------------------------- *) 224(* Bounds on intervals where they exist. *) 225(* ------------------------------------------------------------------------- *) 226 227(* NOTE: HOL Light's original definitions: 228 229 `sup {a | ?x. x IN s /\ (x = a)}` = `sup s` 230 `inf {a | ?x. x IN s /\ (x = a)}` = `inf s` 231 232 are not specified on {} but `sup {} = inf {}` can be proven due to the 233 definition of `inf` in HOL Light. However in HOL4 this is not derivable. 234 Now we explicitly define that the upper and lower bounds of {} are both 0. 235 This change shouldn't cause anything wrong. -- Chun Tian, Oct 24, 2019. 236 *) 237Definition interval_upperbound : 238 (interval_upperbound:(real->bool)->real) s = 239 if s = {} then 0:real else sup s 240End 241 242Definition interval_lowerbound : 243 (interval_lowerbound:(real->bool)->real) s = 244 if s = {} then 0:real else inf s 245End 246 247Theorem INTERVAL_UPPERBOUND : 248 !a b:real. a <= b ==> (interval_upperbound(interval[a,b]) = b) 249Proof 250 RW_TAC std_ss [interval_upperbound] 251 >- (fs [EXTENSION, GSPECIFICATION, IN_INTERVAL] \\ 252 METIS_TAC [REAL_LE_REFL]) 253 >> MATCH_MP_TAC REAL_SUP_UNIQUE 254 >> SIMP_TAC std_ss [GSPECIFICATION, IN_INTERVAL] 255 >> ASM_MESON_TAC[REAL_LE_REFL] 256QED 257 258Theorem INTERVAL_LOWERBOUND : 259 !a b:real. a <= b ==> (interval_lowerbound(interval[a,b]) = a) 260Proof 261 RW_TAC std_ss [interval_lowerbound] 262 >- (fs [EXTENSION, GSPECIFICATION, IN_INTERVAL] \\ 263 METIS_TAC [REAL_LE_REFL]) 264 >> MATCH_MP_TAC REAL_INF_UNIQUE 265 >> SIMP_TAC std_ss [GSPECIFICATION, IN_INTERVAL] 266 >> ASM_MESON_TAC [REAL_LE_REFL] 267QED 268 269Theorem INTERVAL_LOWERBOUND_NONEMPTY : 270 !a b:real. ~(interval[a,b] = {}) ==> 271 (interval_lowerbound(interval[a,b]) = a) 272Proof 273 SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_NE_EMPTY] 274QED 275 276Theorem INTERVAL_UPPERBOUND_NONEMPTY : 277 !a b:real. ~(interval[a,b] = {}) ==> 278 (interval_upperbound(interval[a,b]) = b) 279Proof 280 SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_NE_EMPTY] 281QED 282 283Theorem INTERVAL_BOUNDS_EMPTY : 284 (interval_upperbound {} = 0) /\ 285 (interval_lowerbound {} = 0) 286Proof 287 rw [interval_upperbound, interval_lowerbound] 288QED 289 290(* ------------------------------------------------------------------------- *) 291(* Content (length) of an interval. *) 292(* ------------------------------------------------------------------------- *) 293 294val content = new_definition ("content", 295 ``content(s:real->bool) = 296 if s = {} then 0:real 297 else (interval_upperbound s - interval_lowerbound s)``); 298 299val CONTENT_CLOSED_INTERVAL = store_thm ("CONTENT_CLOSED_INTERVAL", 300 ``!a b:real. a <= b ==> (content(interval[a,b]) = b - a)``, 301 REPEAT GEN_TAC THEN DISCH_TAC THEN SIMP_TAC std_ss [interval] THEN 302 KNOW_TAC ``{x | (a :real) <= x /\ x <= (b :real)} <> {}`` THENL 303 [ONCE_REWRITE_TAC [GSYM MEMBER_NOT_EMPTY] THEN 304 FULL_SIMP_TAC std_ss [GSPECIFICATION, REAL_LE_LT] THENL 305 [KNOW_TAC ``(?(x :real). a < x /\ x < b)`` THENL 306 [FULL_SIMP_TAC std_ss [REAL_MEAN], ALL_TAC] THEN STRIP_TAC THEN 307 EXISTS_TAC ``x:real`` THEN ASM_REWRITE_TAC [], 308 EXISTS_TAC ``a:real`` THEN ASM_REWRITE_TAC []], 309 FULL_SIMP_TAC std_ss [content, INTERVAL_UPPERBOUND, 310 INTERVAL_LOWERBOUND, GSYM interval]]); 311 312val CONTENT_UNIT = store_thm ("CONTENT_UNIT", 313 ``content(interval[0,1]) = 1:real``, 314 SIMP_TAC arith_ss [CONTENT_CLOSED_INTERVAL, REAL_LE_01, REAL_SUB_RZERO]); 315 316val CONTENT_POS_LE = store_thm ("CONTENT_POS_LE", 317 ``!a b:real. &0 <= content(interval[a,b])``, 318 REPEAT GEN_TAC THEN REWRITE_TAC[content] THEN 319 COND_CASES_TAC THEN REWRITE_TAC[REAL_LE_REFL] THEN 320 FULL_SIMP_TAC std_ss [INTERVAL_NE_EMPTY] THEN 321 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND, REAL_SUB_LE]); 322 323val CONTENT_POS_LT = store_thm ("CONTENT_POS_LT", 324 ``!a b:real. a < b ==> &0 < content(interval[a,b])``, 325 REPEAT STRIP_TAC THEN 326 ASM_SIMP_TAC std_ss [CONTENT_CLOSED_INTERVAL, REAL_LT_IMP_LE] THEN 327 ASM_SIMP_TAC std_ss [REAL_SUB_LT]); 328 329val CONTENT_EQ_0_GEN = store_thm ("CONTENT_EQ_0_GEN", 330 ``!s:real->bool. bounded s 331 ==> ((content s = &0) <=> ?a. !x. x IN s ==> (x = a))``, 332 REPEAT GEN_TAC THEN REWRITE_TAC[content] THEN 333 COND_CASES_TAC THEN ASM_REWRITE_TAC[NOT_IN_EMPTY] THEN 334 REWRITE_TAC [bounded_def] THEN DISCH_TAC THEN 335 ASM_SIMP_TAC std_ss [interval_upperbound, interval_lowerbound, 336 GSPEC_ID, REAL_SUB_0, REAL_SUP_EQ_INF] THEN EQ_TAC THENL 337 [METIS_TAC [GSYM UNIQUE_MEMBER_SING], 338 REWRITE_TAC [GSYM UNIQUE_MEMBER_SING] THEN KNOW_TAC ``?a:real. a IN s`` THENL 339 [EXISTS_TAC ``CHOICE (s:real->bool)`` THEN 340 METIS_TAC [CHOICE_DEF, GSYM SPECIFICATION], METIS_TAC []]]); 341 342val CONTENT_EQ_0 = store_thm ("CONTENT_EQ_0", 343 ``!a b:real. (content(interval[a,b]) = &0) <=> b <= a``, 344 REPEAT GEN_TAC THEN REWRITE_TAC[content, INTERVAL_EQ_EMPTY] THEN 345 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THENL 346 [FULL_SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, REAL_LT_IMP_LE], 347 FULL_SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT, 348 INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, REAL_SUB_0] THEN 349 METIS_TAC [REAL_LE_LT, REAL_LE_ANTISYM]]); 350 351val CONTENT_0_SUBSET_GEN = store_thm ("CONTENT_0_SUBSET_GEN", 352 ``!s t:real->bool. 353 s SUBSET t /\ bounded t /\ (content t = &0) ==> (content s = &0)``, 354 REPEAT GEN_TAC THEN 355 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 356 SUBGOAL_THEN ``bounded(s:real->bool)`` ASSUME_TAC THENL 357 [ASM_MESON_TAC[BOUNDED_SUBSET], ALL_TAC] THEN 358 ASM_SIMP_TAC std_ss [CONTENT_EQ_0_GEN] THEN 359 POP_ASSUM_LIST(MP_TAC o end_itlist CONJ) THEN SET_TAC[]); 360 361val CONTENT_0_SUBSET = store_thm ("CONTENT_0_SUBSET", 362 ``!s a b:real. s SUBSET interval[a,b] /\ 363 (content(interval[a,b]) = &0) ==> (content s = &0)``, 364 MESON_TAC[CONTENT_0_SUBSET_GEN, BOUNDED_INTERVAL]); 365 366val CONTENT_CLOSED_INTERVAL_CASES = store_thm ("CONTENT_CLOSED_INTERVAL_CASES", 367 ``!a b:real. content(interval[a,b]) = 368 if a <= b then b - a else &0``, 369 REPEAT GEN_TAC THEN COND_CASES_TAC THEN 370 ASM_SIMP_TAC std_ss [CONTENT_EQ_0, CONTENT_CLOSED_INTERVAL] THEN 371 ASM_MESON_TAC[REAL_LE_TOTAL]); 372 373val CONTENT_EQ_0_INTERIOR = store_thm ("CONTENT_EQ_0_INTERIOR", 374 ``!a b:real. 375 (content(interval[a,b]) = &0) <=> (interior(interval[a,b]) = {})``, 376 REWRITE_TAC[CONTENT_EQ_0, INTERIOR_CLOSED_INTERVAL, INTERVAL_EQ_EMPTY]); 377 378val CONTENT_EQ_0_1 = store_thm ("CONTENT_EQ_0_1", 379 ``!a b:real. 380 (content(interval[a,b]) = &0) <=> b <= a``, 381 REWRITE_TAC [CONTENT_EQ_0]); 382 383val CONTENT_POS_LT_EQ = store_thm ("CONTENT_POS_LT_EQ", 384 ``!a b:real. &0 < content(interval[a,b]) <=> a < b``, 385 REPEAT GEN_TAC THEN EQ_TAC THEN REWRITE_TAC[CONTENT_POS_LT] THEN 386 REWRITE_TAC[REAL_ARITH ``&0 < x:real <=> &0 <= x:real /\ ~(x = &0:real)``] THEN 387 REWRITE_TAC[CONTENT_POS_LE, CONTENT_EQ_0] THEN MESON_TAC[REAL_NOT_LE]); 388 389val CONTENT_EMPTY = store_thm ("CONTENT_EMPTY", 390 ``content {} = &0``, 391 REWRITE_TAC[content]); 392 393val CONTENT_SUBSET = store_thm ("CONTENT_SUBSET", 394 ``!a b c d:real. 395 interval[a,b] SUBSET interval[c,d] 396 ==> content(interval[a,b]) <= content(interval[c,d])``, 397 REPEAT STRIP_TAC THEN GEN_REWR_TAC LAND_CONV [content] THEN 398 COND_CASES_TAC THEN ASM_REWRITE_TAC[CONTENT_POS_LE] THEN 399 UNDISCH_TAC ``interval [(a,b)] SUBSET interval [(c,d)]`` THEN 400 REWRITE_TAC [SUBSET_DEF] THEN 401 RULE_ASSUM_TAC(REWRITE_RULE[INTERVAL_NE_EMPTY]) THEN 402 REWRITE_TAC[IN_INTERVAL] THEN DISCH_THEN(fn th => 403 MP_TAC(SPEC ``a:real`` th) THEN MP_TAC(SPEC ``b:real`` th)) THEN 404 ASM_SIMP_TAC std_ss [REAL_LE_REFL, content] THEN REPEAT STRIP_TAC THEN 405 ONCE_REWRITE_TAC[METIS [] ``(if b then c else d) = (if ~b then d else c)``] THEN 406 REWRITE_TAC[INTERVAL_NE_EMPTY] THEN COND_CASES_TAC THENL 407 [ALL_TAC, ASM_MESON_TAC[REAL_LE_TRANS]] THEN 408 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 409 METIS_TAC [real_sub, REAL_LE_ADD2, REAL_LE_NEG]); 410 411val CONTENT_LT_NZ = store_thm ("CONTENT_LT_NZ", 412 ``!a b. &0 < content(interval[a,b]) <=> ~(content(interval[a,b]) = &0)``, 413 REWRITE_TAC[CONTENT_POS_LT_EQ, CONTENT_EQ_0] THEN MESON_TAC[REAL_NOT_LE]); 414 415Theorem INTERVAL_BOUNDS_NULL : 416 !a b:real. (content(interval[a,b]) = &0) 417 ==> (interval_upperbound(interval[a,b]) = 418 interval_lowerbound(interval[a,b])) 419Proof 420 rpt GEN_TAC >> ASM_CASES_TAC ``interval[a:real,b] = {}`` 421 >| [ (* goal 1 (of 2) *) 422 RW_TAC std_ss [interval_upperbound, interval_lowerbound, 423 GSYM INTERVAL_EQ_EMPTY, NOT_IN_EMPTY] \\ 424 fs [EXTENSION, GSPECIFICATION, NOT_IN_EMPTY, IN_INTERVAL] \\ 425 METIS_TAC [real_lte, REAL_LE_REFL], 426 (* goal 2 (of 2) *) 427 RULE_ASSUM_TAC (SIMP_RULE std_ss [GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT]) \\ 428 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND] \\ 429 REWRITE_TAC [CONTENT_EQ_0] >> ASM_REAL_ARITH_TAC ] 430QED 431 432val INTERVAL_BOUNDS_EMPTY = store_thm ("INTERVAL_BOUNDS_EMPTY", 433 ``interval_upperbound({}:real->bool) = 434 interval_lowerbound({}:real->bool)``, 435 METIS_TAC [INTERVAL_BOUNDS_NULL, CONTENT_EMPTY, EMPTY_AS_INTERVAL]); 436 437(* ------------------------------------------------------------------------- *) 438(* The notion of a gauge --- simply an open set containing the point. *) 439(* ------------------------------------------------------------------------- *) 440 441(* `gauge :(real -> (real set)) -> bool` *) 442val gauge_def = new_definition ("gauge_def", 443 ``gauge_def d <=> !x. x IN d(x) /\ open(d(x))``); 444 445(* `gauge :(real set -> (real -> real) -> bool)` was defined in transcTheory *) 446val _ = overload_on ("gauge", ``gauge_def``); 447 448val GAUGE_BALL_DEPENDENT = store_thm ("GAUGE_BALL_DEPENDENT", 449 ``!e. (!x. &0 < e(x)) ==> gauge(\x. ball(x,e(x)))``, 450 SIMP_TAC std_ss [gauge_def, OPEN_BALL, IN_BALL, DIST_REFL]); 451 452val GAUGE_BALL = store_thm ("GAUGE_BALL", 453 ``!e. &0 < e ==> gauge (\x. ball(x,e))``, 454 SIMP_TAC std_ss [gauge_def, OPEN_BALL, IN_BALL, DIST_REFL]); 455 456val GAUGE_TRIVIAL = store_thm ("GAUGE_TRIVIAL", 457 ``gauge (\x. ball(x,&1))``, 458 SIMP_TAC std_ss [GAUGE_BALL, REAL_LT_01]); 459 460val GAUGE_INTER = store_thm ("GAUGE_INTER", 461 ``!d1 d2. gauge d1 /\ gauge d2 ==> gauge (\x. (d1 x) INTER (d2 x))``, 462 SIMP_TAC std_ss [gauge_def, IN_INTER, OPEN_INTER]); 463 464Theorem GAUGE_BIGINTER : 465 !f s. FINITE s /\ (!d. d IN s ==> gauge (f d)) ==> 466 gauge (\x. BIGINTER {f d x | d IN s}) 467Proof 468 SIMP_TAC std_ss [gauge_def, IN_BIGINTER] 469 >> REWRITE_TAC[SET_RULE ``{f d x | d IN s} = IMAGE (\d. f d x) s``] 470 >> SIMP_TAC std_ss [FORALL_IN_IMAGE, OPEN_BIGINTER, IMAGE_FINITE] 471QED 472 473Theorem GAUGE_EXISTENCE_LEMMA : 474 !p q. (!x:real. ?d:real. p x ==> &0 < d /\ q d x) <=> 475 (!x:real. ?d:real. &0 < d /\ (p x ==> q d x)) 476Proof 477 MESON_TAC [REAL_LT_01] 478QED 479 480(* ------------------------------------------------------------------------- *) 481(* Divisions. *) 482(* ------------------------------------------------------------------------- *) 483 484val _ = set_fixity "division_of" (Infix(NONASSOC, 450)); 485 486val division_of = new_definition ("division_of", 487 ``s division_of i <=> 488 FINITE s /\ 489 (!k. k IN s 490 ==> k SUBSET i /\ ~(k = {}) /\ ?a b. k = interval[a,b]) /\ 491 (!k1 k2. k1 IN s /\ k2 IN s /\ ~(k1 = k2) 492 ==> (interior(k1) INTER interior(k2) = {})) /\ 493 (BIGUNION s = i)``); 494 495Theorem DIVISION_OF : 496 !s i. s division_of i <=> 497 FINITE s /\ 498 (!k. k IN s ==> ~(k = {}) /\ ?a b. k = interval[a,b]) /\ 499 (!k1 k2. k1 IN s /\ k2 IN s /\ ~(k1 = k2) 500 ==> (interior(k1) INTER interior(k2) = {})) /\ 501 (BIGUNION s = i) 502Proof 503 NTAC 2 GEN_TAC 504 >> REWRITE_TAC [division_of] >> SET_TAC [] 505QED 506 507val DIVISION_OF_FINITE = store_thm ("DIVISION_OF_FINITE", 508 ``!s i. s division_of i ==> FINITE s``, 509 MESON_TAC[division_of]); 510 511val DIVISION_OF_SELF = store_thm ("DIVISION_OF_SELF", 512 ``!a b. ~(interval[a,b] = {}) ==> {interval[a,b]} division_of interval[a,b]``, 513 REWRITE_TAC[division_of, FINITE_INSERT, FINITE_EMPTY, IN_SING, BIGUNION_SING] THEN 514 MESON_TAC[SUBSET_REFL]); 515 516val DIVISION_OF_TRIVIAL = store_thm ("DIVISION_OF_TRIVIAL", 517 ``!s. s division_of {} <=> (s = {})``, 518 REWRITE_TAC[division_of, SUBSET_EMPTY, CONJ_ASSOC] THEN 519 REWRITE_TAC[TAUT `~(p /\ ~p)`] THEN REWRITE_TAC [GSYM CONJ_ASSOC] THEN 520 REWRITE_TAC [METIS [GSYM NOT_EXISTS_THM, MEMBER_NOT_EMPTY] 521 ``(!k. k NOTIN s) = (s = {})``] THEN 522 METIS_TAC[FINITE_EMPTY, FINITE_INSERT, BIGUNION_EMPTY, NOT_IN_EMPTY]); 523 524val EMPTY_DIVISION_OF = store_thm ("EMPTY_DIVISION_OF", 525 ``!s. {} division_of s <=> (s = {})``, 526 REWRITE_TAC[division_of, BIGUNION_EMPTY, FINITE_EMPTY, NOT_IN_EMPTY] THEN 527 MESON_TAC[]); 528 529val lemma = Q.prove ( 530 `s SUBSET {{a}} /\ p /\ (BIGUNION s = {a}) <=> (s = {{a}}) /\ p`, 531 EQ_TAC THEN STRIP_TAC THEN 532 ASM_REWRITE_TAC[SET_RULE ``BIGUNION {a} = a``] THEN 533 REPEAT (POP_ASSUM MP_TAC) THEN SET_TAC[]); 534 535val DIVISION_OF_SING = store_thm ("DIVISION_OF_SING", 536 ``!s a. s division_of interval[a,a] <=> (s = {interval[a,a]})``, 537 REWRITE_TAC[division_of, INTERVAL_SING] THEN 538 REWRITE_TAC[SET_RULE ``k SUBSET {a} /\ ~(k = {}) /\ p <=> (k = {a}) /\ p``] THEN 539 REWRITE_TAC[GSYM INTERVAL_SING] THEN 540 REWRITE_TAC[MESON[] ``((k = interval[a,b]) /\ ?c d. (k = interval[c,d])) <=> 541 ((k = interval[a,b]))``] THEN 542 REWRITE_TAC[SET_RULE ``(!k. k IN s ==> (k = a)) <=> s SUBSET {a}``] THEN 543 REWRITE_TAC[INTERVAL_SING, lemma] THEN MESON_TAC[FINITE_EMPTY, FINITE_INSERT, IN_SING]); 544 545val ELEMENTARY_EMPTY = store_thm ("ELEMENTARY_EMPTY", 546 ``?p. p division_of {}``, 547 REWRITE_TAC[DIVISION_OF_TRIVIAL, EXISTS_REFL]); 548 549val ELEMENTARY_INTERVAL = store_thm ("ELEMENTARY_INTERVAL", 550 ``!a b. ?p. p division_of interval[a,b]``, 551 MESON_TAC[DIVISION_OF_TRIVIAL, DIVISION_OF_SELF]); 552 553val DIVISION_CONTAINS = store_thm ("DIVISION_CONTAINS", 554 ``!s i. s division_of i ==> !x. x IN i ==> ?k. x IN k /\ k IN s``, 555 REWRITE_TAC[division_of, EXTENSION, IN_BIGUNION] THEN MESON_TAC[]); 556 557val FORALL_IN_DIVISION = store_thm ("FORALL_IN_DIVISION", 558 ``!P d i. d division_of i 559 ==> ((!x. x IN d ==> P x) <=> 560 (!a b. interval[a,b] IN d ==> P(interval[a,b])))``, 561 REWRITE_TAC[division_of] THEN MESON_TAC[]); 562 563val FORALL_IN_DIVISION_NONEMPTY = store_thm ("FORALL_IN_DIVISION_NONEMPTY", 564 ``!P d i. 565 d division_of i 566 ==> ((!x. x IN d ==> P x) <=> 567 (!a b. interval [a,b] IN d /\ ~(interval[a,b] = {}) 568 ==> P (interval [a,b])))``, 569 REWRITE_TAC[division_of] THEN MESON_TAC[]); 570 571val DIVISION_OF_SUBSET = store_thm ("DIVISION_OF_SUBSET", 572 ``!p q:(real->bool)->bool. 573 p division_of (BIGUNION p) /\ q SUBSET p ==> q division_of (BIGUNION q)``, 574 REPEAT GEN_TAC THEN DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 575 REWRITE_TAC[division_of] THEN 576 REPEAT(MATCH_MP_TAC MONO_AND THEN CONJ_TAC) THENL 577 [ASM_MESON_TAC[SUBSET_FINITE], POP_ASSUM MP_TAC THEN SET_TAC[], 578 POP_ASSUM MP_TAC THEN SET_TAC[]]); 579 580val DIVISION_OF_UNION_SELF = store_thm ("DIVISION_OF_UNION_SELF", 581 ``!p s. p division_of s ==> p division_of (BIGUNION p)``, 582 REWRITE_TAC[division_of] THEN MESON_TAC[]); 583 584val DIVISION_OF_CONTENT_0 = store_thm ("DIVISION_OF_CONTENT_0", 585 ``!a b d. (content(interval[a,b]) = &0) /\ d division_of interval[a,b] 586 ==> !k. k IN d ==> (content k = &0)``, 587 REPEAT GEN_TAC THEN STRIP_TAC THEN 588 KNOW_TAC ``!k. (content k = 0) = (\k. content k = 0) k`` THENL 589 [FULL_SIMP_TAC std_ss [], ALL_TAC] THEN DISC_RW_KILL THEN 590 FIRST_ASSUM(fn th => REWRITE_TAC[MATCH_MP FORALL_IN_DIVISION th]) THEN 591 BETA_TAC THEN 592 REWRITE_TAC[GSYM REAL_LE_ANTISYM, CONTENT_POS_LE] THEN 593 METIS_TAC[CONTENT_SUBSET, division_of]); 594 595val lemma = Q.prove ( 596 `{k1 INTER k2 | k1 IN p1 /\ k2 IN p2 /\ ~(k1 INTER k2 = {})} = 597 {s | s IN IMAGE (\(k1,k2). k1 INTER k2) (p1 CROSS p2) /\ 598 ~(s = {})}`, 599 REWRITE_TAC[EXTENSION] THEN 600 SIMP_TAC std_ss [IN_IMAGE, GSPECIFICATION, EXISTS_PROD, IN_CROSS] THEN 601 MESON_TAC[]); 602 603val DIVISION_INTER = store_thm ("DIVISION_INTER", 604 ``!s1 s2:real->bool p1 p2. 605 p1 division_of s1 /\ 606 p2 division_of s2 607 ==> {k1 INTER k2 | k1 IN p1 /\ k2 IN p2 /\ ~(k1 INTER k2 = {})} 608 division_of (s1 INTER s2)``, 609 REPEAT GEN_TAC THEN REWRITE_TAC[DIVISION_OF] THEN STRIP_TAC THEN 610 ASM_SIMP_TAC std_ss [lemma, FINITE_RESTRICT, FINITE_CROSS, IMAGE_FINITE] THEN 611 SIMP_TAC std_ss [GSPECIFICATION] THEN 612 SIMP_TAC std_ss [GSYM AND_IMP_INTRO, FORALL_IN_IMAGE, RIGHT_FORALL_IMP_THM] THEN 613 SIMP_TAC std_ss [FORALL_PROD, IN_CROSS] THEN REPEAT CONJ_TAC THENL 614 [ASM_MESON_TAC[INTER_INTERVAL], 615 REPEAT STRIP_TAC THEN 616 MATCH_MP_TAC(SET_RULE 617 ``((interior x1 INTER interior x2 = {}) \/ 618 (interior y1 INTER interior y2 = {})) /\ 619 interior(x1 INTER y1) SUBSET interior(x1) /\ 620 interior(x1 INTER y1) SUBSET interior(y1) /\ 621 interior(x2 INTER y2) SUBSET interior(x2) /\ 622 interior(x2 INTER y2) SUBSET interior(y2) 623 ==> (interior(x1 INTER y1) INTER interior(x2 INTER y2) = {})``) THEN 624 CONJ_TAC THENL [ASM_MESON_TAC[], ALL_TAC] THEN 625 REPEAT CONJ_TAC THEN MATCH_MP_TAC SUBSET_INTERIOR THEN SET_TAC[], 626 REWRITE_TAC[SET_RULE ``BIGUNION {x | x IN s /\ ~(x = {})} = BIGUNION s``] THEN 627 REPEAT(FIRST_X_ASSUM(SUBST_ALL_TAC o SYM)) THEN 628 GEN_REWR_TAC I [EXTENSION] THEN 629 SIMP_TAC std_ss [IN_BIGUNION, IN_IMAGE, EXISTS_PROD, IN_CROSS, IN_INTER] THEN 630 MESON_TAC[IN_INTER]]); 631 632val DIVISION_INTER_1 = store_thm ("DIVISION_INTER_1", 633 ``!d i a b:real. 634 d division_of i /\ interval[a,b] SUBSET i 635 ==> { interval[a,b] INTER k | k | 636 k IN d /\ ~(interval[a,b] INTER k = {}) } 637 division_of interval[a,b]``, 638 REPEAT STRIP_TAC THEN 639 ASM_CASES_TAC ``interval[a:real,b] = {}`` THEN 640 ASM_SIMP_TAC std_ss [INTER_EMPTY, DIVISION_OF_TRIVIAL] THENL 641 [SET_TAC [], 642 MP_TAC(ISPECL [``interval[a:real,b]``, ``i:real->bool``, 643 ``{interval[a:real,b]}``, ``d:(real->bool)->bool``] 644 DIVISION_INTER) THEN 645 ASM_SIMP_TAC std_ss [DIVISION_OF_SELF, SET_RULE ``s SUBSET t ==> (s INTER t = s)``] THEN 646 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_TERM_TAC THEN 647 SIMP_TAC std_ss [EXTENSION, EXISTS_PROD, GSPECIFICATION] THEN SET_TAC[]]); 648 649val ELEMENTARY_INTER = store_thm ("ELEMENTARY_INTER", 650 ``!s t. (?p. p division_of s) /\ (?p. p division_of t) 651 ==> ?p. p division_of (s INTER t)``, 652 METIS_TAC[DIVISION_INTER]); 653 654val ELEMENTARY_BIGINTER = store_thm ("ELEMENTARY_BIGINTER", 655 ``!f:(real->bool)->bool. 656 FINITE f /\ ~(f = {}) /\ 657 (!s. s IN f ==> ?p. p division_of s) 658 ==> ?p. p division_of (BIGINTER f)``, 659 REWRITE_TAC[GSYM AND_IMP_INTRO] THEN GEN_TAC THEN 660 KNOW_TAC ``(f <> {} ==> 661 (!s. s IN f ==> ?p. p division_of s) ==> 662 ?p. p division_of BIGINTER f) = 663 (\f:(real->bool)->bool. (f <> {}) ==> 664 (!s. s IN f ==> ?p. p division_of s) ==> 665 ?p. p division_of BIGINTER f) f`` THENL 666 [FULL_SIMP_TAC std_ss [], ALL_TAC] THEN DISC_RW_KILL THEN 667 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 668 REWRITE_TAC[BIGINTER_INSERT] THEN SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM] THEN 669 MAP_EVERY X_GEN_TAC [``s:(real->bool)->bool``, ``s:real->bool``] THEN 670 ASM_CASES_TAC ``s:(real->bool)->bool = {}`` THEN ASM_REWRITE_TAC[] THENL 671 [REWRITE_TAC[BIGINTER_EMPTY, INTER_UNIV, IN_SING] THEN MESON_TAC[], 672 REWRITE_TAC[IN_INSERT] THEN REPEAT STRIP_TAC THEN 673 MATCH_MP_TAC ELEMENTARY_INTER THEN ASM_MESON_TAC[]]); 674 675val DIVISION_DISJOINT_UNION = store_thm ("DIVISION_DISJOINT_UNION", 676 ``!s1 s2:real->bool p1 p2. 677 p1 division_of s1 /\ p2 division_of s2 /\ 678 (interior s1 INTER interior s2 = {}) 679 ==> (p1 UNION p2) division_of (s1 UNION s2)``, 680 REPEAT GEN_TAC THEN REWRITE_TAC[division_of] THEN STRIP_TAC THEN 681 ASM_REWRITE_TAC[FINITE_UNION, IN_UNION, EXISTS_OR_THM, SET_RULE 682 ``BIGUNION {x | P x \/ Q x} = BIGUNION {x | P x} UNION BIGUNION {x | Q x}``] THEN 683 CONJ_TAC THENL [ASM_SET_TAC[], ALL_TAC] THEN 684 CONJ_TAC THENL [ALL_TAC, ASM_SET_TAC[]] THEN 685 REPEAT STRIP_TAC THENL 686 [ASM_SET_TAC[], ALL_TAC, ALL_TAC, ASM_SET_TAC[]] THEN 687 MATCH_MP_TAC(SET_RULE ``!s' t'. s SUBSET s' /\ t SUBSET t' /\ 688 (s' INTER t' = {}) ==> (s INTER t = {})``) 689 THENL 690 [MAP_EVERY EXISTS_TAC 691 [``interior s1:real->bool``, ``interior s2:real->bool``], 692 MAP_EVERY EXISTS_TAC 693 [``interior s2:real->bool``, ``interior s1:real->bool``]] THEN 694 REPEAT CONJ_TAC THEN TRY(MATCH_MP_TAC SUBSET_INTERIOR) THEN 695 ASM_SET_TAC[]); 696 697val PARTIAL_DIVISION_EXTEND_1 = store_thm ("PARTIAL_DIVISION_EXTEND_1", 698 ``!a b c d:real. 699 interval[c,d] SUBSET interval[a,b] /\ ~(interval[c,d] = {}) 700 ==> ?p. p division_of interval[a,b] /\ interval[c,d] IN p``, 701 REPEAT STRIP_TAC THEN ASM_CASES_TAC ``interval[a:real,b] = {}`` THENL 702 [ASM_SET_TAC[], ALL_TAC] THEN 703 POP_ASSUM (MP_TAC o REWRITE_RULE [INTERVAL_NE_EMPTY]) THEN 704 POP_ASSUM (MP_TAC o REWRITE_RULE [INTERVAL_NE_EMPTY]) THEN 705 REPEAT STRIP_TAC THEN 706 EXISTS_TAC 707 ``{interval 708 [(@f. f = if 1:num < l then (c:real) else (a:real)):real, 709 (@f. f = if 1:num < l then d else if 1:num = l then c else b)] | 710 l IN 1:num..(1+1:num)} UNION 711 {interval 712 [(@f. f = if 1:num < l then c else if 1:num = l then d else a), 713 (@f. f = if 1:num < l then (d:real) else (b:real)):real] | 714 l IN 1:num..(1+1:num)}`` THEN 715 MATCH_MP_TAC(TAUT `b /\ (b ==> a) ==> a /\ b`) THEN CONJ_TAC THENL 716 [REWRITE_TAC[IN_UNION] THEN DISJ1_TAC THEN 717 SIMP_TAC std_ss [GSPECIFICATION] THEN EXISTS_TAC ``1+1:num`` THEN 718 SIMP_TAC std_ss [IN_NUMSEG, LESS_EQ_REFL, ARITH_PROVE ``1 <= n + 1:num``], 719 DISCH_TAC] THEN 720 UNDISCH_TAC ``interval [(c,d)] SUBSET interval [(a,b)]`` THEN 721 GEN_REWR_TAC LAND_CONV [SUBSET_INTERVAL] THEN 722 ASM_REWRITE_TAC[DIVISION_OF] THEN DISCH_TAC THEN REPEAT CONJ_TAC THENL 723 [SIMP_TAC std_ss [GSYM IMAGE_DEF] THEN 724 SIMP_TAC std_ss [FINITE_UNION, IMAGE_FINITE, FINITE_NUMSEG], 725 REWRITE_TAC[IN_UNION, TAUT `a \/ b ==> c <=> (a ==> c) /\ (b ==> c)`] THEN 726 SIMP_TAC std_ss [GSYM IMAGE_DEF, FORALL_AND_THM, FORALL_IN_IMAGE] THEN 727 ASM_SIMP_TAC std_ss [IN_NUMSEG, INTERVAL_NE_EMPTY] THEN 728 CONJ_TAC THEN X_GEN_TAC ``l:num`` THEN DISCH_TAC THEN 729 (CONJ_TAC THENL [ALL_TAC, MESON_TAC[]]) THEN 730 REPEAT STRIP_TAC THEN 731 REPEAT (COND_CASES_TAC THEN ASM_SIMP_TAC std_ss []), 732 SIMP_TAC std_ss [IN_UNION, IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 733 SIMP_TAC std_ss [SET_RULE 734 ``(!y. y IN {f x | x IN s} \/ y IN {g x | x IN s} ==> P y) <=> 735 (!x. x IN s ==> P(f x) /\ P(g x))``] THEN 736 SIMP_TAC std_ss [GSYM FORALL_AND_THM, IN_NUMSEG] THEN 737 REWRITE_TAC[TAUT `(a ==> b) /\ (a ==> c) <=> a ==> b /\ c`] THEN 738 SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM] THEN 739 KNOW_TAC ``!l l'. (\l l'. 740 1:num <= l /\ l <= 2:num ==> 741 1:num <= l' /\ l' <= 2:num ==> 742 ((interval 743 [(if 1 < l then c else a, 744 if 1 < l then d else if 1 = l then c else b)] <> 745 interval 746 [(if 1 < l' then c else a, 747 if 1 < l' then d else if 1 = l' then c else b)] ==> 748 (interior 749 (interval 750 [(if 1 < l then c else a, 751 if 1 < l then d else if 1 = l then c else b)]) INTER 752 interior 753 (interval 754 [(if 1 < l' then c else a, 755 if 1 < l' then d else if 1 = l' then c else b)]) = 756 {})) /\ 757 (interval 758 [(if 1 < l then c else a, 759 if 1 < l then d else if 1 = l then c else b)] <> 760 interval 761 [(if 1 < l' then c else if 1 = l' then d else a, 762 if 1 < l' then d else b)] ==> 763 (interior 764 (interval 765 [(if 1 < l then c else a, 766 if 1 < l then d else if 1 = l then c else b)]) INTER 767 interior 768 (interval 769 [(if 1 < l' then c else if 1 = l' then d else a, 770 if 1 < l' then d else b)]) = 771 {}))) /\ 772 (interval 773 [(if 1 < l then c else if 1 = l then d else a, 774 if 1 < l then d else b)] <> 775 interval 776 [(if 1 < l' then c else a, 777 if 1 < l' then d else if 1 = l' then c else b)] ==> 778 (interior 779 (interval 780 [(if 1 < l then c else if 1 = l then d else a, 781 if 1 < l then d else b)]) INTER 782 interior 783 (interval 784 [(if 1 < l' then c else a, 785 if 1 < l' then d else if 1 = l' then c else b)]) = 786 {})) /\ 787 (interval 788 [(if 1 < l then c else if 1 = l then d else a, 789 if 1 < l then d else b)] <> 790 interval 791 [(if 1 < l' then c else if 1 = l' then d else a, 792 if 1 < l' then d else b)] ==> 793 (interior 794 (interval 795 [(if 1 < l then c else if 1 = l then d else a, 796 if 1 < l then d else b)]) INTER 797 interior 798 (interval 799 [(if 1 < l' then c else if 1 = l' then d else a, 800 if 1 < l' then d else b)]) = 801 {}))) l l'`` THENL 802 [ALL_TAC, SIMP_TAC std_ss []] THEN 803 MATCH_MP_TAC WLOG_LE THEN CONJ_TAC THENL 804 [SIMP_TAC std_ss [] THEN REPEAT GEN_TAC THEN 805 ONCE_REWRITE_TAC[TAUT `a ==> b ==> c <=> b ==> a ==> c`] THEN 806 SIMP_TAC std_ss [INTER_ACI, CONJ_ACI] THEN MESON_TAC[], 807 ALL_TAC] THEN 808 MAP_EVERY X_GEN_TAC [``l:num``, ``m:num``] THEN 809 SIMP_TAC std_ss [] THEN 810 DISCH_TAC THEN STRIP_TAC THEN STRIP_TAC THEN 811 ONCE_REWRITE_TAC[TAUT `(~p ==> q) <=> (~q ==> p)`, METIS [] ``(a <> b) = ~(a = b:real)``] THEN 812 REWRITE_TAC[INTERIOR_CLOSED_INTERVAL] THEN 813 REWRITE_TAC[SET_RULE ``(s INTER t = {}) <=> !x. ~(x IN s /\ x IN t)``, 814 METIS [] ``(a <> b) = ~(a = b:real)``] THEN 815 ASM_SIMP_TAC std_ss [IN_NUMSEG, INTERVAL_NE_EMPTY, IN_INTERVAL, 816 INTERIOR_CLOSED_INTERVAL] THEN 817 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN 818 REWRITE_TAC[TAUT `(a ==> b) /\ (a ==> c) <=> a ==> b /\ c`] THEN 819 SIMP_TAC std_ss [NOT_FORALL_THM] THEN REPEAT CONJ_TAC THEN 820 DISCH_THEN(X_CHOOSE_TAC ``x:real``) THEN 821 AP_TERM_TAC THEN SIMP_TAC std_ss [CONS_11, PAIR_EQ] THENL 822 [UNDISCH_TAC ``l:num <= m`` THEN GEN_REWR_TAC LAND_CONV [LESS_OR_EQ] THEN 823 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 824 UNDISCH_TAC ``((if 1:num < l then c else a) < x:real /\ 825 x:real < if 1:num < l then d else if 1 = l then c else b) /\ 826 (if 1:num < m then c else a) < x:real /\ 827 x:real < if 1:num < m then d else if 1 = m then c else b`` THEN 828 ASM_SIMP_TAC arith_ss [] THEN METIS_TAC [REAL_LT_ANTISYM], 829 UNDISCH_TAC ``l:num <= m`` THEN GEN_REWR_TAC LAND_CONV [LESS_OR_EQ] THEN 830 STRIP_TAC THEN ASM_REWRITE_TAC[] THENL 831 [UNDISCH_TAC ``((if 1:num < l then c else a) < x:real /\ 832 x:real < if 1:num < l then d else if 1 = l then c else b) /\ 833 (if 1:num < m then c else if 1 = m then d else a) < x:real /\ 834 x:real < if 1:num < m then d else b`` THEN 835 ASM_SIMP_TAC arith_ss [] THEN METIS_TAC [REAL_LT_ANTISYM], ALL_TAC] THEN 836 FIRST_X_ASSUM(SUBST_ALL_TAC o SYM) THEN 837 CONJ_TAC THEN ASM_CASES_TAC ``1:num = l`` THEN 838 ASM_SIMP_TAC arith_ss [LESS_REFL] THEN FIRST_X_ASSUM SUBST_ALL_TAC THEN 839 UNDISCH_TAC `` ((if l:num < l then c else a) < x:real /\ 840 x:real < if l:num < l then d else if l = l then c else b) /\ 841 (if l:num < l then c else if l = l then d else a) < x:real /\ 842 x:real < if l:num < l then d else b`` THEN 843 ASM_SIMP_TAC arith_ss [LESS_REFL] THEN 844 ASM_REAL_ARITH_TAC, 845 UNDISCH_TAC ``l:num <= m`` THEN GEN_REWR_TAC LAND_CONV [LESS_OR_EQ] THEN 846 STRIP_TAC THEN ASM_REWRITE_TAC[] THENL 847 [UNDISCH_TAC `` ((if 1:num < l then c else if 1 = l then d else a) < x:real /\ 848 x:real < if 1:num < l then d else b) /\ 849 (if 1:num < m then c else a) < x:real /\ 850 x:real < if 1:num < m then d else if 1 = m then c else b`` THEN 851 ASM_SIMP_TAC arith_ss [] THEN METIS_TAC [REAL_LT_ANTISYM], ALL_TAC] THEN 852 FIRST_X_ASSUM(SUBST_ALL_TAC o SYM) THEN 853 CONJ_TAC THEN ASM_CASES_TAC ``1:num = l`` THEN 854 ASM_SIMP_TAC arith_ss [LESS_REFL] THEN FIRST_X_ASSUM SUBST_ALL_TAC THEN 855 UNDISCH_TAC ``((if l:num < l then c else if l = l then d else a) < x:real /\ 856 x:real < if l:num < l then d else b) /\ 857 (if l:num < l then c else a) < x:real /\ 858 x:real < if l:num < l then d else if l = l then c else b`` THEN 859 ASM_SIMP_TAC arith_ss [LESS_REFL] THEN 860 ASM_REAL_ARITH_TAC, 861 UNDISCH_TAC ``l:num <= m`` THEN GEN_REWR_TAC LAND_CONV [LESS_OR_EQ] THEN 862 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 863 UNDISCH_TAC ``((if 1:num < l then c else if 1 = l then d else a) < x:real /\ 864 x:real < if 1:num < l then d else b) /\ 865 (if 1:num < m then c else if 1 = m then d else a) < x:real /\ 866 x:real < if 1:num < m then d else b`` THEN 867 ASM_SIMP_TAC arith_ss [] THEN METIS_TAC [REAL_LT_ANTISYM]], 868 MATCH_MP_TAC SUBSET_ANTISYM THEN CONJ_TAC THENL 869 [SIMP_TAC std_ss [IMP_CONJ, SUBSET_DEF, FORALL_IN_BIGUNION, GSYM IMAGE_DEF] THEN 870 SIMP_TAC std_ss [IN_BIGUNION, IN_INSERT, IN_UNION, FORALL_IN_IMAGE, 871 RIGHT_FORALL_IMP_THM, FORALL_AND_THM, 872 TAUT `(a \/ b ==> c) <=> (a ==> c) /\ (b ==> c)`] THEN 873 ASM_SIMP_TAC std_ss [IN_INTERVAL, IN_NUMSEG] THEN 874 REPEAT CONJ_TAC THEN GEN_TAC THEN DISCH_TAC THEN GEN_TAC THEN 875 METIS_TAC[REAL_LE_TRANS], ALL_TAC] THEN 876 FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP (SET_RULE 877 ``a IN s ==> (c DIFF a) SUBSET BIGUNION s ==> c SUBSET BIGUNION s``)) THEN 878 REWRITE_TAC[SUBSET_DEF, IN_DIFF, IN_INTERVAL] THEN X_GEN_TAC ``x:real`` THEN 879 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 880 SIMP_TAC std_ss [NOT_FORALL_THM, NOT_IMP] THEN 881 REWRITE_TAC [GSYM DE_MORGAN_THM] THEN DISCH_TAC THEN 882 SIMP_TAC std_ss [IN_BIGUNION] THEN ONCE_REWRITE_TAC [CONJ_SYM] THEN 883 SIMP_TAC std_ss [IN_BIGUNION, GSYM IMAGE_DEF, EXISTS_IN_IMAGE, IN_UNION, 884 EXISTS_OR_THM, RIGHT_AND_OVER_OR] THEN 885 SIMP_TAC std_ss [OR_EXISTS_THM] THEN EXISTS_TAC ``1:num`` THEN 886 ASM_SIMP_TAC std_ss [IN_NUMSEG, IN_INTERVAL, 887 ARITH_PROVE ``x <= n ==> x <= n + 1:num``] THEN 888 POP_ASSUM (MP_TAC o REWRITE_RULE [DE_MORGAN_THM]) THEN 889 MATCH_MP_TAC MONO_OR THEN REWRITE_TAC[REAL_NOT_LE] THEN 890 METIS_TAC [REAL_LE_LT]]); 891 892val PARTIAL_DIVISION_EXTEND_INTERVAL = store_thm ("PARTIAL_DIVISION_EXTEND_INTERVAL", 893 ``!p a b:real. 894 p division_of (BIGUNION p) /\ (BIGUNION p) SUBSET interval[a,b] 895 ==> ?q. p SUBSET q /\ q division_of interval[a,b]``, 896 REPEAT GEN_TAC THEN ASM_CASES_TAC ``p:(real->bool)->bool = {}`` THEN 897 ASM_REWRITE_TAC[EMPTY_SUBSET] THENL 898 [MESON_TAC[ELEMENTARY_INTERVAL], STRIP_TAC] THEN 899 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 900 SUBGOAL_THEN ``!k:real->bool. k IN p ==> ?q. q division_of interval[a,b] /\ 901 k IN q`` MP_TAC THENL 902 [X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 903 UNDISCH_TAC ``p division_of BIGUNION p`` THEN DISCH_TAC THEN 904 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 905 ASM_REWRITE_TAC [] THEN STRIP_TAC THEN 906 UNDISCH_TAC ``(!k. k IN p ==> 907 k SUBSET BIGUNION p /\ k <> {} /\ ?a b. k = interval [(a,b)])`` THEN 908 DISCH_THEN (MP_TAC o SPEC ``k:real->bool``) THEN 909 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN FIRST_X_ASSUM SUBST_ALL_TAC THEN 910 MATCH_MP_TAC PARTIAL_DIVISION_EXTEND_1 THEN ASM_SET_TAC[], 911 ALL_TAC] THEN 912 KNOW_TAC ``(!(k :real -> bool). ?(q :(real -> bool) -> bool). 913 k IN (p :(real -> bool) -> bool) ==> 914 q division_of interval [((a :real),(b :real))] /\ k IN q) ==> 915 ?(q :(real -> bool) -> bool). 916 p SUBSET q /\ q division_of interval [(a,b)]`` THENL 917 [ALL_TAC, METIS_TAC [GSYM RIGHT_EXISTS_IMP_THM]] THEN 918 SIMP_TAC std_ss [SKOLEM_THM] THEN 919 DISCH_THEN(X_CHOOSE_TAC ``q:(real->bool)->(real->bool)->bool``) THEN 920 SUBGOAL_THEN 921 ``?d. d division_of BIGINTER {BIGUNION (q i DELETE i) | (i:real->bool) IN p}`` 922 MP_TAC THENL 923 [MATCH_MP_TAC ELEMENTARY_BIGINTER THEN SIMP_TAC std_ss [GSYM IMAGE_DEF] THEN 924 ASM_SIMP_TAC std_ss [IMAGE_EQ_EMPTY, IMAGE_FINITE] THEN 925 SIMP_TAC std_ss [FORALL_IN_IMAGE] THEN X_GEN_TAC ``k:real->bool`` THEN 926 DISCH_TAC THEN EXISTS_TAC ``(q k) DELETE (k:real->bool)`` THEN 927 MATCH_MP_TAC DIVISION_OF_SUBSET THEN 928 EXISTS_TAC ``(q:(real->bool)->(real->bool)->bool) k`` THEN 929 REWRITE_TAC[DELETE_SUBSET] THEN ASM_MESON_TAC[division_of], 930 ALL_TAC] THEN 931 DISCH_THEN(X_CHOOSE_TAC ``d:(real->bool)->bool``) THEN 932 EXISTS_TAC ``(d UNION p):(real->bool)->bool`` THEN 933 REWRITE_TAC[SUBSET_UNION] THEN 934 SUBGOAL_THEN ``interval[a:real,b] = 935 BIGINTER {BIGUNION (q i DELETE i) | i IN p} UNION 936 BIGUNION p`` SUBST1_TAC THENL 937 [SIMP_TAC std_ss [GSYM IMAGE_DEF] THEN MATCH_MP_TAC(SET_RULE 938 ``~(s = {}) /\ (!i. i IN s ==> (f i UNION i = t)) 939 ==> (t = BIGINTER (IMAGE f s) UNION (BIGUNION s))``) THEN 940 ASM_REWRITE_TAC[] THEN X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 941 BETA_TAC THEN MATCH_MP_TAC(SET_RULE 942 ``(BIGUNION k = s) /\ i IN k ==> (BIGUNION (k DELETE i) UNION i = s)``) THEN 943 ASM_MESON_TAC[division_of], ALL_TAC] THEN 944 MATCH_MP_TAC DIVISION_DISJOINT_UNION THEN ASM_REWRITE_TAC[] THEN 945 MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 946 ASM_REWRITE_TAC[OPEN_INTERIOR] THEN 947 CONJ_TAC THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 948 X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 949 MATCH_MP_TAC(SET_RULE 950 ``!s. u SUBSET s /\ (s INTER t = {}) ==> (u INTER t = {})``) THEN 951 EXISTS_TAC ``interior(BIGUNION(q k DELETE (k:real->bool)))`` THEN 952 CONJ_TAC THENL 953 [MATCH_MP_TAC SUBSET_INTERIOR THEN 954 MATCH_MP_TAC(SET_RULE ``x IN s ==> BIGINTER s SUBSET x``) THEN ASM_SET_TAC[], 955 ALL_TAC] THEN 956 ONCE_REWRITE_TAC[INTER_COMM] THEN 957 MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 958 REWRITE_TAC[OPEN_INTERIOR, FINITE_DELETE, IN_DELETE] THEN 959 ASM_MESON_TAC[division_of]); 960 961val ELEMENTARY_BOUNDED = store_thm ("ELEMENTARY_BOUNDED", 962 ``!s. (?p. p division_of s) ==> bounded s``, 963 REWRITE_TAC[division_of] THEN 964 METIS_TAC[BOUNDED_BIGUNION, BOUNDED_INTERVAL]); 965 966val ELEMENTARY_SUBSET_INTERVAL = store_thm ("ELEMENTARY_SUBSET_INTERVAL", 967 ``!s. (?p. p division_of s) ==> ?a b. s SUBSET interval[a,b]``, 968 MESON_TAC[ELEMENTARY_BOUNDED, BOUNDED_SUBSET_CLOSED_INTERVAL]); 969 970val DIVISION_UNION_INTERVALS_EXISTS = store_thm ("DIVISION_UNION_INTERVALS_EXISTS", 971 ``!a b c d:real. ~(interval[a,b] = {}) 972 ==> ?p. (interval[a,b] INSERT p) division_of 973 (interval[a,b] UNION interval[c,d])``, 974 REPEAT STRIP_TAC THEN 975 ASM_CASES_TAC ``interval[c:real,d] = {}`` THENL 976 [ASM_REWRITE_TAC[UNION_EMPTY] THEN ASM_MESON_TAC[DIVISION_OF_SELF], 977 ALL_TAC] THEN 978 ASM_CASES_TAC ``interval[a:real,b] INTER interval[c,d] = {}`` THENL 979 [EXISTS_TAC ``{interval[c:real,d]}`` THEN 980 ONCE_REWRITE_TAC[SET_RULE ``{a;b} = {a} UNION {b}``] THEN 981 MATCH_MP_TAC DIVISION_DISJOINT_UNION THEN 982 ASM_SIMP_TAC std_ss [DIVISION_OF_SELF] THEN 983 MATCH_MP_TAC(SET_RULE 984 ``interior s SUBSET s /\ interior t SUBSET t /\ (s INTER t = {}) 985 ==> (interior s INTER interior t = {})``) THEN 986 ASM_REWRITE_TAC[INTERIOR_SUBSET], ALL_TAC] THEN 987 SUBGOAL_THEN 988 ``?u v:real. interval[a,b] INTER interval[c,d] = interval[u,v]`` 989 STRIP_ASSUME_TAC THENL [MESON_TAC[INTER_INTERVAL], ALL_TAC] THEN 990 MP_TAC(ISPECL [``c:real``, ``d:real``, ``u:real``, ``v:real``] 991 PARTIAL_DIVISION_EXTEND_1) THEN 992 KNOW_TAC ``interval [(u,v)] SUBSET interval [(c,d)] /\ 993 (interval [(u,v)] <> {})`` THENL 994 [ASM_MESON_TAC[INTER_SUBSET], DISCH_TAC THEN ASM_REWRITE_TAC []] THEN 995 DISCH_THEN(X_CHOOSE_THEN ``p:(real->bool)->bool`` STRIP_ASSUME_TAC) THEN 996 EXISTS_TAC ``p DELETE interval[u:real,v]`` THEN 997 SUBGOAL_THEN ``interval[a:real,b] UNION interval[c,d] = 998 interval[a,b] UNION BIGUNION (p DELETE interval[u,v])`` 999 SUBST1_TAC THENL 1000 [UNDISCH_TAC ``p division_of interval [c,d]`` THEN DISCH_TAC THEN 1001 FIRST_ASSUM(SUBST1_TAC o SYM o last o CONJUNCTS o 1002 REWRITE_RULE [division_of]) THEN 1003 ASM_SET_TAC[], ALL_TAC] THEN 1004 ONCE_REWRITE_TAC[SET_RULE ``x INSERT s = {x} UNION s``] THEN 1005 MATCH_MP_TAC DIVISION_DISJOINT_UNION THEN 1006 ASM_SIMP_TAC std_ss [DIVISION_OF_SELF] THEN CONJ_TAC THENL 1007 [MATCH_MP_TAC DIVISION_OF_SUBSET THEN 1008 EXISTS_TAC ``p:(real->bool)->bool`` THEN 1009 ASM_MESON_TAC[DIVISION_OF_UNION_SELF, DELETE_SUBSET], 1010 ALL_TAC] THEN 1011 REWRITE_TAC[GSYM INTERIOR_INTER] THEN 1012 MATCH_MP_TAC EQ_TRANS THEN 1013 EXISTS_TAC ``interior(interval[u:real,v] INTER 1014 BIGUNION (p DELETE interval[u,v]))`` THEN 1015 CONJ_TAC THENL 1016 [AP_TERM_TAC THEN MATCH_MP_TAC(SET_RULE 1017 ``!cd. p SUBSET cd /\ (uv = ab INTER cd) 1018 ==> (ab INTER p = uv INTER p)``) THEN 1019 EXISTS_TAC ``interval[c:real,d]`` THEN 1020 ASM_REWRITE_TAC[BIGUNION_SUBSET, IN_DELETE] THEN 1021 ASM_MESON_TAC[division_of], 1022 REWRITE_TAC[INTERIOR_INTER] THEN 1023 MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 1024 REWRITE_TAC[IN_DELETE, OPEN_INTERIOR, FINITE_DELETE] THEN 1025 ASM_MESON_TAC[division_of]]); 1026 1027val DIVISION_OF_BIGUNION = store_thm ("DIVISION_OF_BIGUNION", 1028 ``!f. FINITE f /\ 1029 (!p. p IN f ==> p division_of (BIGUNION p)) /\ 1030 (!k1 k2. k1 IN BIGUNION f /\ k2 IN BIGUNION f /\ ~(k1 = k2) 1031 ==> (interior k1 INTER interior k2 = {})) 1032 ==> (BIGUNION f) division_of BIGUNION (BIGUNION f)``, 1033REWRITE_TAC[division_of] THEN 1034SIMP_TAC std_ss [FINITE_BIGUNION] THEN SIMP_TAC std_ss [FORALL_IN_BIGUNION] THEN 1035GEN_TAC THEN SET_TAC[]); 1036 1037val ELEMENTARY_UNION_INTERVAL_STRONG = store_thm ("ELEMENTARY_UNION_INTERVAL_STRONG", 1038 ``!p a b:real. p division_of (BIGUNION p) 1039 ==> ?q. p SUBSET q /\ q division_of (interval[a,b] UNION BIGUNION p)``, 1040 REPEAT STRIP_TAC THEN ASM_CASES_TAC ``p:(real->bool)->bool = {}`` THENL 1041 [ASM_REWRITE_TAC[BIGUNION_EMPTY, UNION_EMPTY, EMPTY_SUBSET] THEN 1042 MESON_TAC[ELEMENTARY_INTERVAL], 1043 ALL_TAC] THEN 1044 ASM_CASES_TAC ``interval[a:real,b] = {}`` THEN 1045 ASM_REWRITE_TAC[UNION_EMPTY] THENL [ASM_MESON_TAC[SUBSET_REFL], ALL_TAC] THEN 1046 ASM_CASES_TAC ``interior(interval[a:real,b]) = {}`` THENL 1047 [EXISTS_TAC ``interval[a:real,b] INSERT p`` THEN 1048 REWRITE_TAC[division_of] THEN 1049 UNDISCH_TAC ``p division_of BIGUNION p`` THEN DISCH_TAC THEN 1050 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 1051 SIMP_TAC std_ss [FINITE_INSERT, BIGUNION_INSERT] THEN ASM_SET_TAC[], 1052 ALL_TAC] THEN 1053 ASM_CASES_TAC ``interval[a:real,b] SUBSET BIGUNION p`` THENL 1054 [ASM_SIMP_TAC std_ss [SET_RULE ``s SUBSET t ==> (s UNION t = t)``] THEN 1055 ASM_MESON_TAC[SUBSET_REFL], ALL_TAC] THEN 1056 SUBGOAL_THEN 1057 ``!k:real->bool. k IN p 1058 ==> ?q. ~(k IN q) /\ ~(q = {}) /\ 1059 (k INSERT q) division_of (interval[a,b] UNION k)`` 1060 MP_TAC THENL 1061 [X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 1062 UNDISCH_TAC ``p division_of BIGUNION p`` THEN DISCH_TAC THEN 1063 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 1064 DISCH_THEN(MP_TAC o SPEC ``k:real->bool`` o CONJUNCT1 o CONJUNCT2) THEN 1065 ASM_REWRITE_TAC[] THEN 1066 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 1067 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 1068 MAP_EVERY X_GEN_TAC [``c:real``, ``d:real``] THEN 1069 DISCH_THEN SUBST_ALL_TAC THEN 1070 ONCE_REWRITE_TAC[UNION_COMM] THEN 1071 MP_TAC(ISPECL [``c:real``, ``d:real``, ``a:real``, ``b:real``] 1072 DIVISION_UNION_INTERVALS_EXISTS) THEN 1073 ASM_REWRITE_TAC[] THEN 1074 DISCH_THEN(X_CHOOSE_TAC ``q:(real->bool)->bool``) THEN 1075 EXISTS_TAC ``q DELETE interval[c:real,d]`` THEN 1076 ASM_REWRITE_TAC[IN_DELETE, SET_RULE 1077 ``x INSERT (q DELETE x) = x INSERT q``] THEN 1078 DISCH_TAC THEN 1079 UNDISCH_TAC ``(interval[c:real,d] INSERT q) division_of 1080 (interval [c,d] UNION interval [a,b])`` THEN 1081 ASM_SIMP_TAC std_ss [SET_RULE ``(s DELETE x = {}) ==> (x INSERT s = {x})``] THEN 1082 REWRITE_TAC[division_of, BIGUNION_SING] THEN ASM_SET_TAC[], ALL_TAC] THEN 1083 KNOW_TAC ``(!(k :real -> bool). ?(q :(real -> bool) -> bool). 1084 k IN (p :(real -> bool) -> bool) ==> 1085 k NOTIN q /\ q <> ({} :(real -> bool) -> bool) /\ 1086 k INSERT q division_of 1087 interval [((a :real),(b :real))] UNION k) ==> 1088 ?(q :(real -> bool) -> bool). 1089 p SUBSET q /\ q division_of interval [(a,b)] UNION BIGUNION p`` THENL 1090 [ALL_TAC, METIS_TAC [GSYM RIGHT_EXISTS_IMP_THM]] THEN SIMP_TAC std_ss [SKOLEM_THM] THEN 1091 DISCH_THEN(X_CHOOSE_TAC ``q:(real->bool)->(real->bool)->bool``) THEN 1092 MP_TAC(ISPEC ``IMAGE (BIGUNION o (q:(real->bool)->(real->bool)->bool)) p`` 1093 ELEMENTARY_BIGINTER) THEN 1094 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 1095 ASM_SIMP_TAC std_ss [IMAGE_FINITE, IMAGE_EQ_EMPTY, FORALL_IN_IMAGE] THEN 1096 KNOW_TAC ``(!(x :real -> bool). 1097 x IN (p :(real -> bool) -> bool) ==> ?(p' :(real -> bool) -> bool). 1098 p' division_of BIGUNION ((q :(real -> bool) -> (real -> bool) -> bool) x))`` THENL 1099 [X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 1100 EXISTS_TAC ``(q:(real->bool)->(real->bool)->bool) k`` THEN 1101 SIMP_TAC std_ss [o_THM] THEN MATCH_MP_TAC DIVISION_OF_SUBSET THEN 1102 EXISTS_TAC ``(k:real->bool) INSERT q k`` THEN 1103 CONJ_TAC THENL [ASM_MESON_TAC[DIVISION_OF_UNION_SELF], SET_TAC[]], 1104 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 1105 DISCH_THEN(X_CHOOSE_TAC ``r:(real->bool)->bool``)] THEN 1106 EXISTS_TAC ``p UNION r:(real->bool)->bool`` THEN SIMP_TAC std_ss [SUBSET_UNION] THEN 1107 SUBGOAL_THEN 1108 ``interval[a:real,b] UNION BIGUNION p = 1109 BIGUNION p UNION BIGINTER (IMAGE (BIGUNION o q) p)`` 1110 SUBST1_TAC THENL 1111 [GEN_REWR_TAC I [EXTENSION] THEN X_GEN_TAC ``y:real`` THEN 1112 REWRITE_TAC[IN_UNION] THEN 1113 ASM_CASES_TAC ``(y:real) IN BIGUNION p`` THEN ASM_REWRITE_TAC[IN_BIGINTER] THEN 1114 SIMP_TAC std_ss [FORALL_IN_BIGUNION, IMP_CONJ, FORALL_IN_IMAGE, 1115 RIGHT_FORALL_IMP_THM] THEN 1116 SUBGOAL_THEN 1117 ``!k. k IN p ==> (BIGUNION(k INSERT q k) = interval[a:real,b] UNION k)`` 1118 MP_TAC THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 1119 SIMP_TAC std_ss [BIGUNION_INSERT, o_THM] THEN 1120 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) [EXTENSION] THEN 1121 SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM, IN_UNION] THEN 1122 KNOW_TAC ``(!(x :real) (k :real -> bool). 1123 k IN (p :(real -> bool) -> bool) ==> 1124 (x IN k \/ 1125 x IN BIGUNION ((q :(real -> bool) -> (real -> bool) -> bool) k) <=> 1126 x IN interval [((a :real),(b :real))] \/ x IN k)) ==> 1127 ((y :real) IN interval [(a,b)] <=> 1128 !(x :real -> bool). x IN p ==> y IN BIGUNION (q x))`` THENL 1129 [ALL_TAC, METIS_TAC [SWAP_FORALL_THM]] THEN 1130 DISCH_THEN(MP_TAC o SPEC ``y:real``) THEN 1131 UNDISCH_TAC ``~((y:real) IN BIGUNION p)`` THEN 1132 SIMP_TAC std_ss [IN_BIGUNION, NOT_EXISTS_THM, TAUT `~(a /\ b) <=> a ==> ~b`] THEN 1133 ASM_CASES_TAC ``(y:real) IN interval[a,b]`` THEN 1134 ASM_REWRITE_TAC[] THEN ASM_SET_TAC[], ALL_TAC] THEN 1135 MATCH_MP_TAC DIVISION_DISJOINT_UNION THEN 1136 ASM_REWRITE_TAC[] THEN ONCE_REWRITE_TAC[INTER_COMM] THEN 1137 MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 1138 ASM_REWRITE_TAC[OPEN_INTERIOR] THEN 1139 CONJ_TAC THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 1140 X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 1141 ASM_SIMP_TAC std_ss [INTERIOR_FINITE_BIGINTER, IMAGE_FINITE] THEN 1142 MATCH_MP_TAC(SET_RULE ``(?x. x IN p /\ (f x INTER s = {})) 1143 ==> (BIGINTER (IMAGE f p) INTER s = {})``) THEN 1144 SIMP_TAC std_ss [EXISTS_IN_IMAGE, o_THM] THEN EXISTS_TAC ``k:real->bool`` THEN 1145 ASM_REWRITE_TAC[] THEN 1146 ONCE_REWRITE_TAC[INTER_COMM] THEN 1147 MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 1148 ASM_REWRITE_TAC[OPEN_INTERIOR] THEN REPEAT CONJ_TAC THENL 1149 [ASM_MESON_TAC[division_of, FINITE_INSERT, IN_INSERT], 1150 ASM_MESON_TAC[division_of, FINITE_INSERT, IN_INSERT], 1151 ALL_TAC] THEN 1152 UNDISCH_TAC ``!k. k IN p ==> k NOTIN q k /\ q k <> {} /\ 1153 k INSERT q k division_of interval [(a,b)] UNION k`` THEN DISCH_TAC THEN 1154 FIRST_X_ASSUM(MP_TAC o SPEC ``k:real->bool``) THEN 1155 ASM_REWRITE_TAC[division_of, IN_INSERT] THEN 1156REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_MESON_TAC[]); 1157 1158val ELEMENTARY_UNION_INTERVAL = store_thm ("ELEMENTARY_UNION_INTERVAL", 1159 ``!p a b:real. p division_of (BIGUNION p) 1160 ==> ?q. q division_of (interval[a,b] UNION BIGUNION p)``, 1161 MESON_TAC[ELEMENTARY_UNION_INTERVAL_STRONG]); 1162 1163val ELEMENTARY_BIGUNION_INTERVALS = store_thm ("ELEMENTARY_BIGUNION_INTERVALS", 1164 ``!f. FINITE f /\ 1165 (!s. s IN f ==> ?a b:real. s = interval[a,b]) 1166 ==> (?p. p division_of (BIGUNION f))``, 1167 REWRITE_TAC[IMP_CONJ] THEN 1168 KNOW_TAC ``!f. ((!s. s IN f ==> ?a b. s = interval [(a,b)]) ==> 1169 ?p. p division_of BIGUNION f) = 1170 (\f. (!s. s IN f ==> ?a b. s = interval [(a,b)]) ==> 1171 ?p. p division_of BIGUNION f) f`` THENL 1172 [SIMP_TAC std_ss [], DISC_RW_KILL] THEN 1173 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 1174 SIMP_TAC std_ss [BIGUNION_EMPTY, BIGUNION_INSERT, ELEMENTARY_EMPTY] THEN 1175 SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM] THEN 1176 SIMP_TAC std_ss [IN_INSERT, TAUT `a \/ b ==> c <=> (a ==> c) /\ (b ==> c)`] THEN 1177 SIMP_TAC std_ss [FORALL_AND_THM, LEFT_FORALL_IMP_THM, EXISTS_REFL] THEN 1178 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC [METIS [] ``(a ==> b ==> c ==> d) = 1179 (c ==> a ==> b ==> d)``] THEN STRIP_TAC THEN 1180 ASM_REWRITE_TAC[] THEN REPEAT STRIP_TAC THEN 1181 SUBGOAL_THEN ``BIGUNION s:real->bool = BIGUNION p`` SUBST1_TAC THENL 1182 [METIS_TAC[division_of], ALL_TAC] THEN 1183 MATCH_MP_TAC ELEMENTARY_UNION_INTERVAL THEN ASM_MESON_TAC[division_of]); 1184 1185val ELEMENTARY_UNION = store_thm ("ELEMENTARY_UNION", 1186 ``!s t:real->bool. 1187 (?p. p division_of s) /\ (?p. p division_of t) 1188 ==> (?p. p division_of (s UNION t))``, 1189 REPEAT GEN_TAC THEN DISCH_THEN 1190 (CONJUNCTS_THEN2 (X_CHOOSE_TAC ``p1:(real->bool)->bool``) 1191 (X_CHOOSE_TAC ``p2:(real->bool)->bool``)) THEN 1192 SUBGOAL_THEN ``s UNION t :real->bool = BIGUNION p1 UNION BIGUNION p2`` 1193 SUBST1_TAC THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 1194 REWRITE_TAC[SET_RULE ``BIGUNION p1 UNION BIGUNION p2 = BIGUNION (p1 UNION p2)``] THEN 1195 MATCH_MP_TAC ELEMENTARY_BIGUNION_INTERVALS THEN 1196 REWRITE_TAC[IN_UNION, FINITE_UNION] THEN 1197 ASM_MESON_TAC[division_of]); 1198 1199val PARTIAL_DIVISION_EXTEND = store_thm ("PARTIAL_DIVISION_EXTEND", 1200 ``!p q s t:real->bool. 1201 p division_of s /\ q division_of t /\ s SUBSET t 1202 ==> ?r. p SUBSET r /\ r division_of t``, 1203 REPEAT STRIP_TAC THEN 1204 SUBGOAL_THEN ``?a b:real. t SUBSET interval[a,b]`` MP_TAC THENL 1205 [ASM_MESON_TAC[ELEMENTARY_SUBSET_INTERVAL], ALL_TAC] THEN 1206 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 1207 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN DISCH_TAC THEN 1208 SUBGOAL_THEN ``?r1. p SUBSET r1 /\ r1 division_of interval[a:real,b]`` 1209 STRIP_ASSUME_TAC THENL 1210 [MATCH_MP_TAC PARTIAL_DIVISION_EXTEND_INTERVAL THEN 1211 ASM_MESON_TAC[division_of, SUBSET_TRANS], ALL_TAC] THEN 1212 SUBGOAL_THEN ``?r2:(real->bool)->bool. 1213 r2 division_of (BIGUNION (r1 DIFF p)) INTER (BIGUNION q)`` 1214 STRIP_ASSUME_TAC THENL 1215 [MATCH_MP_TAC ELEMENTARY_INTER THEN 1216 ASM_MESON_TAC[FINITE_DIFF, IN_DIFF, division_of, 1217 ELEMENTARY_BIGUNION_INTERVALS], ALL_TAC] THEN 1218 EXISTS_TAC ``p UNION r2:(real->bool)->bool`` THEN 1219 CONJ_TAC THENL [SET_TAC[], ALL_TAC] THEN 1220 SUBGOAL_THEN 1221 ``t:real->bool = BIGUNION p UNION (BIGUNION (r1 DIFF p) INTER BIGUNION q)`` 1222 SUBST1_TAC THENL 1223 [REPEAT(FIRST_X_ASSUM(MP_TAC o last o CONJUNCTS o 1224 REWRITE_RULE [division_of])) THEN 1225 REPEAT(POP_ASSUM MP_TAC) THEN SET_TAC[], 1226 MATCH_MP_TAC DIVISION_DISJOINT_UNION THEN ASM_REWRITE_TAC[] THEN 1227 CONJ_TAC THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 1228 MATCH_MP_TAC(SET_RULE 1229 ``!t'. t SUBSET t' /\ (s INTER t' = {}) ==> (s INTER t = {})``) THEN 1230 EXISTS_TAC ``interior(BIGUNION (r1 DIFF p)):real->bool`` THEN 1231 CONJ_TAC THENL [MATCH_MP_TAC SUBSET_INTERIOR THEN SET_TAC[], ALL_TAC] THEN 1232 REPEAT(MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 1233 REWRITE_TAC[OPEN_INTERIOR] THEN REPEAT(CONJ_TAC THENL 1234 [ASM_MESON_TAC[IN_DIFF, FINITE_DIFF, division_of], ALL_TAC]) THEN 1235 REWRITE_TAC[IN_DIFF] THEN REPEAT STRIP_TAC THEN 1236 ONCE_REWRITE_TAC[INTER_COMM]) THEN 1237 ASM_MESON_TAC[division_of, SUBSET_DEF]]); 1238 1239val INTERVAL_SUBDIVISION = store_thm ("INTERVAL_SUBDIVISION", 1240 ``!a b c:real. c IN interval[a,b] 1241 ==> (IMAGE (\s. interval[(@f. f = if 1:num IN s then c else a), 1242 (@f. f = if 1:num IN s then b else c)]) 1243 {s | s SUBSET (1:num..1:num)}) division_of interval[a,b]``, 1244 REPEAT STRIP_TAC THEN 1245 FIRST_ASSUM(ASSUME_TAC o REWRITE_RULE [IN_INTERVAL]) THEN 1246 REWRITE_TAC[DIVISION_OF] THEN 1247 SIMP_TAC std_ss [IMAGE_FINITE, FINITE_POWERSET, FINITE_NUMSEG] THEN 1248 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_IMAGE] THEN 1249 SIMP_TAC std_ss [FORALL_IN_GSPEC, SUBSET_INTERVAL, INTERVAL_NE_EMPTY] THEN 1250 REWRITE_TAC[INTERIOR_CLOSED_INTERVAL] THEN REPEAT CONJ_TAC THENL 1251 [METIS_TAC[REAL_LE_TRANS], 1252 X_GEN_TAC ``s:num->bool`` THEN DISCH_TAC THEN 1253 X_GEN_TAC ``s':num->bool`` THEN DISCH_TAC THEN 1254 REWRITE_TAC[SET_RULE 1255 ``(~p ==> (s INTER t = {})) <=> (!x. x IN s /\ x IN t ==> p)``, 1256 METIS [] ``(a <> b) = ~(a = b)``] THEN 1257 X_GEN_TAC ``x:real`` THEN SIMP_TAC std_ss [IN_INTERVAL, GSYM FORALL_AND_THM] THEN 1258 ASM_CASES_TAC ``s':num->bool = s`` THEN ASM_REWRITE_TAC[] THEN 1259 FIRST_X_ASSUM(MP_TAC o MATCH_MP (SET_RULE 1260 ``~(s' = s) ==> ?x. x IN s' /\ ~(x IN s) \/ x IN s /\ ~(x IN s')``)) THEN 1261 FULL_SIMP_TAC std_ss [NUMSEG_SING, IN_SING, SUBSET_DEF] THEN 1262 DISCH_THEN(X_CHOOSE_THEN ``k:num`` STRIP_ASSUME_TAC) THEN 1263 (POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1264 POP_ASSUM (MP_TAC o Q.SPEC `k:num`) THEN POP_ASSUM (MP_TAC o Q.SPEC `k:num`) THEN 1265 DISCH_TAC THEN DISCH_TAC THEN DISCH_TAC THEN DISCH_TAC THEN 1266 FULL_SIMP_TAC std_ss [] THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1267 ASM_REWRITE_TAC [] THEN DISCH_TAC THEN DISCH_TAC THEN 1268 ASM_REWRITE_TAC [] THEN METIS_TAC [REAL_LT_ANTISYM]), 1269 MATCH_MP_TAC SUBSET_ANTISYM THEN CONJ_TAC THEN 1270 GEN_REWR_TAC I [SUBSET_DEF] THENL 1271 [SIMP_TAC std_ss [FORALL_IN_BIGUNION] THEN 1272 KNOW_TAC ``(!(x :real) (t :real -> bool). 1273 t IN IMAGE (\(s :num -> bool). 1274 interval 1275 [(if (1 :num) IN s then (c :real) else (a :real), 1276 if (1 :num) IN s then (b :real) else c)]) 1277 {s | s SUBSET ((1 :num) .. (1 :num))} /\ x IN t ==> 1278 x IN interval [(a,b)])`` THENL 1279 [ALL_TAC, METIS_TAC [SWAP_FORALL_THM]] THEN 1280 SIMP_TAC std_ss [IMP_CONJ, FORALL_IN_IMAGE, FORALL_IN_GSPEC] THEN 1281 KNOW_TAC ``(!(s :num -> bool) (x :real). 1282 s SUBSET ((1 :num) .. (1 :num)) ==> 1283 x IN interval 1284 [(if (1 :num) IN s then (c :real) else (a :real), 1285 if (1 :num) IN s then (b :real) else c)] ==> 1286 x IN interval [(a,b)])`` THENL 1287 [ALL_TAC, METIS_TAC [SWAP_FORALL_THM]] THEN 1288 SIMP_TAC std_ss [RIGHT_FORALL_IMP_THM, GSYM SUBSET_DEF] THEN 1289 SIMP_TAC std_ss [SUBSET_INTERVAL] THEN 1290 METIS_TAC[REAL_LE_TRANS, REAL_LE_REFL], 1291 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 1292 REWRITE_TAC [IN_BIGUNION] THEN ONCE_REWRITE_TAC [CONJ_SYM] THEN 1293 SIMP_TAC std_ss [EXISTS_IN_IMAGE, EXISTS_IN_GSPEC] THEN 1294 EXISTS_TAC ``{i | i IN (1:num..1:num) /\ (c:real) <= (x:real)}`` THEN 1295 CONJ_TAC THENL [SET_TAC[], REWRITE_TAC[IN_INTERVAL]] THEN 1296 SIMP_TAC std_ss [GSPECIFICATION, IN_NUMSEG] THEN 1297 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 1298 METIS_TAC[REAL_LE_TOTAL]]]); 1299 1300val DIVISION_OF_NONTRIVIAL = store_thm ("DIVISION_OF_NONTRIVIAL", 1301 ``!s a b:real. 1302 s division_of interval[a,b] /\ ~(content(interval[a,b]) = &0) 1303 ==> {k | k IN s /\ ~(content k = &0)} division_of interval[a,b]``, 1304 REPEAT GEN_TAC THEN completeInduct_on `CARD(s:(real->bool)->bool)` THEN 1305 GEN_TAC THEN DISCH_TAC THEN FULL_SIMP_TAC std_ss [] THEN POP_ASSUM K_TAC THEN 1306 REPEAT STRIP_TAC THEN 1307 ASM_CASES_TAC ``{k:real->bool | k IN s /\ ~(content k = &0)} = s`` THEN 1308 ASM_REWRITE_TAC[] THEN 1309 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [EXTENSION]) THEN 1310 SIMP_TAC std_ss [GSPECIFICATION, NOT_FORALL_THM, LEFT_IMP_EXISTS_THM] THEN 1311 REWRITE_TAC[TAUT `~(a /\ ~b <=> a) <=> a /\ b`] THEN 1312 X_GEN_TAC ``k:real->bool`` THEN STRIP_TAC THEN 1313 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 1314 UNDISCH_TAC `` !(m :num). 1315 m < CARD (s :(real -> bool) -> bool) ==> 1316 !(s :(real -> bool) -> bool). 1317 (m = CARD s) ==> 1318 s division_of interval [((a :real),(b :real))] /\ 1319 content (interval [(a,b)]) <> (0 :real) ==> 1320 {k | k IN s /\ content k <> (0 :real)} division_of 1321 interval [(a,b)]`` THEN DISCH_TAC THEN 1322 FIRST_X_ASSUM(MP_TAC o SPEC ``CARD (s DELETE (k:real->bool))``) THEN 1323 ASM_SIMP_TAC std_ss [CARD_DELETE, ARITH_PROVE ``n - 1 < n <=> ~(n = 0:num)``] THEN 1324 ASM_SIMP_TAC std_ss [CARD_EQ_0] THEN 1325 KNOW_TAC ``(s :(real -> bool) -> bool) <> {}`` THENL [ASM_SET_TAC[], 1326 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 1327 DISCH_THEN (MP_TAC o SPEC ``(s :(real -> bool) -> bool) DELETE k``) THEN 1328 ASM_SIMP_TAC std_ss [CARD_DELETE, ARITH_PROVE ``n - 1 < n <=> ~(n = 0:num)``] THEN 1329 KNOW_TAC ``s DELETE (k:real->bool) division_of interval [(a,b)]`` THENL 1330 [ALL_TAC, 1331 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 1332 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_TERM_TAC THEN 1333 ASM_SET_TAC[]] THEN 1334 REWRITE_TAC[DIVISION_OF] THEN 1335 UNDISCH_TAC ``s division_of interval [(a,b)]`` THEN DISCH_TAC THEN 1336 FIRST_X_ASSUM(STRIP_ASSUME_TAC o REWRITE_RULE [division_of]) THEN 1337 ASM_SIMP_TAC std_ss [FINITE_DELETE, IN_DELETE] THEN 1338 FIRST_ASSUM(MP_TAC o C MATCH_MP (ASSUME ``(k:real->bool) IN s``)) THEN 1339 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 1340 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 1341 MAP_EVERY X_GEN_TAC [``c:real``, ``d:real``] THEN 1342 DISCH_THEN SUBST_ALL_TAC THEN 1343 MATCH_MP_TAC(SET_RULE 1344 ``(BIGUNION s = i) /\ k SUBSET BIGUNION(s DELETE k) 1345 ==> (BIGUNION(s DELETE k) = i)``) THEN 1346 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC(MESON[CLOSED_LIMPT, SUBSET_DEF] 1347 ``closed s /\ (!x. x IN k ==> x limit_point_of s) ==> k SUBSET s``) THEN 1348 CONJ_TAC THENL 1349 [MATCH_MP_TAC CLOSED_BIGUNION THEN 1350 ASM_REWRITE_TAC[FINITE_DELETE, IN_DELETE] THEN 1351 ASM_MESON_TAC[CLOSED_INTERVAL], 1352 ALL_TAC] THEN 1353 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN REWRITE_TAC[LIMPT_APPROACHABLE] THEN 1354 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN REWRITE_TAC[dist] THEN 1355 SUBGOAL_THEN ``?y:real. y IN BIGUNION s /\ ~(y IN interval[c,d]) /\ 1356 ~(y = x) /\ abs(y - x) < e`` 1357 MP_TAC THENL [ALL_TAC, SET_TAC[]] THEN ASM_REWRITE_TAC[] THEN 1358 MAP_EVERY UNDISCH_TAC 1359 [``~(content(interval[a:real,b]) = &0)``, 1360 ``content(interval[c:real,d]) = &0``] THEN 1361 SIMP_TAC std_ss [CONTENT_EQ_0, NOT_EXISTS_THM] THEN 1362 DISCH_TAC THEN ASM_REWRITE_TAC[REAL_NOT_LE] THEN 1363 DISCH_TAC THEN UNDISCH_TAC ``~(interval[c:real,d] = {})`` THEN 1364 SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, NOT_EXISTS_THM] THEN 1365 ASM_REWRITE_TAC[REAL_NOT_LT] THEN 1366 ASM_SIMP_TAC std_ss [REAL_ARITH ``a <= b ==> (b <= a <=> (a = b:real))``] THEN 1367 DISCH_THEN(fn th => SUBST_ALL_TAC th THEN ASSUME_TAC th) THEN 1368 UNDISCH_TAC ``interval[c:real,c] SUBSET interval[a,b]`` THEN 1369 REWRITE_TAC[SUBSET_DEF] THEN DISCH_THEN(MP_TAC o SPEC ``x:real``) THEN 1370 ASM_REWRITE_TAC[] THEN DISCH_TAC THEN 1371 MP_TAC(ASSUME ``(x:real) IN interval[c,c]``) THEN 1372 GEN_REWR_TAC LAND_CONV [IN_INTERVAL] THEN 1373 ASM_REWRITE_TAC[] THEN 1374 ASM_SIMP_TAC std_ss [REAL_ARITH ``(d = c) ==> (c <= x /\ x <= d <=> (x = c:real))``] THEN 1375 DISCH_TAC THEN 1376 MP_TAC(ASSUME ``(x:real) IN interval[a,b]``) THEN 1377 GEN_REWR_TAC LAND_CONV [IN_INTERVAL] THEN ASM_REWRITE_TAC[] THEN 1378 STRIP_TAC THEN EXISTS_TAC 1379 ``(@f. f = if (c:real) <= ((a:real) + (b:real)) / &2 1380 then c + min e (b - c) / &2 1381 else c - min e (c - a) / &2)`` THEN 1382 SIMP_TAC std_ss [IN_INTERVAL] THEN REPEAT CONJ_TAC THENL 1383 [FULL_SIMP_TAC std_ss [IN_INTERVAL, min_def] THEN 1384 REPEAT COND_CASES_TAC THEN 1385 FULL_SIMP_TAC real_ss [REAL_ARITH ``a <= b - c / 2 <=> c / 2 <= b - a:real``, 1386 REAL_ARITH ``a <= b + c / 2 <=> a - b <= c / 2:real``, 1387 REAL_ARITH ``c + e / 2 <= b <=> e / 2 <= b - c:real``, 1388 REAL_ARITH ``c - e / 2 <= b <=> c - b <= e / 2:real``, 1389 REAL_LE_RDIV_EQ, REAL_LE_LDIV_EQ] THEN 1390 UNDISCH_TAC ``0 < e:real`` THEN POP_ASSUM MP_TAC THEN 1391 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1392 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 1393 FULL_SIMP_TAC std_ss [IN_INTERVAL, min_def] THEN 1394 REPEAT COND_CASES_TAC THEN 1395 FULL_SIMP_TAC real_ss [REAL_ARITH ``a <= b - c / 2 <=> c / 2 <= b - a:real``, 1396 REAL_ARITH ``a <= b + c / 2 <=> a - b <= c / 2:real``, 1397 REAL_ARITH ``c + e / 2 <= b <=> e / 2 <= b - c:real``, 1398 REAL_ARITH ``c - e / 2 <= b <=> c - b <= e / 2:real``, 1399 REAL_LE_RDIV_EQ, REAL_LE_LDIV_EQ] THEN 1400 UNDISCH_TAC ``0 < e:real`` THEN POP_ASSUM MP_TAC THEN 1401 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1402 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 1403 FULL_SIMP_TAC std_ss [IN_INTERVAL, min_def] THEN 1404 REPEAT COND_CASES_TAC THEN 1405 FULL_SIMP_TAC real_ss [REAL_ARITH ``a <= b - c / 2 <=> c / 2 <= b - a:real``, 1406 REAL_ARITH ``a <= b + c / 2 <=> a - b <= c / 2:real``, 1407 REAL_ARITH ``c + e / 2 <= b <=> e / 2 <= b - c:real``, 1408 REAL_ARITH ``c - e / 2 <= b <=> c - b <= e / 2:real``, 1409 REAL_LE_RDIV_EQ, REAL_LE_LDIV_EQ] THENL 1410 [ASM_REWRITE_TAC [REAL_NOT_LE], 1411 REWRITE_TAC [REAL_NOT_LE] THEN 1412 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1413 POP_ASSUM MP_TAC THEN UNDISCH_TAC ``a < b:real`` THEN 1414 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC, 1415 ASM_REWRITE_TAC [REAL_NOT_LE], 1416 REWRITE_TAC [REAL_NOT_LE] THEN 1417 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1418 POP_ASSUM MP_TAC THEN UNDISCH_TAC ``a < b:real`` THEN 1419 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC], 1420 FULL_SIMP_TAC std_ss [IN_INTERVAL, min_def] THEN 1421 REPEAT COND_CASES_TAC THEN 1422 FULL_SIMP_TAC real_ss [REAL_ARITH ``a <= b - c / 2 <=> c / 2 <= b - a:real``, 1423 REAL_ARITH ``a <= b + c / 2 <=> a - b <= c / 2:real``, 1424 REAL_ARITH ``c + e / 2 <= b <=> e / 2 <= b - c:real``, 1425 REAL_ARITH ``c - e / 2 <= b <=> c - b <= e / 2:real``, 1426 REAL_LE_RDIV_EQ, REAL_LE_LDIV_EQ] THENL 1427 [REWRITE_TAC [REAL_ARITH ``(a + b <> a) <=> (0 <> b:real)``] THEN 1428 ASM_SIMP_TAC std_ss [REAL_LT_IMP_NE, REAL_HALF], 1429 REWRITE_TAC [REAL_ARITH ``(a + b <> a) <=> (0 <> b:real)``] THEN 1430 MATCH_MP_TAC REAL_LT_IMP_NE THEN SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 1431 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1432 POP_ASSUM MP_TAC THEN UNDISCH_TAC ``a < b:real`` THEN 1433 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC, 1434 REWRITE_TAC [REAL_ARITH ``(a - b <> a) <=> (0 <> b:real)``] THEN 1435 ASM_SIMP_TAC std_ss [REAL_LT_IMP_NE, REAL_HALF], 1436 REWRITE_TAC [REAL_ARITH ``(a - b <> a) <=> (0 <> b:real)``] THEN 1437 MATCH_MP_TAC REAL_LT_IMP_NE THEN SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 1438 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1439 POP_ASSUM MP_TAC THEN UNDISCH_TAC ``a < b:real`` THEN 1440 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC], 1441 FULL_SIMP_TAC std_ss [IN_INTERVAL, min_def, abs] THEN 1442 REPEAT COND_CASES_TAC THEN 1443 FULL_SIMP_TAC real_ss [REAL_ARITH ``a <= b - c / 2 <=> c / 2 <= b - a:real``, 1444 REAL_ARITH ``a <= b + c / 2 <=> a - b <= c / 2:real``, 1445 REAL_ARITH ``c + e / 2 <= b <=> e / 2 <= b - c:real``, 1446 REAL_ARITH ``c - e / 2 <= b <=> c - b <= e / 2:real``, 1447 REAL_LE_RDIV_EQ, REAL_LE_LDIV_EQ, REAL_LT_RDIV_EQ, REAL_LT_LDIV_EQ] THENL 1448 [UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC, 1449 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1450 POP_ASSUM MP_TAC THEN UNDISCH_TAC ``a < b:real`` THEN 1451 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC, 1452 REWRITE_TAC [REAL_ARITH ``a - b - a < e <=> -e < b:real``] THEN 1453 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 1454 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC, 1455 REWRITE_TAC [REAL_ARITH ``a - b - a < e <=> -e < b:real``] THEN 1456 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 1457 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1458 POP_ASSUM MP_TAC THEN UNDISCH_TAC ``a < b:real`` THEN 1459 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC, 1460 REWRITE_TAC [REAL_ARITH ``a - (a + b) < e <=> -e < b:real``] THEN 1461 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 1462 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC, 1463 REWRITE_TAC [REAL_ARITH ``a - (a + b) < e <=> -e < b:real``] THEN 1464 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 1465 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1466 POP_ASSUM MP_TAC THEN UNDISCH_TAC ``a < b:real`` THEN 1467 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC, 1468 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC, 1469 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 1470 POP_ASSUM MP_TAC THEN UNDISCH_TAC ``a < b:real`` THEN 1471 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC]]); 1472 1473val DIVISION_OF_AFFINITY = store_thm ("DIVISION_OF_AFFINITY", 1474 ``!d s:real->bool m c. 1475 IMAGE (IMAGE (\x. m * x + c)) d division_of (IMAGE (\x. m * x + c) s) <=> 1476 if m = &0 then if s = {} then (d = {}) 1477 else ~(d = {}) /\ !k. k IN d ==> ~(k = {}) 1478 else d division_of s``, 1479 REPEAT GEN_TAC THEN ASM_CASES_TAC ``m = &0:real`` THEN ASM_REWRITE_TAC[] THENL 1480 [ASM_CASES_TAC ``s:real->bool = {}`` THEN 1481 ASM_REWRITE_TAC[IMAGE_EMPTY, IMAGE_INSERT, DIVISION_OF_TRIVIAL, IMAGE_EQ_EMPTY] THEN 1482 ASM_CASES_TAC ``d:(real->bool)->bool = {}`` THEN 1483 ASM_REWRITE_TAC[IMAGE_EMPTY, IMAGE_INSERT, EMPTY_DIVISION_OF, BIGUNION_EMPTY, 1484 IMAGE_EQ_EMPTY] THEN 1485 REWRITE_TAC[REAL_MUL_LZERO, REAL_ADD_LID] THEN 1486 ASM_SIMP_TAC std_ss [SET_RULE ``~(s = {}) ==> (IMAGE (\x. c) s = {c})``] THEN 1487 ASM_CASES_TAC ``!k:real->bool. k IN d ==> ~(k = {})`` THEN 1488 ASM_REWRITE_TAC[division_of] THENL 1489 [ALL_TAC, 1490 SIMP_TAC std_ss [FORALL_IN_IMAGE] THEN ASM_MESON_TAC[IMAGE_EQ_EMPTY]] THEN 1491 SUBGOAL_THEN 1492 ``IMAGE (IMAGE ((\x. c):real->real)) d = {{c}}`` 1493 SUBST1_TAC THENL 1494 [GEN_REWR_TAC I [EXTENSION] THEN 1495 REWRITE_TAC[IN_IMAGE, IN_SING] THEN ASM_SET_TAC[], 1496 SIMP_TAC std_ss [BIGUNION_SING, FINITE_SING, IN_SING, IMP_CONJ] THEN 1497 REWRITE_TAC[SUBSET_REFL, NOT_INSERT_EMPTY] THEN 1498 METIS_TAC[INTERVAL_SING]], 1499 REWRITE_TAC[division_of] THEN 1500 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_IMAGE] THEN 1501 REWRITE_TAC[IMAGE_EQ_EMPTY, GSYM INTERIOR_INTER] THEN 1502 ASM_SIMP_TAC std_ss [FINITE_IMAGE_INJ_EQ, GSYM IMAGE_BIGUNION, 1503 REAL_ARITH ``(x + a:real = y + a) <=> (x = y)``, REAL_EQ_LMUL, 1504 SET_RULE ``(!x y. (f x = f y) <=> (x = y)) 1505 ==> (IMAGE f s SUBSET IMAGE f t <=> s SUBSET t) /\ 1506 ((IMAGE f s = IMAGE f t) <=> (s = t)) /\ 1507 (IMAGE f s INTER IMAGE f t = IMAGE f (s INTER t))``] THEN 1508 AP_TERM_TAC THEN BINOP_TAC THENL 1509 [AP_TERM_TAC THEN ABS_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN 1510 EQ_TAC THEN SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 1511 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN DISCH_TAC THEN 1512 ASM_SIMP_TAC std_ss [IMAGE_AFFINITY_INTERVAL] THENL [ALL_TAC, METIS_TAC[]] THEN 1513 FIRST_X_ASSUM(MP_TAC o AP_TERM 1514 ``IMAGE (\x:real. inv m * x + -(inv m * c))``) THEN 1515 ASM_SIMP_TAC std_ss [GSYM IMAGE_COMPOSE, AFFINITY_INVERSES] THEN 1516 ASM_REWRITE_TAC[IMAGE_ID, IMAGE_AFFINITY_INTERVAL] THEN METIS_TAC[], 1517 SUBGOAL_THEN ``(\x:real. m * x + c) = (\x. c + x) o (\x. m * x)`` 1518 SUBST1_TAC THENL 1519 [SIMP_TAC std_ss [FUN_EQ_THM, o_THM] THEN REAL_ARITH_TAC, 1520 ASM_SIMP_TAC std_ss [IMAGE_COMPOSE, INTERIOR_TRANSLATION] THEN 1521 ASM_SIMP_TAC std_ss [INTERIOR_INJECTIVE_LINEAR_IMAGE, LINEAR_SCALING, 1522 REAL_EQ_LMUL, IMAGE_EQ_EMPTY]]]]); 1523 1524val DIVISION_OF_TRANSLATION = store_thm ("DIVISION_OF_TRANSLATION", 1525 ``!d s:real->bool. 1526 IMAGE (IMAGE (\x. a + x)) d division_of (IMAGE (\x. a + x) s) <=> 1527 d division_of s``, 1528 ONCE_REWRITE_TAC[REAL_ARITH ``a + x:real = &1 * x + a:real``] THEN 1529 SIMP_TAC real_ss [DIVISION_OF_AFFINITY]); 1530 1531val DIVISION_OF_REFLECT = store_thm ("DIVISION_OF_REFLECT", 1532``!d s:real->bool. 1533 IMAGE (IMAGE (\x. -x)) d division_of IMAGE (\x. -x) s <=> 1534 d division_of s``, 1535 REPEAT GEN_TAC THEN SUBGOAL_THEN ``(\x. -x) = \x:real. -(&1) * x + 0`` 1536 SUBST1_TAC THENL 1537 [REWRITE_TAC[FUN_EQ_THM] THEN REAL_ARITH_TAC, 1538 SIMP_TAC real_ss [DIVISION_OF_AFFINITY]]); 1539 1540val ELEMENTARY_COMPACT = store_thm ("ELEMENTARY_COMPACT", 1541 ``!s. (?d. d division_of s) ==> compact s``, 1542 REWRITE_TAC[division_of] THEN 1543 MESON_TAC[COMPACT_BIGUNION, COMPACT_INTERVAL]); 1544 1545Theorem DIVISION_1_SORT : 1546 !d s:real->bool. d division_of s /\ 1547 (!k. k IN d ==> ~(interior k = {})) 1548 ==> ?n t. (IMAGE t ((1:num)..n) = d) /\ 1549 !i j. i IN ((1:num)..n) /\ j IN ((1:num)..n) /\ i < j 1550 ==> ~(t i = t j) /\ 1551 !x y. x IN t i /\ y IN t j ==> x <= y 1552Proof 1553 REPEAT STRIP_TAC THEN EXISTS_TAC ``CARD(d:(real->bool)->bool)`` THEN 1554 MP_TAC(ISPEC ``\i j:real->bool. i IN d /\ j IN d /\ 1555 (interval_lowerbound i) <= (interval_lowerbound j)`` 1556 TOPOLOGICAL_SORT) THEN 1557 SIMP_TAC std_ss [] THEN 1558 KNOW_TAC ``(!(x :real -> bool) (y :real -> bool). 1559 (x IN (d :(real -> bool) -> bool) /\ y IN d /\ 1560 interval_lowerbound x <= interval_lowerbound y) /\ y IN d /\ 1561 x IN d /\ interval_lowerbound y <= interval_lowerbound x ==> 1562 (x = y)) /\ 1563 (!(x :real -> bool) (y :real -> bool) (z :real -> bool). 1564 (x IN d /\ y IN d /\ 1565 interval_lowerbound x <= interval_lowerbound y) /\ y IN d /\ 1566 z IN d /\ interval_lowerbound y <= interval_lowerbound z ==> 1567 interval_lowerbound x <= interval_lowerbound z)`` THENL 1568 [CONJ_TAC THENL [ALL_TAC, MESON_TAC[REAL_LE_TRANS]] THEN 1569 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM], 1570 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 1571 DISCH_THEN(MP_TAC o SPECL 1572 [``CARD(d:(real->bool)->bool)``, ``d:(real->bool)->bool``]) THEN 1573 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 1574 ASM_REWRITE_TAC[GSYM FINITE_HAS_SIZE] THEN 1575 DISCH_THEN (X_CHOOSE_TAC ``f:num->real->bool``) THEN 1576 EXISTS_TAC ``f:num->real->bool`` THEN POP_ASSUM MP_TAC THEN 1577 DISCH_THEN(STRIP_ASSUME_TAC o GSYM) THEN 1578 SUBGOAL_THEN 1579 ``!k l. k IN d /\ l IN d /\ 1580 ~((interval_lowerbound l) <= (interval_lowerbound k)) 1581 ==> ~(k = l) /\ 1582 !x y. x IN k /\ y IN l ==> x <= y`` MP_TAC THENL 1583 [ALL_TAC, 1584 DISCH_TAC THEN 1585 CONJ_TAC THENL [ASM_SET_TAC[], REPEAT GEN_TAC THEN STRIP_TAC] THEN 1586 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SET_TAC[]] THEN 1587 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM]] THEN 1588 UNDISCH_TAC ``d division_of s`` THEN DISCH_TAC THEN 1589 FIRST_ASSUM(fn th => 1590 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 1591 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY] THEN 1592 REWRITE_TAC[INTERVAL_NE_EMPTY, IN_INTERVAL] THEN 1593 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN STRIP_TAC THEN 1594 MAP_EVERY X_GEN_TAC [``a':real``, ``b':real``] THEN STRIP_TAC THEN 1595 REPEAT STRIP_TAC THEN 1596 UNDISCH_TAC ``d division_of s`` THEN DISCH_TAC THEN 1597 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 1598 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 1599 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 1600 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 1601 DISCH_THEN(MP_TAC o SPECL 1602 [``interval[a:real,b]``, ``interval[a':real,b']``]) THEN 1603 (SUBGOAL_THEN 1604 ``~(interior(interval[a:real,b]) = {}) /\ 1605 ~(interior(interval[a':real,b']) = {})`` 1606 MP_TAC THENL [ASM_MESON_TAC[], ALL_TAC]) THEN 1607 ASM_REWRITE_TAC [EQ_INTERVAL, GSYM INTERIOR_INTER] THEN 1608 REWRITE_TAC [INTER_INTERVAL, INTERIOR_INTERVAL, GSYM INTERVAL_EQ_EMPTY] THEN 1609 ASM_SIMP_TAC real_ss [min_def, max_def] THENL 1610 [ (* goal 1 (of 3) *) 1611 Cases_on `b <= b'` >> rw [] \\ 1612 Cases_on `(a = a') /\ (b = b')` >- rw [] \\ 1613 ONCE_REWRITE_TAC [DISJ_COMM] >> STRONG_DISJ2_TAC \\ 1614 `b <= a'` by PROVE_TAC [real_lte] \\ 1615 METIS_TAC [REAL_LE_ANTISYM], 1616 (* goal 2 (of 3) *) 1617 rw [GSYM real_lte] \\ 1618 STRONG_DISJ2_TAC >> CCONTR_TAC >> fs [GSYM real_lte], 1619 (* goal 3 (of 3) *) 1620 rpt STRIP_TAC \\ 1621 MATCH_MP_TAC REAL_LE_TRANS \\ 1622 Q.EXISTS_TAC `b` >> art [] \\ 1623 MATCH_MP_TAC REAL_LE_TRANS \\ 1624 Q.EXISTS_TAC `a'` >> art [] \\ 1625 Cases_on `b <= b'` >> Cases_on `a <= a'` >> fs [] (* 4 goals *) 1626 >- (FIRST_X_ASSUM MATCH_MP_TAC \\ 1627 CONJ_TAC >- (DISJ1_TAC >> rw [GSYM real_lte]) \\ 1628 STRONG_DISJ2_TAC >> CCONTR_TAC >> fs [GSYM real_lte]) 1629 >> (fs [real_lte] >> PROVE_TAC [REAL_LT_ANTISYM]) ] 1630QED 1631 1632(* ------------------------------------------------------------------------- *) 1633(* Tagged (partial) divisions. *) 1634(* ------------------------------------------------------------------------- *) 1635 1636val _ = set_fixity "tagged_partial_division_of" (Infix(NONASSOC, 450)); 1637val _ = set_fixity "tagged_division_of" (Infix(NONASSOC, 450)); 1638 1639val tagged_partial_division_of = new_definition ("tagged_partial_division_of", 1640 ``s tagged_partial_division_of i <=> 1641 FINITE s /\ 1642 (!x k. (x,k) IN s 1643 ==> x IN k /\ k SUBSET i /\ ?a b. k = interval[a,b]) /\ 1644 (!x1 k1 x2 k2. (x1,k1) IN s /\ (x2,k2) IN s /\ ~((x1,k1) = (x2,k2)) 1645 ==> (interior(k1) INTER interior(k2) = {}))``); 1646 1647val tagged_division_of = new_definition ("tagged_division_of", 1648 ``s tagged_division_of i <=> 1649 s tagged_partial_division_of i /\ (BIGUNION {k | ?x. (x,k) IN s} = i)``); 1650 1651val TAGGED_DIVISION_OF_FINITE = store_thm ("TAGGED_DIVISION_OF_FINITE", 1652 ``!s i. s tagged_division_of i ==> FINITE s``, 1653 SIMP_TAC std_ss [tagged_division_of, tagged_partial_division_of]); 1654 1655Theorem TAGGED_DIVISION_OF : 1656 !s i. s tagged_division_of i <=> 1657 FINITE s /\ 1658 (!x k. (x,k) IN s 1659 ==> x IN k /\ k SUBSET i /\ ?a b. k = interval[a,b]) /\ 1660 (!x1 k1 x2 k2. (x1,k1) IN s /\ (x2,k2) IN s /\ ~((x1,k1) = (x2,k2)) 1661 ==> (interior(k1) INTER interior(k2) = {})) /\ 1662 (BIGUNION {k | ?x. (x,k) IN s} = i) 1663Proof 1664 REWRITE_TAC[tagged_division_of, tagged_partial_division_of, CONJ_ASSOC] 1665QED 1666 1667val DIVISION_OF_TAGGED_DIVISION = store_thm ("DIVISION_OF_TAGGED_DIVISION", 1668 ``!s i. s tagged_division_of i ==> (IMAGE SND s) division_of i``, 1669 REWRITE_TAC[TAGGED_DIVISION_OF, division_of] THEN 1670 ASM_SIMP_TAC std_ss [IMAGE_FINITE, FORALL_IN_IMAGE, FORALL_PROD, PAIR_EQ] THEN 1671 SIMP_TAC std_ss [IN_IMAGE, EXISTS_PROD] THEN 1672 REPEAT GEN_TAC THEN STRIP_TAC THEN REPEAT CONJ_TAC THENL 1673 [ASM_MESON_TAC[MEMBER_NOT_EMPTY], 1674 REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 1675 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_MESON_TAC[], 1676 SIMP_TAC std_ss [EXTENSION, GSPECIFICATION, IN_IMAGE, IN_BIGUNION] THEN 1677 SIMP_TAC std_ss [FORALL_PROD, EXISTS_PROD] THEN MESON_TAC[]]); 1678 1679val PARTIAL_DIVISION_OF_TAGGED_DIVISION = store_thm ("PARTIAL_DIVISION_OF_TAGGED_DIVISION", 1680 ``!s i. s tagged_partial_division_of i 1681 ==> (IMAGE SND s) division_of BIGUNION(IMAGE SND s)``, 1682 REWRITE_TAC[tagged_partial_division_of, division_of] THEN 1683 SIMP_TAC std_ss [GSYM AND_IMP_INTRO, RIGHT_FORALL_IMP_THM, FORALL_IN_IMAGE] THEN 1684 SIMP_TAC std_ss [FORALL_PROD, PAIR_EQ, DE_MORGAN_THM] THEN 1685 GEN_TAC THEN DISCH_TAC THEN GEN_TAC THEN REPEAT DISCH_TAC THEN 1686 REPEAT CONJ_TAC THENL 1687 [ASM_MESON_TAC[IMAGE_FINITE], 1688 ALL_TAC, 1689 ASM_MESON_TAC[]] THEN 1690 REPEAT GEN_TAC THEN STRIP_TAC THEN CONJ_TAC THENL 1691 [ALL_TAC, ASM_MESON_TAC[MEMBER_NOT_EMPTY]] THEN 1692 SIMP_TAC std_ss [SUBSET_DEF, IN_BIGUNION, IN_IMAGE, EXISTS_PROD] THEN 1693 REPEAT (POP_ASSUM MP_TAC) THEN SET_TAC[]); 1694 1695val TAGGED_PARTIAL_DIVISION_SUBSET = store_thm ("TAGGED_PARTIAL_DIVISION_SUBSET", 1696 ``!s t i. s tagged_partial_division_of i /\ t SUBSET s 1697 ==> t tagged_partial_division_of i``, 1698 REWRITE_TAC[tagged_partial_division_of] THEN 1699 MESON_TAC[SUBSET_FINITE, SUBSET_DEF]); 1700 1701val SUM_OVER_TAGGED_PARTIAL_DIVISION_LEMMA = store_thm ("SUM_OVER_TAGGED_PARTIAL_DIVISION_LEMMA", 1702 ``!d:(real->bool)->real p i. 1703 p tagged_partial_division_of i /\ 1704 (!u v. ~(interval[u,v] = {}) /\ (content(interval[u,v]) = &0) 1705 ==> (d(interval[u,v]) = &0)) 1706 ==> (sum p (\(x,k). d k) = sum (IMAGE SND p) d)``, 1707 REWRITE_TAC[CONTENT_EQ_0_INTERIOR] THEN REPEAT STRIP_TAC THEN 1708 SUBGOAL_THEN ``(\(x:real,k:real->bool). d k:real) = d o SND`` 1709 SUBST1_TAC THENL [SIMP_TAC std_ss [FUN_EQ_THM, FORALL_PROD, o_THM], ALL_TAC] THEN 1710 CONV_TAC SYM_CONV THEN MATCH_MP_TAC SUM_IMAGE_NONZERO THEN 1711 UNDISCH_TAC ``p tagged_partial_division_of i`` THEN 1712 REWRITE_TAC [tagged_partial_division_of] THEN 1713 MATCH_MP_TAC MONO_AND THEN SIMP_TAC std_ss [FORALL_PROD] THEN 1714 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN DISCH_TAC THEN 1715 X_GEN_TAC ``x:real`` THEN X_GEN_TAC ``k:real->bool`` THEN 1716 X_GEN_TAC ``y:real`` THEN 1717 POP_ASSUM (MP_TAC o Q.SPECL [`x:real`, `k:real->bool`, `y:real`, `k:real->bool`]) THEN 1718 ASM_REWRITE_TAC[PAIR_EQ, INTER_IDEMPOT] THEN 1719 RULE_ASSUM_TAC(REWRITE_RULE[GSYM MEMBER_NOT_EMPTY]) THEN 1720 ASM_MESON_TAC[]); 1721 1722val SUM_OVER_TAGGED_DIVISION_LEMMA = store_thm ("SUM_OVER_TAGGED_DIVISION_LEMMA", 1723 ``!d:(real->bool)->real p i. 1724 p tagged_division_of i /\ 1725 (!u v. ~(interval[u,v] = {}) /\ (content(interval[u,v]) = &0) 1726 ==> (d(interval[u,v]) = &0)) 1727 ==> (sum p (\(x,k). d k) = sum (IMAGE SND p) d)``, 1728 REWRITE_TAC[tagged_division_of] THEN REPEAT STRIP_TAC THEN 1729 MATCH_MP_TAC SUM_OVER_TAGGED_PARTIAL_DIVISION_LEMMA THEN 1730 EXISTS_TAC ``i:real->bool`` THEN ASM_REWRITE_TAC[]); 1731 1732val TAG_IN_INTERVAL = store_thm ("TAG_IN_INTERVAL", 1733 ``!p i k. p tagged_division_of i /\ (x,k) IN p ==> x IN i``, 1734 REWRITE_TAC[TAGGED_DIVISION_OF] THEN SET_TAC[]); 1735 1736val TAGGED_DIVISION_OF_EMPTY = store_thm ("TAGGED_DIVISION_OF_EMPTY", 1737 ``{} tagged_division_of {}``, 1738 REWRITE_TAC[tagged_division_of, tagged_partial_division_of] THEN 1739 SIMP_TAC std_ss [FINITE_EMPTY, EXTENSION, NOT_IN_EMPTY, IN_BIGUNION, GSPECIFICATION]); 1740 1741val TAGGED_PARTIAL_DIVISION_OF_TRIVIAL = store_thm ("TAGGED_PARTIAL_DIVISION_OF_TRIVIAL", 1742 ``!p. p tagged_partial_division_of {} <=> (p = {})``, 1743 REWRITE_TAC[tagged_partial_division_of, SUBSET_EMPTY, CONJ_ASSOC] THEN 1744 REWRITE_TAC[SET_RULE ``x IN k /\ (k = {}) <=> F``] THEN 1745 SIMP_TAC std_ss [GSYM FORALL_PROD] THEN 1746 REWRITE_TAC [GSYM NOT_EXISTS_THM, MEMBER_NOT_EMPTY] THEN 1747 REWRITE_TAC[METIS [] ``(a /\ b) /\ c <=> b /\ a /\ c``] THEN 1748 REWRITE_TAC [METIS [GSYM NOT_EXISTS_THM, MEMBER_NOT_EMPTY] 1749 ``(!k. k NOTIN s) = (s = {})``] THEN 1750 GEN_TAC THEN MATCH_MP_TAC(TAUT `(a ==> b) ==> (a /\ b <=> a)`) THEN 1751 DISCH_THEN SUBST1_TAC THEN 1752 REWRITE_TAC[FINITE_EMPTY, BIGUNION_EMPTY, NOT_IN_EMPTY]); 1753 1754val TAGGED_DIVISION_OF_TRIVIAL = store_thm ("TAGGED_DIVISION_OF_TRIVIAL", 1755 ``!p. p tagged_division_of {} <=> (p = {})``, 1756 REWRITE_TAC[tagged_division_of, TAGGED_PARTIAL_DIVISION_OF_TRIVIAL] THEN 1757 GEN_TAC THEN MATCH_MP_TAC(TAUT `(a ==> b) ==> (a /\ b <=> a)`) THEN 1758 DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[NOT_IN_EMPTY] THEN SET_TAC[]); 1759 1760val TAGGED_DIVISION_OF_SELF = store_thm ("TAGGED_DIVISION_OF_SELF", 1761 ``!x a b. x IN interval[a,b] 1762 ==> {(x,interval[a,b])} tagged_division_of interval[a,b]``, 1763 REWRITE_TAC[TAGGED_DIVISION_OF, FINITE_INSERT, FINITE_EMPTY, IN_SING] THEN 1764 SIMP_TAC std_ss [FORALL_PROD, PAIR_EQ] THEN REPEAT STRIP_TAC THEN 1765 ASM_REWRITE_TAC[SUBSET_REFL, UNWIND_THM2, SET_RULE ``{k | k = a} = {a}``] THEN 1766 REWRITE_TAC[BIGUNION_SING] THEN ASM_MESON_TAC[]); 1767 1768val TAGGED_DIVISION_UNION = store_thm ("TAGGED_DIVISION_UNION", 1769 ``!s1 s2:real->bool p1 p2. 1770 p1 tagged_division_of s1 /\ 1771 p2 tagged_division_of s2 /\ 1772 (interior s1 INTER interior s2 = {}) 1773 ==> (p1 UNION p2) tagged_division_of (s1 UNION s2)``, 1774 REPEAT GEN_TAC THEN REWRITE_TAC[TAGGED_DIVISION_OF] THEN STRIP_TAC THEN 1775 ASM_REWRITE_TAC[FINITE_UNION, IN_UNION, EXISTS_OR_THM, SET_RULE 1776 ``BIGUNION {x | P x \/ Q x} = BIGUNION {x | P x} UNION BIGUNION {x | Q x}``] THEN 1777 CONJ_TAC THENL [REPEAT (POP_ASSUM MP_TAC) THEN SET_TAC[], ALL_TAC] THEN 1778 REPEAT STRIP_TAC THENL 1779 [ASM_MESON_TAC[], ALL_TAC, ALL_TAC, ASM_MESON_TAC[], 1780 REPEAT (POP_ASSUM MP_TAC) THEN SET_TAC []] THEN 1781 MATCH_MP_TAC(SET_RULE 1782 ``!s' t'. s SUBSET s' /\ t SUBSET t' /\ (s' INTER t' = {}) 1783 ==> (s INTER t = {})``) THENL 1784 [MAP_EVERY EXISTS_TAC 1785 [``interior s1:real->bool``, ``interior s2:real->bool``], 1786 MAP_EVERY EXISTS_TAC 1787 [``interior s2:real->bool``, ``interior s1:real->bool``]] THEN 1788 ASM_SIMP_TAC std_ss[INTER_COMM] THEN CONJ_TAC THEN MATCH_MP_TAC SUBSET_INTERIOR THEN 1789 ASM_MESON_TAC[]); 1790 1791val lemma1 = Q.prove ( 1792 `!x' k. (?s. (x',k) IN s /\ ?x. (s = pfn x) /\ x IN iset) <=> 1793 (?x. x IN iset /\ (x',k) IN pfn x)`, 1794 MESON_TAC []); 1795 1796val lemma2 = Q.prove ( 1797 `!s1 t1 s2 t2. s1 SUBSET t1 /\ s2 SUBSET t2 /\ (t1 INTER t2 = {}) 1798 ==> (s1 INTER s2 = {})`, 1799 SET_TAC []); 1800 1801val TAGGED_DIVISION_BIGUNION = store_thm ("TAGGED_DIVISION_BIGUNION", 1802 ``!iset pfn. FINITE iset /\ 1803 (!i:real->bool. i IN iset ==> pfn(i) tagged_division_of i) /\ 1804 (!i1 i2. i1 IN iset /\ i2 IN iset /\ ~(i1 = i2) 1805 ==> (interior(i1) INTER interior(i2) = {})) 1806 ==> BIGUNION(IMAGE pfn iset) tagged_division_of (BIGUNION iset)``, 1807 REPEAT GEN_TAC THEN 1808 REWRITE_TAC[ONCE_REWRITE_RULE[EXTENSION] tagged_division_of] THEN 1809 SIMP_TAC std_ss [tagged_partial_division_of, IN_BIGUNION, GSPECIFICATION] THEN 1810 SIMP_TAC std_ss [SUBSET_DEF, GSPECIFICATION, IN_BIGUNION, IN_IMAGE] THEN 1811 SIMP_TAC std_ss [FINITE_BIGUNION, IMAGE_FINITE, FORALL_IN_IMAGE] THEN 1812 STRIP_TAC THEN REPEAT CONJ_TAC THENL 1813 [ASM_MESON_TAC[], ALL_TAC, ASM_MESON_TAC[]] THEN 1814 REPEAT GEN_TAC THEN REWRITE_TAC[lemma1] THEN 1815 SIMP_TAC std_ss [GSYM LEFT_EXISTS_AND_THM] THEN 1816 SIMP_TAC std_ss [GSYM RIGHT_EXISTS_AND_THM] THEN 1817 RW_TAC std_ss [] THENL [ASM_CASES_TAC ``x = x':real->bool`` THENL 1818 [ASM_MESON_TAC[], ALL_TAC], ASM_CASES_TAC ``x = x':real->bool`` THENL 1819 [ASM_MESON_TAC[], ALL_TAC]] THEN MATCH_MP_TAC lemma2 THEN 1820 MAP_EVERY EXISTS_TAC 1821 [``interior(x:real->bool)``, ``interior(x':real->bool)``] THEN 1822 ASM_MESON_TAC[SUBSET_DEF, SUBSET_INTERIOR]); 1823 1824val TAGGED_PARTIAL_DIVISION_OF_UNION_SELF = store_thm ("TAGGED_PARTIAL_DIVISION_OF_UNION_SELF", 1825 ``!p s. p tagged_partial_division_of s 1826 ==> p tagged_division_of (BIGUNION(IMAGE SND p))``, 1827 SIMP_TAC std_ss [tagged_partial_division_of, TAGGED_DIVISION_OF] THEN 1828 REPEAT GEN_TAC THEN STRIP_TAC THEN REPEAT CONJ_TAC THENL 1829 [REPEAT STRIP_TAC THENL [ALL_TAC, ASM_MESON_TAC[]] THEN 1830 SIMP_TAC std_ss [SUBSET_DEF, IN_BIGUNION, IN_IMAGE, EXISTS_PROD] THEN 1831 ASM_MESON_TAC[], ASM_MESON_TAC[], 1832 AP_TERM_TAC THEN GEN_REWR_TAC I [EXTENSION] THEN 1833 SIMP_TAC std_ss [GSPECIFICATION, IN_IMAGE, EXISTS_PROD] THEN MESON_TAC[]]); 1834 1835val TAGGED_DIVISION_OF_UNION_SELF = store_thm ("TAGGED_DIVISION_OF_UNION_SELF", 1836 ``!p s. p tagged_division_of s 1837 ==> p tagged_division_of (BIGUNION(IMAGE SND p))``, 1838 SIMP_TAC std_ss [TAGGED_DIVISION_OF] THEN REPEAT GEN_TAC THEN STRIP_TAC THEN 1839 MATCH_MP_TAC(TAUT `(c ==> a /\ b) /\ c ==> a /\ b /\ c`) THEN CONJ_TAC THENL 1840 [DISCH_THEN(SUBST1_TAC o SYM) THEN ASM_SIMP_TAC std_ss [] THEN ASM_MESON_TAC[], 1841 AP_TERM_TAC THEN GEN_REWR_TAC I [EXTENSION] THEN 1842 SIMP_TAC std_ss [GSPECIFICATION, IN_IMAGE, EXISTS_PROD]]); 1843 1844val TAGGED_DIVISION_UNION_IMAGE_SND = store_thm ("TAGGED_DIVISION_UNION_IMAGE_SND", 1845 ``!p s. p tagged_division_of s ==> (s = BIGUNION(IMAGE SND p))``, 1846 METIS_TAC[TAGGED_PARTIAL_DIVISION_OF_UNION_SELF, tagged_division_of]); 1847 1848val TAGGED_DIVISION_OF_ALT = store_thm ("TAGGED_DIVISION_OF_ALT", 1849 ``!p s. p tagged_division_of s <=> 1850 p tagged_partial_division_of s /\ 1851 (!x. x IN s ==> ?t k. (t,k) IN p /\ x IN k)``, 1852 REWRITE_TAC[tagged_division_of, GSYM SUBSET_ANTISYM] THEN 1853 SIMP_TAC std_ss [SUBSET_DEF, GSPECIFICATION] THEN 1854 SIMP_TAC std_ss [IN_BIGUNION, EXISTS_PROD, GSPECIFICATION] THEN 1855 REWRITE_TAC[tagged_partial_division_of, SUBSET_DEF] THEN SET_TAC[]); 1856 1857val TAGGED_DIVISION_OF_ANOTHER = store_thm ("TAGGED_DIVISION_OF_ANOTHER", 1858 ``!p s s'. 1859 p tagged_partial_division_of s' /\ 1860 (!t k. (t,k) IN p ==> k SUBSET s) /\ 1861 (!x. x IN s ==> ?t k. (t,k) IN p /\ x IN k) 1862 ==> p tagged_division_of s``, 1863 REWRITE_TAC[TAGGED_DIVISION_OF_ALT, tagged_partial_division_of] THEN 1864 SET_TAC[]); 1865 1866val TAGGED_PARTIAL_DIVISION_OF_SUBSET = store_thm ("TAGGED_PARTIAL_DIVISION_OF_SUBSET", 1867 ``!p s t. p tagged_partial_division_of s /\ s SUBSET t 1868 ==> p tagged_partial_division_of t``, 1869 REWRITE_TAC[tagged_partial_division_of] THEN SET_TAC[]); 1870 1871val TAGGED_DIVISION_OF_NONTRIVIAL = store_thm ("TAGGED_DIVISION_OF_NONTRIVIAL", 1872 ``!s a b:real. 1873 s tagged_division_of interval[a,b] /\ ~(content(interval[a,b]) = &0) 1874 ==> {(x,k) | (x,k) IN s /\ ~(content k = &0)} 1875 tagged_division_of interval[a,b]``, 1876 REPEAT STRIP_TAC THEN REWRITE_TAC[TAGGED_DIVISION_OF_ALT] THEN 1877 CONJ_TAC THENL 1878 [MATCH_MP_TAC TAGGED_PARTIAL_DIVISION_SUBSET THEN 1879 EXISTS_TAC ``s:(real#(real->bool))->bool`` THEN 1880 RULE_ASSUM_TAC(REWRITE_RULE[tagged_division_of]) THEN 1881 ASM_REWRITE_TAC[] THEN SRW_TAC [][SUBSET_DEF] THEN ASM_REWRITE_TAC [], 1882 FIRST_ASSUM(MP_TAC o MATCH_MP DIVISION_OF_TAGGED_DIVISION) THEN 1883 DISCH_THEN(MP_TAC o 1884 MATCH_MP(REWRITE_RULE[GSYM AND_IMP_INTRO] DIVISION_OF_NONTRIVIAL)) THEN 1885 ASM_SIMP_TAC std_ss [] THEN 1886 REWRITE_TAC[division_of] THEN DISCH_THEN(MP_TAC o last o CONJUNCTS) THEN 1887 SIMP_TAC std_ss [GSYM SUBSET_ANTISYM_EQ, SUBSET_DEF, IN_ELIM_PAIR_THM] THEN 1888 SIMP_TAC real_ss [BIGUNION, EXISTS_IN_IMAGE, EXISTS_PROD, GSPECIFICATION, 1889 GSYM CONJ_ASSOC, LAMBDA_PROD]]); 1890 1891(* ------------------------------------------------------------------------- *) 1892(* Fine-ness of a partition w.r.t. a gauge. *) 1893(* ------------------------------------------------------------------------- *) 1894 1895val _ = set_fixity "FINE" (Infix(NONASSOC, 450)); 1896 1897val FINE = new_definition ("FINE", 1898 ``d FINE s <=> !x k. (x,k) IN s ==> k SUBSET d(x)``); 1899 1900val FINE_INTER = store_thm ("FINE_INTER", 1901 ``!p d1 d2. (\x. d1(x) INTER d2(x)) FINE p <=> d1 FINE p /\ d2 FINE p``, 1902 KNOW_TAC ``s SUBSET (t INTER u) <=> s SUBSET t /\ s SUBSET u`` THEN 1903 SIMP_TAC std_ss [FINE, IN_INTER, SUBSET_INTER] THEN MESON_TAC[]); 1904 1905val FINE_BIGINTER = store_thm ("FINE_BIGINTER", 1906 ``!f s p. (\x. BIGINTER {f d x | d IN s}) FINE p <=> 1907 !d. d IN s ==> (f d) FINE p``, 1908 SIMP_TAC std_ss [FINE, SET_RULE ``s SUBSET BIGINTER u <=> !t. t IN u ==> s SUBSET t``, 1909 GSPECIFICATION] THEN MESON_TAC[]); 1910 1911val FINE_UNION = store_thm ("FINE_UNION", 1912 ``!d p1 p2. d FINE p1 /\ d FINE p2 ==> d FINE (p1 UNION p2)``, 1913 REWRITE_TAC[FINE, IN_UNION] THEN MESON_TAC[]); 1914 1915val FINE_BIGUNION = store_thm ("FINE_BIGUNION", 1916 ``!d ps. (!p. p IN ps ==> d FINE p) ==> d FINE (BIGUNION ps)``, 1917 REWRITE_TAC[FINE, IN_BIGUNION] THEN MESON_TAC[]); 1918 1919val FINE_SUBSET = store_thm ("FINE_SUBSET", 1920 ``!d p q. p SUBSET q /\ d FINE q ==> d FINE p``, 1921 REWRITE_TAC[FINE, SUBSET_DEF] THEN MESON_TAC[]); 1922 1923(* ------------------------------------------------------------------------- *) 1924(* Gauge integral. Define on compact intervals first, then use a limit. *) 1925(* ------------------------------------------------------------------------- *) 1926 1927val _ = set_fixity "has_integral_compact_interval" (Infix(NONASSOC, 450)); 1928val _ = set_fixity "has_integral" (Infix(NONASSOC, 450)); 1929val _ = set_fixity "integrable_on" (Infix(NONASSOC, 450)); 1930 1931val has_integral_compact_interval = new_definition ("has_integral_compact_interval", 1932 ``(f has_integral_compact_interval y) i <=> 1933 !e. &0 < e 1934 ==> ?d. gauge d /\ 1935 !p. p tagged_division_of i /\ d FINE p 1936 ==> abs(sum p (\(x,k). content(k) * f(x)) - y) < e``); 1937 1938val has_integral_def = new_definition ("has_integral_def", 1939 ``(f has_integral y) i <=> 1940 if ?a b. i = interval[a,b] then (f has_integral_compact_interval y) i 1941 else !e. &0 < e 1942 ==> ?B. &0 < B /\ 1943 !a b. ball(0,B) SUBSET interval[a,b] 1944 ==> ?z. ((\x. if x IN i then f(x) else 0) 1945 has_integral_compact_interval z) 1946 (interval[a,b]) /\ abs(z - y) < e``);; 1947 1948val has_integral = store_thm ("has_integral", 1949 ``(f has_integral y) (interval[a,b]) <=> 1950 !e. &0 < e 1951 ==> ?d. gauge d /\ 1952 !p. p tagged_division_of interval[a,b] /\ d FINE p 1953 ==> abs(sum p (\(x,k). content(k) * f(x)) - y) < e``, 1954 REWRITE_TAC[has_integral_def, has_integral_compact_interval] THEN 1955 METIS_TAC[]); 1956 1957val has_integral_alt = store_thm ("has_integral_alt", 1958 ``(f has_integral y) i <=> 1959 if ?a b. i = interval[a,b] then (f has_integral y) i 1960 else !e. &0 < e 1961 ==> ?B. &0 < B /\ 1962 !a b. ball(0,B) SUBSET interval[a,b] 1963 ==> ?z. ((\x. if x IN i then f(x) else 0) 1964 has_integral z) (interval[a,b]) /\ 1965 abs(z - y) < e``, 1966 REPEAT GEN_TAC THEN GEN_REWR_TAC LAND_CONV [has_integral_def] THEN 1967 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THENL 1968 [POP_ASSUM(REPEAT_TCL CHOOSE_THEN SUBST1_TAC), ALL_TAC] THEN 1969 REWRITE_TAC[has_integral_compact_interval, has_integral]); 1970 1971val integrable_on = new_definition ("integrable_on", 1972 ``f integrable_on i <=> ?y. (f has_integral y) i``); 1973 1974(* renamed `integral` to `HK_integral` (Henstock-Kurzweil integral) 1975 to prevent naming conflicts with lebesgueTheory. -- Chun Tian 1976 *) 1977Definition integral : 1978 HK_integral i f = @y. (f has_integral y) i 1979End 1980 1981val _ = overload_on ("integral", ``HK_integral``); 1982 1983val INTEGRABLE_INTEGRAL = store_thm ("INTEGRABLE_INTEGRAL", 1984 ``!f i. f integrable_on i ==> (f has_integral (integral i f)) i``, 1985 REPEAT GEN_TAC THEN REWRITE_TAC[integrable_on, integral] THEN 1986 CONV_TAC(RAND_CONV SELECT_CONV) THEN REWRITE_TAC[]); 1987 1988val HAS_INTEGRAL_INTEGRABLE = store_thm ("HAS_INTEGRAL_INTEGRABLE", 1989 ``!f i s. (f has_integral i) s ==> f integrable_on s``, 1990 REWRITE_TAC[integrable_on] THEN MESON_TAC[]); 1991 1992val HAS_INTEGRAL_INTEGRAL = store_thm ("HAS_INTEGRAL_INTEGRAL", 1993 ``!f s. f integrable_on s <=> (f has_integral (integral s f)) s``, 1994 MESON_TAC[INTEGRABLE_INTEGRAL, HAS_INTEGRAL_INTEGRABLE]); 1995 1996val SUM_CONTENT_NULL = store_thm ("SUM_CONTENT_NULL", 1997 ``!f:real->real a b p. 1998 (content (interval[a,b]) = &0) /\ 1999 (p tagged_division_of interval[a,b]) 2000 ==> (sum p (\(x,k). content k * f x) = &0)``, 2001 REPEAT STRIP_TAC THEN MATCH_MP_TAC SUM_EQ_0 THEN 2002 SIMP_TAC std_ss [FORALL_PROD] THEN 2003 MAP_EVERY X_GEN_TAC [``p:real``, ``k:real->bool``] THEN 2004 DISCH_TAC THEN REWRITE_TAC[REAL_ENTIRE] THEN DISJ1_TAC THEN 2005 UNDISCH_TAC ``(p :real # (real -> bool) -> bool) tagged_division_of 2006 interval [(a,b)]`` THEN REWRITE_TAC [TAGGED_DIVISION_OF] THEN 2007 DISCH_THEN(MP_TAC o CONJUNCT1 o CONJUNCT2) THEN 2008 DISCH_THEN(MP_TAC o SPECL [``p:real``, ``k:real->bool``]) THEN 2009 ASM_MESON_TAC[CONTENT_SUBSET, CONTENT_POS_LE, REAL_ARITH 2010 ``&0 <= x /\ x <= y /\ (y = &0) ==> (x:real = &0)``]); 2011 2012(* ------------------------------------------------------------------------- *) 2013(* Some basic combining lemmas. *) 2014(* ------------------------------------------------------------------------- *) 2015 2016val TAGGED_DIVISION_BIGUNION_EXISTS = store_thm ("TAGGED_DIVISION_BIGUNION_EXISTS", 2017 ``!d iset i:real->bool. 2018 FINITE iset /\ 2019 (!i. i IN iset ==> ?p. p tagged_division_of i /\ d FINE p) /\ 2020 (!i1 i2. i1 IN iset /\ i2 IN iset /\ ~(i1 = i2) 2021 ==> (interior(i1) INTER interior(i2) = {})) /\ 2022 (BIGUNION iset = i) 2023 ==> ?p. p tagged_division_of i /\ d FINE p``, 2024 REPEAT GEN_TAC THEN 2025 KNOW_TAC ``(!i. i IN iset ==> ?p. p tagged_division_of i /\ d FINE p) = 2026 (!i. ?p. i IN iset ==> p tagged_division_of i /\ d FINE p)`` THENL 2027 [SIMP_TAC std_ss [RIGHT_EXISTS_IMP_THM], ALL_TAC] THEN DISC_RW_KILL THEN 2028 SIMP_TAC std_ss [SKOLEM_THM, LEFT_EXISTS_AND_THM, GSYM LEFT_EXISTS_IMP_THM] THEN 2029 REPEAT STRIP_TAC THEN FIRST_X_ASSUM(SUBST_ALL_TAC o SYM) THEN 2030 EXISTS_TAC ``BIGUNION (IMAGE(f:(real->bool)->((real#(real->bool))->bool)) 2031 iset)`` THEN 2032 ASM_SIMP_TAC std_ss [TAGGED_DIVISION_BIGUNION] THEN 2033 ASM_MESON_TAC[FINE_BIGUNION, IN_IMAGE]); 2034 2035(* ------------------------------------------------------------------------- *) 2036(* The set we're concerned with must be closed. *) 2037(* ------------------------------------------------------------------------- *) 2038 2039val DIVISION_OF_CLOSED = store_thm ("DIVISION_OF_CLOSED", 2040 ``!s i. s division_of i ==> closed i``, 2041 REWRITE_TAC[division_of] THEN MESON_TAC[CLOSED_BIGUNION, CLOSED_INTERVAL]); 2042 2043(* ------------------------------------------------------------------------- *) 2044(* General bisection principle for intervals; might be useful elsewhere. *) 2045(* ------------------------------------------------------------------------- *) 2046 2047val FINITE_POWERSET = store_thm ("FINITE_POWERSET", 2048 ``!s. FINITE s ==> FINITE {t | t SUBSET s}``, 2049 METIS_TAC [FINITE_POW, POW_DEF]); 2050 2051val lemma1 = Q.prove ( 2052 `!a b:real. ((a + b) / 2 - a) = ((a + b) - (a + a)) / 2`, 2053 REPEAT GEN_TAC THEN 2054 KNOW_TAC ``((a + b) / 2 - a) = ((a + b) / 2 - a / 1:real)`` THENL 2055 [METIS_TAC [REAL_OVER1], ALL_TAC] THEN DISC_RW_KILL THEN 2056 SIMP_TAC std_ss [REAL_ARITH ``1 <> 0:real /\ 2 <> 0:real``, REAL_SUB_RAT] THEN 2057 REWRITE_TAC [REAL_MUL_RID] THEN REWRITE_TAC [GSYM REAL_DOUBLE]); 2058 2059val lemma2 = Q.prove ( 2060 `!a b:real. (b - (a + b) / 2) = ((b + b) - (a + b)) / 2`, 2061 REPEAT GEN_TAC THEN 2062 KNOW_TAC ``(b - (a + b) / 2) = (b / 1 - (a + b) / 2:real)`` THENL 2063 [METIS_TAC [REAL_OVER1], ALL_TAC] THEN DISC_RW_KILL THEN 2064 SIMP_TAC std_ss [REAL_ARITH ``1 <> 0:real /\ 2 <> 0:real``, REAL_SUB_RAT] THEN 2065 REWRITE_TAC [REAL_MUL_LID] THEN METIS_TAC[REAL_MUL_SYM, GSYM REAL_DOUBLE]); 2066 2067val INTERVAL_BISECTION_STEP = store_thm ("INTERVAL_BISECTION_STEP", 2068 ``!P. P {} /\ 2069 (!s t. P s /\ P t /\ (interior(s) INTER interior(t) = {}) 2070 ==> P(s UNION t)) 2071 ==> !a b:real. 2072 ~(P(interval[a,b])) 2073 ==> ?c d. ~(P(interval[c,d])) /\ 2074 a <= c /\ c <= d /\ d <= b /\ 2075 &2 * (d - c) <= b - a``, 2076 REPEAT GEN_TAC THEN STRIP_TAC THEN REPEAT GEN_TAC THEN 2077 ASM_CASES_TAC ``(a:real) <= (b:real)`` THENL 2078 [ALL_TAC, 2079 RULE_ASSUM_TAC(REWRITE_RULE[GSYM INTERVAL_NE_EMPTY]) THEN 2080 ASM_REWRITE_TAC[]] THEN 2081 SUBGOAL_THEN 2082 ``!f. FINITE f /\ 2083 (!s:real->bool. s IN f ==> P s) /\ 2084 (!s:real->bool. s IN f ==> ?a b. s = interval[a,b]) /\ 2085 (!s t. s IN f /\ t IN f /\ ~(s = t) 2086 ==> (interior(s) INTER interior(t) = {})) 2087 ==> P(BIGUNION f)`` 2088 ASSUME_TAC THENL 2089 [ONCE_REWRITE_TAC[GSYM AND_IMP_INTRO] THEN GEN_TAC THEN 2090 KNOW_TAC ``((!s. s IN f ==> P s) /\ (!s. s IN f ==> ?a b. s = interval [(a,b)]) /\ 2091 (!s t. s IN f /\ t IN f /\ s <> t ==> 2092 (interior s INTER interior t = {})) ==> P (BIGUNION f)) = 2093 (\f. (!s. s IN f ==> P s) /\ (!s. s IN f ==> ?a b. s = interval [(a,b)]) /\ 2094 (!s t. s IN f /\ t IN f /\ s <> t ==> 2095 (interior s INTER interior t = {})) ==> P (BIGUNION f)) f`` THENL 2096 [FULL_SIMP_TAC std_ss [], ALL_TAC] THEN DISC_RW_KILL THEN 2097 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 2098 ASM_SIMP_TAC std_ss [BIGUNION_EMPTY, BIGUNION_INSERT, NOT_IN_EMPTY, FORALL_IN_INSERT] THEN 2099 SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM] THEN REWRITE_TAC[AND_IMP_INTRO] THEN 2100 X_GEN_TAC ``f :(real -> bool) -> bool`` THEN X_GEN_TAC ``x:real->bool`` THEN 2101 REPEAT GEN_TAC THEN DISCH_THEN(fn th => 2102 FIRST_X_ASSUM MATCH_MP_TAC THEN STRIP_ASSUME_TAC th) THEN 2103 ASM_REWRITE_TAC[] THEN CONJ_TAC THENL [REPEAT (POP_ASSUM MP_TAC) THEN SET_TAC[], ALL_TAC] THEN 2104 MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 2105 ASM_REWRITE_TAC[OPEN_INTERIOR] THEN REPEAT STRIP_TAC THEN 2106 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[IN_INSERT] THEN 2107 ASM_MESON_TAC[], ALL_TAC] THEN 2108 DISCH_TAC THEN 2109 FIRST_X_ASSUM(MP_TAC o SPEC 2110 ``{ interval[c,d] | 2111 ((c:real) = (a:real)) /\ (d = (a + b) / &2) \/ 2112 (c = (a + b) / &2) /\ ((d:real) = (b:real))}``) THEN 2113 ONCE_REWRITE_TAC[GSYM AND_IMP_INTRO] THEN 2114 KNOW_TAC ``FINITE {interval [(c,d)] | 2115 (c = a) /\ (d = (a + b) / 2) \/ (c = (a + b) / 2) /\ (d = b)}`` THENL 2116 [MATCH_MP_TAC FINITE_SUBSET THEN 2117 EXISTS_TAC 2118 ``IMAGE (\s. interval 2119 [(@f. f = if (1:num) IN s then (a:real) else (a + b) / &2):real, 2120 (@f. f = if (1:num) IN s then (a + b) / &2 else (b:real))]) 2121 {s | s SUBSET (1:num..1:num)}`` THEN 2122 CONJ_TAC THENL 2123 [SIMP_TAC std_ss [FINITE_POWERSET, IMAGE_FINITE, FINITE_NUMSEG], ALL_TAC] THEN 2124 SIMP_TAC std_ss [SUBSET_DEF, GSPECIFICATION, IN_IMAGE, EXISTS_PROD] THEN 2125 X_GEN_TAC ``k:real->bool`` THEN 2126 DISCH_THEN(X_CHOOSE_THEN ``c:real`` (X_CHOOSE_THEN ``d:real`` 2127 (CONJUNCTS_THEN2 SUBST1_TAC ASSUME_TAC))) THEN 2128 EXISTS_TAC ``{i | (i = 1:num) /\ ((c:real) = (a:real))}`` THEN 2129 CONJ_TAC THENL [ALL_TAC, SIMP_TAC std_ss [GSPECIFICATION, IN_NUMSEG]] THEN 2130 AP_TERM_TAC THEN REWRITE_TAC[CONS_11, PAIR_EQ] THEN 2131 SIMP_TAC std_ss [GSPECIFICATION] THEN POP_ASSUM MP_TAC THEN 2132 UNDISCH_TAC ``a <= b:real`` THEN REWRITE_TAC [AND_IMP_INTRO] THEN 2133 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN 2134 SIMP_TAC arith_ss [REAL_EQ_RDIV_EQ, REAL_LT] THEN 2135 REAL_ARITH_TAC, ALL_TAC] THEN 2136 DISCH_TAC THEN ASM_SIMP_TAC std_ss [] THEN 2137 GEN_REWR_TAC LAND_CONV [MONO_NOT_EQ] THEN 2138 KNOW_TAC `` (~(P :(real -> bool) -> bool) 2139 (BIGUNION {interval [(c,d)] | 2140 (c = (a :real)) /\ (d = (a + (b :real)) / (2 :real)) \/ 2141 (c = (a + b) / (2 :real)) /\ (d = b)}))`` THENL 2142 [UNDISCH_TAC ``~(P :(real -> bool) -> bool)(interval[a:real,b])`` THEN 2143 MATCH_MP_TAC EQ_IMPLIES THEN 2144 AP_TERM_TAC THEN AP_TERM_TAC THEN CONV_TAC SYM_CONV THEN 2145 GEN_REWR_TAC I [EXTENSION] THEN 2146 SIMP_TAC std_ss [IN_BIGUNION, GSPECIFICATION, EXISTS_PROD] THEN 2147 ONCE_REWRITE_TAC [CONJ_SYM] THEN X_GEN_TAC ``x:real`` THEN 2148 SIMP_TAC std_ss [GSYM LEFT_EXISTS_AND_THM] THEN 2149 ONCE_REWRITE_TAC[CONJ_SYM] THEN 2150 REWRITE_TAC[UNWIND_THM2, IN_INTERVAL] THEN 2151 ONCE_REWRITE_TAC[TAUT `c /\ (a \/ b) <=> ~(a ==> ~c) \/ ~(b ==> ~c)`] THEN 2152 REWRITE_TAC[TAUT `~(a ==> ~b) <=> a /\ b`, GSYM CONJ_ASSOC] THEN 2153 SIMP_TAC std_ss [EXISTS_OR_THM, RIGHT_EXISTS_AND_THM] THEN 2154 SIMP_TAC arith_ss [REAL_LE_LDIV_EQ, REAL_LE_RDIV_EQ, REAL_LT] THEN 2155 REAL_ARITH_TAC, ALL_TAC] THEN 2156 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 2157 KNOW_TAC `` 2158 (!(s :real -> bool). s IN {interval [(c,d)] | 2159 (c = a) /\ (d = (a + b) / (2 :real)) \/ 2160 (c = (a + b) / (2 :real)) /\ (d = b)} ==> 2161 ?(a :real) (b :real). s = interval [(a,b)]) = 2162 (!c d. (c = a) /\ (d = (a + b) / 2) \/ 2163 (c = (a + b) / 2) /\ (d = b) ==> 2164 ?a b. interval [(c,d)] = interval [(a,b)])`` THENL 2165 [SIMP_TAC std_ss [FORALL_IN_GSPEC], ALL_TAC] THEN DISC_RW_KILL THEN 2166 KNOW_TAC ``(!(s :real -> bool). s IN {interval [(c,d)] | 2167 (c = (a :real)) /\ (d = (a + (b :real)) / (2 :real)) \/ 2168 (c = (a + b) / (2 :real)) /\ (d = b)} ==> 2169 (P :(real -> bool) -> bool) s) = 2170 (!c d. (c = a) /\ (d = (a + b) / 2) \/ 2171 (c = (a + b) / 2) /\ (d = b) ==> 2172 (P :(real -> bool) -> bool) (interval [(c,d)])) `` THENL 2173 [SIMP_TAC std_ss [FORALL_IN_GSPEC], ALL_TAC] THEN DISC_RW_KILL THEN 2174 MATCH_MP_TAC(TAUT `b /\ (~a ==> e) /\ c ==> ~(a /\ b /\ c) ==> e`) THEN 2175 CONJ_TAC THENL [MESON_TAC[], ALL_TAC] THEN CONJ_TAC THENL 2176 [SIMP_TAC std_ss [NOT_FORALL_THM, NOT_IMP] THEN 2177 DISCH_THEN (X_CHOOSE_TAC ``c:real``) THEN EXISTS_TAC ``c:real`` THEN 2178 POP_ASSUM MP_TAC THEN DISCH_THEN (X_CHOOSE_TAC ``d:real``) THEN 2179 EXISTS_TAC ``d:real`` THEN POP_ASSUM MP_TAC THEN 2180 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN ASM_REWRITE_TAC[] THEN 2181 ASSUME_TAC REAL_MIDDLE1 THEN ASSUME_TAC REAL_MIDDLE2 THEN 2182 RW_TAC std_ss [] THENL [REAL_ARITH_TAC, METIS_TAC [], METIS_TAC [], 2183 ONCE_REWRITE_TAC [REAL_MUL_SYM] THEN SIMP_TAC std_ss [lemma1, 2184 REAL_DIV_RMUL, REAL_ARITH ``2 <> 0:real``] THEN REAL_ARITH_TAC, 2185 METIS_TAC [], METIS_TAC [], REAL_ARITH_TAC, ONCE_REWRITE_TAC [REAL_MUL_SYM] THEN 2186 SIMP_TAC std_ss [lemma2, REAL_DIV_RMUL, REAL_ARITH ``2 <> 0:real``] THEN 2187 REAL_ARITH_TAC], ALL_TAC] THEN 2188 SIMP_TAC std_ss [GSYM AND_IMP_INTRO, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC] THEN 2189 REWRITE_TAC[AND_IMP_INTRO, INTERIOR_CLOSED_INTERVAL] THEN 2190 SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM] THEN 2191 MAP_EVERY X_GEN_TAC 2192 [``c1:real``, ``d1:real``, ``c2:real``, ``d2:real``] THEN 2193 ASM_CASES_TAC ``(c1 = c2:real) /\ (d1 = d2:real)`` THENL 2194 [ASM_REWRITE_TAC[], ALL_TAC] THEN 2195 DISCH_THEN(fn th => 2196 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC (K ALL_TAC)) THEN MP_TAC th) THEN 2197 REWRITE_TAC[AND_IMP_INTRO] THEN 2198 UNDISCH_TAC ``~((c1 = c2:real) /\ (d1 = d2:real))`` THEN 2199 ASM_REWRITE_TAC[AND_IMP_INTRO] THEN 2200 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC STRIP_ASSUME_TAC) THEN 2201 ASM_REWRITE_TAC[EXTENSION, IN_INTERVAL, NOT_IN_EMPTY, IN_INTER] THEN 2202 SIMP_TAC arith_ss [REAL_EQ_RDIV_EQ, REAL_EQ_LDIV_EQ, REAL_LT] THEN 2203 REWRITE_TAC[ 2204 REAL_ARITH ``((a * &2 <> a + b) \/ (a + b <> b * &2)) <=> ~(a = b:real)``, 2205 REAL_ARITH ``((a + b <> a * &2) \/ (b * &2 <> a + b)) <=> ~(a = b:real)``] THEN 2206 DISCH_THEN(fn th => X_GEN_TAC ``x:real`` THEN MP_TAC th) THEN 2207 REAL_ARITH_TAC); 2208 2209val lemma1 = Q.prove (`!n. 2 pow n <> 0:real`, 2210 GEN_TAC THEN ONCE_REWRITE_TAC [EQ_SYM_EQ] THEN 2211 MATCH_MP_TAC REAL_LT_IMP_NE THEN MATCH_MP_TAC REAL_LET_TRANS THEN 2212 EXISTS_TAC ``&n:real`` THEN SIMP_TAC std_ss [REAL_POS, POW_2_LT]); 2213 2214val INTERVAL_BISECTION = store_thm ("INTERVAL_BISECTION", 2215 ``!P. P {} /\ 2216 (!s t. P s /\ P t /\ (interior(s) INTER interior(t) = {}) 2217 ==> P(s UNION t)) 2218 ==> !a b:real. 2219 ~(P(interval[a,b])) 2220 ==> ?x. x IN interval[a,b] /\ 2221 !e. &0 < e 2222 ==> ?c d. x IN interval[c,d] /\ 2223 interval[c,d] SUBSET ball(x,e) /\ 2224 interval[c,d] SUBSET interval[a,b] /\ 2225 ~P(interval[c,d])``, 2226 REPEAT STRIP_TAC THEN 2227 SUBGOAL_THEN 2228 ``?A B. (A(0) = a:real) /\ (B(0) = b) /\ 2229 !n. ~(P(interval[A(SUC n), B(SUC n)])) /\ 2230 A(n) <= A(SUC n) /\ A(SUC n) <= B(SUC n) /\ 2231 B(SUC n) <= B(n) /\ 2232 &2 * (B(SUC n) - A(SUC n)) <= B(n) - A(n)`` 2233 STRIP_ASSUME_TAC THENL 2234 [MP_TAC(ISPEC ``P:(real->bool)->bool`` INTERVAL_BISECTION_STEP) THEN 2235 ASM_REWRITE_TAC[] THEN 2236 KNOW_TAC ``((!a b. ~P (interval [(a,b)]) ==> 2237 ?c d. ~P (interval [(c,d)]) /\ a <= c /\ c <= d /\ d <= b /\ 2238 2 * (d - c) <= b - a)) = 2239 ((!a b. ?c d. ~P (interval [(a,b)]) ==> 2240 ~P (interval [(c,d)]) /\ a <= c /\ c <= d /\ d <= b /\ 2241 2 * (d - c) <= b - a))`` THENL 2242 [SIMP_TAC std_ss [GSYM RIGHT_EXISTS_IMP_THM], ALL_TAC] THEN 2243 DISC_RW_KILL THEN SIMP_TAC std_ss [SKOLEM_THM] THEN 2244 DISCH_THEN(X_CHOOSE_THEN ``C:real->real->real`` 2245 (X_CHOOSE_THEN ``D:real->real->real`` ASSUME_TAC)) THEN 2246 KNOW_TAC ``?E. ((E (0:num) = (a:real,b:real)) /\ 2247 (!n. E(SUC n) = (C (FST(E n)) (SND(E n)), 2248 D (FST(E n)) (SND(E n)))))`` THENL 2249 [RW_TAC real_ss [num_Axiom], ALL_TAC] THEN 2250 DISCH_THEN(X_CHOOSE_THEN ``E:num->real#real`` STRIP_ASSUME_TAC) THEN 2251 EXISTS_TAC ``\n. FST((E:num->real#real) n)`` THEN 2252 EXISTS_TAC ``\n. SND((E:num->real#real) n)`` THEN BETA_TAC THEN 2253 ASM_REWRITE_TAC[] THEN INDUCT_TAC THEN ASM_SIMP_TAC std_ss [], 2254 ALL_TAC] THEN 2255 SUBGOAL_THEN ``!e. &0 < e 2256 ==> ?n:num. !x y. x IN interval[A(n),B(n)] /\ y IN interval[A(n),B(n)] 2257 ==> dist(x,y:real) < e`` ASSUME_TAC THENL 2258 [X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN MP_TAC(SPEC 2259 ``sum(1:num..1:num) (\i. (b:real) - (a:real)) / e`` 2260 REAL_ARCH_POW2) THEN STRIP_TAC THEN EXISTS_TAC ``n:num`` THEN 2261 MAP_EVERY X_GEN_TAC [``x:real``, ``y:real``] THEN STRIP_TAC THEN 2262 MATCH_MP_TAC REAL_LET_TRANS THEN 2263 EXISTS_TAC ``sum(1:num..1:num)(\i. abs((x - y:real)))`` THEN 2264 CONJ_TAC THENL [REWRITE_TAC [NUMSEG_SING, SUM_SING, REAL_LE_REFL, dist] THEN 2265 REAL_ARITH_TAC, ALL_TAC] THEN 2266 MATCH_MP_TAC REAL_LET_TRANS THEN 2267 EXISTS_TAC ``sum(1:num..1:num) 2268 (\i. (B:num->real)(n) - (A:num->real)(n))`` THEN 2269 CONJ_TAC THENL 2270 [MATCH_MP_TAC SUM_LE_NUMSEG THEN REPEAT STRIP_TAC THEN BETA_TAC THEN 2271 MATCH_MP_TAC(REAL_ARITH ``a <= x /\ x <= b /\ a <= y /\ y <= b 2272 ==> abs(x - y) <= b - a:real``) THEN 2273 UNDISCH_TAC ``x IN interval[(A:num->real) n,B n]`` THEN 2274 UNDISCH_TAC ``y IN interval[(A:num->real) n,B n]`` THEN 2275 REWRITE_TAC[IN_INTERVAL] THEN ASM_SIMP_TAC std_ss [], 2276 ALL_TAC] THEN 2277 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC 2278 ``sum(1:num..1:num) (\i. (b:real) - (a:real)) / (2:real) pow n`` THEN 2279 CONJ_TAC THENL 2280 [ALL_TAC, 2281 SIMP_TAC arith_ss [REAL_LT_LDIV_EQ, REAL_POW_LT, REAL_LT] THEN 2282 ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 2283 ASM_SIMP_TAC std_ss [GSYM REAL_LT_LDIV_EQ]] THEN 2284 REWRITE_TAC[real_div] THEN ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 2285 REWRITE_TAC[GSYM SUM_LMUL] THEN MATCH_MP_TAC SUM_LE_NUMSEG THEN 2286 X_GEN_TAC ``j:num`` THEN STRIP_TAC THEN REWRITE_TAC[] THEN 2287 ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN REWRITE_TAC[GSYM real_div] THEN 2288 SPEC_TAC(``n:num``,``m:num``) THEN INDUCT_TAC THEN 2289 ASM_REWRITE_TAC[pow, REAL_OVER1, REAL_LE_REFL] THEN 2290 ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 2291 SIMP_TAC arith_ss [real_div, REAL_INV_MUL, REAL_MUL_ASSOC, lemma1, 2292 REAL_ARITH ``2 <> 0:real``] THEN 2293 SIMP_TAC arith_ss [GSYM real_div, REAL_LE_RDIV_EQ, REAL_LT] THEN 2294 ASM_MESON_TAC[REAL_LE_TRANS, REAL_MUL_SYM], ALL_TAC] THEN 2295 SUBGOAL_THEN ``?a:real. !n:num. a IN interval[A(n),B(n)]`` MP_TAC THENL 2296 [ONCE_REWRITE_TAC [METIS [] ``!a n. interval [(A n,B n)] = 2297 (\n. interval [(A n,B n)]) n``] THEN 2298 MATCH_MP_TAC DECREASING_CLOSED_NEST THEN 2299 ASM_SIMP_TAC std_ss [CLOSED_INTERVAL] THEN CONJ_TAC THENL 2300 [REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY] THEN 2301 METIS_TAC[REAL_NOT_LT, REAL_LE_TRANS], 2302 ALL_TAC] THEN 2303 REWRITE_TAC[LE_EXISTS] THEN SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 2304 X_GEN_TAC ``m:num`` THEN 2305 SIMP_TAC std_ss [GSYM LEFT_IMP_EXISTS_THM, EXISTS_REFL] THEN 2306 INDUCT_TAC THEN REWRITE_TAC[ADD_CLAUSES, SUBSET_REFL] THEN 2307 MATCH_MP_TAC SUBSET_TRANS THEN 2308 EXISTS_TAC ``interval[A(m + d:num):real,B(m + d)]`` THEN 2309 ASM_REWRITE_TAC[] THEN 2310 REWRITE_TAC[SUBSET_DEF, IN_INTERVAL] THEN ASM_MESON_TAC[REAL_LE_TRANS], 2311 ALL_TAC] THEN 2312 DISCH_THEN (X_CHOOSE_TAC ``x0:real``) THEN EXISTS_TAC ``x0:real`` THEN 2313 CONJ_TAC THENL [ASM_MESON_TAC[], ALL_TAC] THEN 2314 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 2315 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 2316 DISCH_THEN(X_CHOOSE_TAC ``n:num``) THEN 2317 MAP_EVERY EXISTS_TAC [``(A:num->real) n``, ``(B:num->real) n``] THEN 2318 ASM_REWRITE_TAC[] THEN REPEAT CONJ_TAC THENL 2319 [REWRITE_TAC[SUBSET_DEF, IN_BALL] THEN ASM_MESON_TAC[], 2320 ALL_TAC, 2321 SPEC_TAC(``n:num``,``p:num``) THEN INDUCT_TAC THEN ASM_REWRITE_TAC[]] THEN 2322 SUBGOAL_THEN 2323 ``!m n. m <= n ==> interval[(A:num->real) n,B n] SUBSET interval[A m,B m]`` 2324 (fn th => ASM_MESON_TAC[SUBSET_DEF, LE_0, th]) THEN 2325 ONCE_REWRITE_TAC [METIS [] ``!m n. (interval [(A n,B n)] SUBSET 2326 interval [(A m,B m)]) = 2327 (\m n. interval [(A n,B n)] SUBSET 2328 interval [(A m,B m)]) m n``] THEN 2329 MATCH_MP_TAC TRANSITIVE_STEPWISE_LE THEN 2330 REPEAT(CONJ_TAC THENL [SET_TAC[], ALL_TAC]) THEN 2331 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_MESON_TAC[]); 2332 2333(* ------------------------------------------------------------------------- *) 2334(* Cousin's lemma. *) 2335(* ------------------------------------------------------------------------- *) 2336 2337val FINE_DIVISION_EXISTS = store_thm ("FINE_DIVISION_EXISTS", 2338 ``!g a b:real. 2339 gauge g ==> ?p. p tagged_division_of (interval[a,b]) /\ g FINE p``, 2340 REPEAT STRIP_TAC THEN 2341 MP_TAC(ISPEC ``\s:real->bool. ?p. p tagged_division_of s /\ g FINE p`` 2342 INTERVAL_BISECTION) THEN 2343 SIMP_TAC std_ss [] THEN 2344 KNOW_TAC ``(?p. p tagged_division_of {} /\ g FINE p) /\ 2345 (!s t. 2346 (?p. p tagged_division_of s /\ g FINE p) /\ 2347 (?p. p tagged_division_of t /\ g FINE p) /\ 2348 (interior s INTER interior t = {}) ==> 2349 ?p. p tagged_division_of s UNION t /\ g FINE p)`` THENL 2350 [MESON_TAC[TAGGED_DIVISION_UNION, FINE_UNION, 2351 TAGGED_DIVISION_OF_EMPTY, FINE, NOT_IN_EMPTY], 2352 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 2353 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``])] THEN 2354 GEN_REWR_TAC LAND_CONV [MONO_NOT_EQ] THEN 2355 REWRITE_TAC [GSYM DE_MORGAN_THM] THEN 2356 REWRITE_TAC [METIS [] ``( ~!p. ~(p tagged_division_of interval [(a,b)] /\ g FINE p)) = 2357 ( ?p. (p tagged_division_of interval [(a,b)] /\ g FINE p))``] THEN 2358 DISCH_THEN MATCH_MP_TAC THEN 2359 DISCH_THEN(X_CHOOSE_THEN ``x:real`` (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 2360 FIRST_ASSUM(MP_TAC o SPEC ``x:real`` o REWRITE_RULE[gauge_def]) THEN 2361 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 2362 SIMP_TAC std_ss [OPEN_CONTAINS_BALL, NOT_FORALL_THM] THEN 2363 DISCH_THEN(MP_TAC o SPEC ``x:real``) THEN ASM_REWRITE_TAC[] THEN 2364 STRIP_TAC THEN EXISTS_TAC ``e:real`` THEN 2365 ASM_SIMP_TAC std_ss [NOT_EXISTS_THM] THEN 2366 MAP_EVERY X_GEN_TAC [``c:real``, ``d:real``] THEN 2367 CCONTR_TAC THEN FULL_SIMP_TAC std_ss [] THEN 2368 FIRST_X_ASSUM(MP_TAC o SPEC ``{(x:real,interval[c:real,d])}``) THEN 2369 ASM_SIMP_TAC std_ss [TAGGED_DIVISION_OF_SELF] THEN 2370 SIMP_TAC std_ss [FINE, IN_SING, PAIR_EQ] THEN ASM_MESON_TAC[SUBSET_TRANS]); 2371 2372(* ------------------------------------------------------------------------- *) 2373(* Basic theorems about integrals. *) 2374(* ------------------------------------------------------------------------- *) 2375 2376val HAS_INTEGRAL_UNIQUE = store_thm ("HAS_INTEGRAL_UNIQUE", 2377 ``!f:real->real i k1 k2. 2378 (f has_integral k1) i /\ (f has_integral k2) i ==> (k1 = k2)``, 2379 REPEAT GEN_TAC THEN 2380 SUBGOAL_THEN 2381 ``!f:real->real a b k1 k2. 2382 (f has_integral k1) (interval[a,b]) /\ 2383 (f has_integral k2) (interval[a,b]) 2384 ==> (k1 = k2)`` 2385 MP_TAC THENL 2386 [REPEAT GEN_TAC THEN REWRITE_TAC[has_integral] THEN 2387 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN 2388 REWRITE_TAC[TAUT `(a ==> b) /\ (a ==> c) <=> a ==> b /\ c`] THEN 2389 ONCE_REWRITE_TAC[MONO_NOT_EQ] THEN 2390 ONCE_REWRITE_TAC[GSYM REAL_SUB_0] THEN 2391 REWRITE_TAC[REAL_ARITH ``!x. ~(x:real = &0) <=> &0 < abs x``] THEN DISCH_TAC THEN 2392 DISCH_THEN(MP_TAC o SPEC ``abs(k1 - k2 :real) / &2``) THEN 2393 ASM_REWRITE_TAC[REAL_LT_HALF1] THEN 2394 DISCH_THEN(CONJUNCTS_THEN2 2395 (X_CHOOSE_THEN ``d1:real->real->bool`` STRIP_ASSUME_TAC) 2396 (X_CHOOSE_THEN ``d2:real->real->bool`` STRIP_ASSUME_TAC)) THEN 2397 MP_TAC(ISPEC ``\x. ((d1:real->real->bool) x) INTER (d2 x)`` 2398 FINE_DIVISION_EXISTS) THEN 2399 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 2400 ASM_SIMP_TAC std_ss [GAUGE_INTER] THEN 2401 KNOW_TAC ``(?p. p tagged_division_of interval [a,b] /\ 2402 (\x. d1 x INTER d2 x) FINE p) ==> F`` THENL 2403 [ALL_TAC,METIS_TAC []] THEN POP_ASSUM MP_TAC THEN 2404 UNDISCH_TAC `` !p. 2405 p tagged_division_of interval [(a,b)] /\ d1 FINE p ==> 2406 abs (sum p (\(x,k). content k * f x) - k1) < abs (k1 - k2) / 2`` THEN 2407 REWRITE_TAC [] THEN SIMP_TAC std_ss [AND_IMP_INTRO, NOT_EXISTS_THM] THEN 2408 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN DISCH_TAC THEN 2409 GEN_TAC THEN POP_ASSUM (MP_TAC o Q.SPEC `(p :real # (real -> bool) -> bool)`) THEN 2410 REWRITE_TAC [GSYM DE_MORGAN_THM] THEN 2411 MATCH_MP_TAC(TAUT 2412 `(f0 ==> f1 /\ f2) /\ ~(n1 /\ n2) 2413 ==> (t /\ f1 ==> n1) /\ (t /\ f2 ==> n2) ==> ~(t /\ f0)`) THEN 2414 CONJ_TAC THENL [SIMP_TAC std_ss [FINE, SUBSET_INTER], ALL_TAC] THEN 2415 MATCH_MP_TAC(METIS [REAL_HALF, REAL_LT_ADD2, REAL_NOT_LE] 2416 ``c:real <= a + b ==> ~(a < c / &2 /\ b < c / &2)``) THEN 2417 MESON_TAC[ABS_SUB, ABS_TRIANGLE, REAL_ARITH 2418 ``k1 - k2:real = (k1 - x) + (x - k2)``], 2419 ALL_TAC] THEN 2420 DISCH_TAC THEN ONCE_REWRITE_TAC[has_integral_alt] THEN 2421 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THENL 2422 [ASM_MESON_TAC[], ALL_TAC] THEN 2423 DISCH_TAC THEN MATCH_MP_TAC(REAL_ARITH 2424 ``~(&0:real < abs(x - y)) ==> (x = y)``) THEN 2425 DISCH_TAC THEN 2426 FIRST_X_ASSUM(CONJUNCTS_THEN (MP_TAC o SPEC ``abs(k1 - k2:real) / &2``)) THEN 2427 ASM_REWRITE_TAC[REAL_HALF] THEN 2428 DISCH_THEN(X_CHOOSE_THEN ``B1:real`` STRIP_ASSUME_TAC) THEN 2429 DISCH_THEN(X_CHOOSE_THEN ``B2:real`` STRIP_ASSUME_TAC) THEN 2430 MP_TAC(ISPEC 2431 ``ball(0,B1) UNION ball(0:real,B2)`` 2432 BOUNDED_SUBSET_CLOSED_INTERVAL) THEN 2433 SIMP_TAC std_ss [BOUNDED_UNION, BOUNDED_BALL, UNION_SUBSET, NOT_EXISTS_THM] THEN 2434 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 2435 REWRITE_TAC [GSYM DE_MORGAN_THM] THEN 2436 DISCH_THEN(CONJUNCTS_THEN(ANTE_RES_THEN MP_TAC)) THEN 2437 DISCH_THEN(X_CHOOSE_THEN ``w:real`` STRIP_ASSUME_TAC) THEN 2438 DISCH_THEN(X_CHOOSE_THEN ``z:real`` STRIP_ASSUME_TAC) THEN 2439 SUBGOAL_THEN ``w:real = z:real`` SUBST_ALL_TAC THENL 2440 [METIS_TAC [], ALL_TAC] THEN 2441 KNOW_TAC ``~(abs(z - k1) < abs(k1 - k2) / &2:real /\ 2442 abs(z - k2) < abs(k1 - k2) / &2:real)`` THENL 2443 [SIMP_TAC arith_ss [REAL_LT_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 2444 REWRITE_TAC [GSYM REAL_DOUBLE] THEN REAL_ARITH_TAC, ALL_TAC] THEN 2445 METIS_TAC[]); 2446 2447val INTEGRAL_UNIQUE = store_thm ("INTEGRAL_UNIQUE", 2448 ``!f y k. 2449 (f has_integral y) k ==> (integral k f = y)``, 2450 REPEAT STRIP_TAC THEN REWRITE_TAC[integral] THEN 2451 MATCH_MP_TAC SELECT_UNIQUE THEN ASM_MESON_TAC[HAS_INTEGRAL_UNIQUE]);; 2452 2453val HAS_INTEGRAL_INTEGRABLE_INTEGRAL = store_thm ("HAS_INTEGRAL_INTEGRABLE_INTEGRAL", 2454 ``!f:real->real i s. 2455 (f has_integral i) s <=> f integrable_on s /\ (integral s f = i)``, 2456 MESON_TAC[INTEGRABLE_INTEGRAL, INTEGRAL_UNIQUE, integrable_on]); 2457 2458val INTEGRAL_EQ_HAS_INTEGRAL = store_thm ("INTEGRAL_EQ_HAS_INTEGRAL", 2459 ``!s f y. f integrable_on s ==> ((integral s f = y) <=> (f has_integral y) s)``, 2460 MESON_TAC[INTEGRABLE_INTEGRAL, INTEGRAL_UNIQUE]); 2461 2462val HAS_INTEGRAL_IS_0 = store_thm ("HAS_INTEGRAL_IS_0", 2463 ``!f:real->real s. 2464 (!x. x IN s ==> (f(x) = 0)) ==> (f has_integral 0) s``, 2465 SUBGOAL_THEN 2466 ``!f:real->real a b. 2467 (!x. x IN interval[a,b] ==> (f(x) = 0)) 2468 ==> (f has_integral 0) (interval[a,b])`` 2469 ASSUME_TAC THENL 2470 [REPEAT STRIP_TAC THEN REWRITE_TAC[has_integral] THEN 2471 REPEAT STRIP_TAC THEN EXISTS_TAC ``\x:real. ball(x,&1)`` THEN 2472 SIMP_TAC std_ss [gauge_def, OPEN_BALL, CENTRE_IN_BALL, REAL_LT_01] THEN 2473 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_SUB_RZERO] THEN 2474 UNDISCH_TAC ``&0 < e:real`` THEN MATCH_MP_TAC(TAUT `(a <=> b) ==> b ==> a`) THEN 2475 AP_THM_TAC THEN AP_TERM_TAC THEN 2476 REWRITE_TAC[ABS_ZERO, REAL_SUB_0, REAL_ADD_LID] THEN 2477 MATCH_MP_TAC SUM_EQ_0 THEN SIMP_TAC std_ss [FORALL_PROD] THEN 2478 X_GEN_TAC ``x:real`` THEN REPEAT STRIP_TAC THEN 2479 SUBGOAL_THEN ``(x:real) IN interval[a,b]`` 2480 (fn th => ASM_SIMP_TAC std_ss [th, REAL_MUL_RZERO]) THEN 2481 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 2482 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [tagged_division_of]) THEN 2483 REWRITE_TAC[tagged_partial_division_of, SUBSET_DEF] THEN ASM_MESON_TAC[], 2484 ALL_TAC] THEN 2485 REPEAT STRIP_TAC THEN ONCE_REWRITE_TAC[has_integral_alt] THEN 2486 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THENL 2487 [ASM_MESON_TAC[], ALL_TAC] THEN 2488 GEN_TAC THEN DISCH_TAC THEN EXISTS_TAC ``&1:real`` THEN REWRITE_TAC[REAL_LT_01] THEN 2489 REPEAT STRIP_TAC THEN EXISTS_TAC ``0:real`` THEN 2490 ASM_REWRITE_TAC[REAL_SUB_REFL, ABS_0] THEN 2491 FIRST_X_ASSUM MATCH_MP_TAC THEN METIS_TAC[]); 2492 2493val HAS_INTEGRAL_0 = store_thm ("HAS_INTEGRAL_0", 2494 ``!s. ((\x. 0) has_integral 0) s``, 2495 SIMP_TAC std_ss [HAS_INTEGRAL_IS_0]); 2496 2497val HAS_INTEGRAL_0_EQ = store_thm ("HAS_INTEGRAL_0_EQ", 2498 ``!i s. ((\x. 0) has_integral i) s <=> (i = 0)``, 2499 MESON_TAC[HAS_INTEGRAL_UNIQUE, HAS_INTEGRAL_0]); 2500 2501val HAS_INTEGRAL_LINEAR = store_thm ("HAS_INTEGRAL_LINEAR", 2502 ``!f:real->real y s h:real->real. 2503 (f has_integral y) s /\ linear h ==> ((h o f) has_integral h(y)) s``, 2504 SUBGOAL_THEN 2505 ``!f:real->real y a b h:real->real. 2506 (f has_integral y) (interval[a,b]) /\ linear h 2507 ==> ((h o f) has_integral h(y)) (interval[a,b])`` 2508 MP_TAC THENL 2509 [REPEAT GEN_TAC THEN REWRITE_TAC[has_integral] THEN STRIP_TAC THEN 2510 FIRST_ASSUM(MP_TAC o MATCH_MP LINEAR_BOUNDED_POS) THEN 2511 DISCH_THEN(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) THEN 2512 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 2513 UNDISCH_TAC ``!e. 2514 0 < e ==> ?d. gauge d /\ 2515 !p. p tagged_division_of interval [(a,b)] /\ d FINE p ==> 2516 abs (sum p (\(x,k). content k * f x) - y) < e`` THEN 2517 DISCH_TAC THEN 2518 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real / B``) THEN 2519 ASM_SIMP_TAC std_ss [REAL_LT_DIV] THEN 2520 STRIP_TAC THEN EXISTS_TAC ``d:real -> real -> bool`` THEN 2521 ASM_SIMP_TAC std_ss [] THEN 2522 X_GEN_TAC ``p:real#(real->bool)->bool`` THEN STRIP_TAC THEN 2523 FIRST_X_ASSUM(MP_TAC o SPEC ``p:real#(real->bool)->bool``) THEN 2524 ASM_SIMP_TAC std_ss [REAL_LT_RDIV_EQ] THEN ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 2525 MATCH_MP_TAC(REAL_ARITH ``x <= y ==> y < e ==> x < e:real``) THEN 2526 FIRST_ASSUM(fn th => W(fn (asl,w) => 2527 MP_TAC(PART_MATCH rand th (rand w)))) THEN 2528 MATCH_MP_TAC(REAL_ARITH ``x <= y ==> y <= e ==> x <= e:real``) THEN 2529 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 2530 ASM_SIMP_TAC std_ss [LINEAR_SUB, LINEAR_SUM, o_DEF, LAMBDA_PROD, 2531 REAL_MUL_SYM, LINEAR_CMUL, REAL_LE_REFL], ALL_TAC] THEN 2532 DISCH_TAC THEN REPEAT GEN_TAC THEN 2533 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 2534 ONCE_REWRITE_TAC[has_integral_alt] THEN 2535 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THENL 2536 [ASM_MESON_TAC[], ALL_TAC] THEN 2537 DISCH_TAC THEN 2538 FIRST_ASSUM(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC o MATCH_MP 2539 LINEAR_BOUNDED_POS) THEN 2540 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 2541 UNDISCH_TAC ``!e. 2542 0 < e ==> ?B. 0 < B /\ 2543 !a b. ball (0,B) SUBSET interval [(a,b)] ==> 2544 ?z. ((\x. if x IN s then f x else 0) has_integral z) 2545 (interval [(a,b)]) /\ abs (z - y) < e`` THEN 2546 DISCH_TAC THEN 2547 FIRST_X_ASSUM(MP_TAC o SPEC ``e / B:real``) THEN 2548 ASM_SIMP_TAC std_ss [REAL_LT_DIV] THEN 2549 DISCH_THEN (X_CHOOSE_TAC ``M:real``) THEN 2550 EXISTS_TAC ``M:real`` THEN POP_ASSUM MP_TAC THEN 2551 MATCH_MP_TAC MONO_AND THEN REWRITE_TAC[] THEN 2552 DISCH_TAC THEN MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 2553 POP_ASSUM (MP_TAC o Q.SPECL [`a:real`, `b:real`]) THEN 2554 MATCH_MP_TAC MONO_IMP THEN REWRITE_TAC[] THEN 2555 DISCH_THEN(X_CHOOSE_THEN ``z:real`` STRIP_ASSUME_TAC) THEN 2556 EXISTS_TAC ``(h:real->real) z`` THEN 2557 SUBGOAL_THEN 2558 ``(\x. if x IN s then (h:real->real) ((f:real->real) x) else 0) 2559 = h o (\x. if x IN s then f x else 0)`` 2560 SUBST1_TAC THENL 2561 [SIMP_TAC std_ss [FUN_EQ_THM, o_THM] THEN METIS_TAC[LINEAR_0], ALL_TAC] THEN 2562 ASM_SIMP_TAC std_ss [GSYM LINEAR_SUB] THEN 2563 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC ``B * abs(z - y:real)`` THEN 2564 ASM_REWRITE_TAC[] THEN ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 2565 ASM_SIMP_TAC std_ss [GSYM REAL_LT_RDIV_EQ]); 2566 2567val HAS_INTEGRAL_CMUL = store_thm ("HAS_INTEGRAL_CMUL", 2568 ``!(f:real->real) k s c. 2569 (f has_integral k) s 2570 ==> ((\x. c * f(x)) has_integral (c * k)) s``, 2571 REPEAT STRIP_TAC THEN MATCH_MP_TAC 2572 (REWRITE_RULE[o_DEF] HAS_INTEGRAL_LINEAR) THEN 2573 ASM_REWRITE_TAC[linear] THEN CONJ_TAC THEN REAL_ARITH_TAC); 2574 2575val HAS_INTEGRAL_NEG = store_thm ("HAS_INTEGRAL_NEG", 2576 ``!f k s. (f has_integral k) s ==> ((\x. -(f x)) has_integral (-k)) s``, 2577 ONCE_REWRITE_TAC[REAL_NEG_MINUS1] THEN REWRITE_TAC[HAS_INTEGRAL_CMUL]); 2578 2579val HAS_INTEGRAL_ADD = store_thm ("HAS_INTEGRAL_ADD", 2580 ``!f:real->real g s k. 2581 (f has_integral k) s /\ (g has_integral l) s 2582 ==> ((\x. f(x) + g(x)) has_integral (k + l)) s``, 2583 SUBGOAL_THEN 2584 ``!f:real->real g k l a b. 2585 (f has_integral k) (interval[a,b]) /\ 2586 (g has_integral l) (interval[a,b]) 2587 ==> ((\x. f(x) + g(x)) has_integral (k + l)) (interval[a,b])`` 2588 ASSUME_TAC THENL 2589 [REPEAT GEN_TAC THEN SIMP_TAC std_ss [has_integral, GSYM FORALL_AND_THM] THEN 2590 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 2591 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 2592 DISCH_THEN(CONJUNCTS_THEN2 2593 (X_CHOOSE_THEN ``d1:real->real->bool`` STRIP_ASSUME_TAC) 2594 (X_CHOOSE_THEN ``d2:real->real->bool`` STRIP_ASSUME_TAC)) THEN 2595 EXISTS_TAC ``\x. ((d1:real->real->bool) x) INTER (d2 x)`` THEN 2596 ASM_SIMP_TAC std_ss [GAUGE_INTER] THEN 2597 REWRITE_TAC[tagged_division_of, tagged_partial_division_of] THEN 2598 SIMP_TAC std_ss [SUM_ADD, REAL_ADD_LDISTRIB, LAMBDA_PAIR] THEN 2599 SIMP_TAC std_ss [GSYM LAMBDA_PAIR] THEN 2600 REWRITE_TAC [METIS [] ``(a <> b) = ~(a = b)``, GSYM DE_MORGAN_THM] THEN 2601 REWRITE_TAC [GSYM PAIR_EQ] THEN 2602 SIMP_TAC std_ss [GSYM tagged_partial_division_of] THEN 2603 REWRITE_TAC[GSYM tagged_division_of, FINE_INTER] THEN 2604 SIMP_TAC std_ss [REAL_ARITH ``(a + b) - (c + d) = (a - c) + (b - d):real``] THEN 2605 REPEAT STRIP_TAC THEN MATCH_MP_TAC ABS_TRIANGLE_LT THEN 2606 MATCH_MP_TAC(METIS [REAL_HALF, REAL_LT_ADD2] 2607 ``x < e / &2 /\ y < e / &2 ==> x + y < e:real``) THEN 2608 ASM_SIMP_TAC std_ss [], ALL_TAC] THEN 2609 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[has_integral_alt] THEN 2610 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THENL 2611 [METIS_TAC[], ALL_TAC] THEN 2612 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 2613 FIRST_X_ASSUM(CONJUNCTS_THEN (MP_TAC o SPEC ``e / &2:real``)) THEN 2614 ASM_REWRITE_TAC[REAL_HALF] THEN 2615 DISCH_THEN(X_CHOOSE_THEN ``B1:real`` STRIP_ASSUME_TAC) THEN 2616 DISCH_THEN(X_CHOOSE_THEN ``B2:real`` STRIP_ASSUME_TAC) THEN 2617 EXISTS_TAC ``max B1 B2:real`` THEN ASM_REWRITE_TAC[REAL_LT_MAX] THEN 2618 REWRITE_TAC[BALL_MAX_UNION, UNION_SUBSET] THEN 2619 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 2620 DISCH_THEN(CONJUNCTS_THEN(ANTE_RES_THEN MP_TAC)) THEN 2621 DISCH_THEN(X_CHOOSE_THEN ``w:real`` STRIP_ASSUME_TAC) THEN 2622 DISCH_THEN(X_CHOOSE_THEN ``z:real`` STRIP_ASSUME_TAC) THEN 2623 EXISTS_TAC ``w + z:real`` THEN BETA_TAC THEN 2624 SUBGOAL_THEN 2625 ``(\x. if x IN s then (f:real->real) x + g x else 0) = 2626 (\x. (if x IN s then f x else 0) + (if x IN s then g x else 0))`` 2627 SUBST1_TAC THENL 2628 [SIMP_TAC std_ss [FUN_EQ_THM] THEN GEN_TAC THEN COND_CASES_TAC THEN 2629 ASM_REWRITE_TAC[] THEN REAL_ARITH_TAC, 2630 ALL_TAC] THEN 2631 ASM_SIMP_TAC std_ss [] THEN 2632 REWRITE_TAC [REAL_ARITH ``(w + z - (k + l)) = ((w - k) + (z - l):real)``] THEN 2633 METIS_TAC [ABS_TRIANGLE_LT, REAL_HALF, REAL_LT_ADD2]); 2634 2635val HAS_INTEGRAL_SUB = store_thm ("HAS_INTEGRAL_SUB", 2636 ``!f:real->real g s k l. 2637 (f has_integral k) s /\ (g has_integral l) s 2638 ==> ((\x. f(x) - g(x)) has_integral (k - l)) s``, 2639 SIMP_TAC std_ss [real_sub, HAS_INTEGRAL_NEG, HAS_INTEGRAL_ADD]); 2640 2641val INTEGRAL_0 = store_thm ("INTEGRAL_0", 2642 ``!s. integral s (\x. 0) = 0``, 2643 MESON_TAC[INTEGRAL_UNIQUE, HAS_INTEGRAL_0]); 2644 2645val INTEGRAL_ADD = store_thm ("INTEGRAL_ADD", 2646 ``!f:real->real g s. 2647 f integrable_on s /\ g integrable_on s 2648 ==> (integral s (\x. f x + g x) = integral s f + integral s g)``, 2649 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 2650 MATCH_MP_TAC HAS_INTEGRAL_ADD THEN ASM_SIMP_TAC std_ss [INTEGRABLE_INTEGRAL]); 2651 2652val INTEGRAL_CMUL = store_thm ("INTEGRAL_CMUL", 2653 ``!f:real->real c s. 2654 f integrable_on s ==> (integral s (\x. c * f(x)) = c * integral s f)``, 2655 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 2656 MATCH_MP_TAC HAS_INTEGRAL_CMUL THEN ASM_SIMP_TAC std_ss [INTEGRABLE_INTEGRAL]); 2657 2658val INTEGRAL_NEG = store_thm ("INTEGRAL_NEG", 2659 ``!f:real->real s. 2660 f integrable_on s ==> (integral s (\x. -f(x)) = -integral s f)``, 2661 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 2662 MATCH_MP_TAC HAS_INTEGRAL_NEG THEN ASM_SIMP_TAC std_ss [INTEGRABLE_INTEGRAL]); 2663 2664val INTEGRAL_SUB = store_thm ("INTEGRAL_SUB", 2665 ``!f:real->real g k l s. 2666 f integrable_on s /\ g integrable_on s 2667 ==> (integral s (\x. f x - g x) = integral s f - integral s g)``, 2668 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 2669 MATCH_MP_TAC HAS_INTEGRAL_SUB THEN ASM_SIMP_TAC std_ss [INTEGRABLE_INTEGRAL]); 2670 2671val INTEGRABLE_0 = store_thm ("INTEGRABLE_0", 2672 ``!s. (\x. 0) integrable_on s``, 2673 REWRITE_TAC[integrable_on] THEN MESON_TAC[HAS_INTEGRAL_0]); 2674 2675val INTEGRABLE_ADD = store_thm ("INTEGRABLE_ADD", 2676 ``!f:real->real g s. 2677 f integrable_on s /\ g integrable_on s 2678 ==> (\x. f x + g x) integrable_on s``, 2679 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_ADD]); 2680 2681val INTEGRABLE_CMUL = store_thm ("INTEGRABLE_CMUL", 2682 ``!f:real->real c s. 2683 f integrable_on s ==> (\x. c * f(x)) integrable_on s``, 2684 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_CMUL]); 2685 2686val INTEGRABLE_CMUL_EQ = store_thm ("INTEGRABLE_CMUL_EQ", 2687 ``!f:real->real s c. 2688 (\x. c * f x) integrable_on s <=> (c = &0) \/ f integrable_on s``, 2689 REPEAT(STRIP_TAC ORELSE EQ_TAC) THEN 2690 ASM_SIMP_TAC std_ss [INTEGRABLE_CMUL, REAL_MUL_LZERO, INTEGRABLE_0] THEN 2691 ASM_CASES_TAC ``c = &0:real`` THEN ASM_REWRITE_TAC[] THEN 2692 FIRST_X_ASSUM(MP_TAC o SPEC ``inv c:real`` o MATCH_MP INTEGRABLE_CMUL) THEN 2693 ASM_SIMP_TAC std_ss [REAL_MUL_ASSOC, REAL_MUL_LID, REAL_MUL_LINV, ETA_AX]); 2694 2695val INTEGRABLE_NEG = store_thm ("INTEGRABLE_NEG", 2696 ``!f:real->real s. 2697 f integrable_on s ==> (\x. -f(x)) integrable_on s``, 2698 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_NEG]); 2699 2700val INTEGRABLE_SUB = store_thm ("INTEGRABLE_SUB", 2701 ``!f:real->real g s. 2702 f integrable_on s /\ g integrable_on s 2703 ==> (\x. f x - g x) integrable_on s``, 2704 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_SUB]); 2705 2706val INTEGRABLE_LINEAR = store_thm ("INTEGRABLE_LINEAR", 2707 ``!f h s. f integrable_on s /\ linear h ==> (h o f) integrable_on s``, 2708 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_LINEAR]); 2709 2710val INTEGRAL_LINEAR = store_thm ("INTEGRAL_LINEAR", 2711 ``!f:real->real s h:real->real. 2712 f integrable_on s /\ linear h 2713 ==> (integral s (h o f) = h(integral s f))``, 2714 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_UNIQUE THEN 2715 MAP_EVERY EXISTS_TAC 2716 [``(h:real->real) o (f:real->real)``, ``s:real->bool``] THEN 2717 CONJ_TAC THENL [ALL_TAC, MATCH_MP_TAC HAS_INTEGRAL_LINEAR] THEN 2718 ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRAL, INTEGRABLE_LINEAR]); 2719 2720val HAS_INTEGRAL_SUM = store_thm ("HAS_INTEGRAL_SUM", 2721 ``!f:'a->real->real s t. 2722 FINITE t /\ 2723 (!a. a IN t ==> ((f a) has_integral (i a)) s) 2724 ==> ((\x. sum t (\a. f a x)) has_integral (sum t i)) s``, 2725 GEN_TAC THEN GEN_TAC THEN REWRITE_TAC[IMP_CONJ] THEN 2726 KNOW_TAC ``!t. ((!a. a IN t ==> ((f:'a->real->real) a has_integral i a) s) ==> 2727 ((\x. sum t (\a. f a x)) has_integral sum t i) s) = 2728 (\t. (!a. a IN t ==> (f a has_integral i a) s) ==> 2729 ((\x. sum t (\a. f a x)) has_integral sum t i) s) t`` THENL 2730 [FULL_SIMP_TAC std_ss [], ALL_TAC] THEN DISC_RW_KILL THEN 2731 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 2732 SIMP_TAC std_ss [SUM_CLAUSES, HAS_INTEGRAL_0, IN_INSERT] THEN 2733 REPEAT STRIP_TAC THEN 2734 ONCE_REWRITE_TAC [METIS [] ``!x. sum s' (\a. f a x) = 2735 (\x. sum s' (\a. f a x)) x``] THEN 2736 MATCH_MP_TAC HAS_INTEGRAL_ADD THEN 2737 ASM_SIMP_TAC std_ss [ETA_AX] THEN CONJ_TAC THEN 2738 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC std_ss []); 2739 2740val INTEGRAL_SUM = store_thm ("INTEGRAL_SUM", 2741 ``!f:'a->real->real s t. 2742 FINITE t /\ 2743 (!a. a IN t ==> (f a) integrable_on s) 2744 ==> (integral s (\x. sum t (\a. f a x)) = 2745 sum t (\a. integral s (f a)))``, 2746 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 2747 MATCH_MP_TAC HAS_INTEGRAL_SUM THEN ASM_SIMP_TAC std_ss [INTEGRABLE_INTEGRAL]); 2748 2749val INTEGRABLE_SUM = store_thm ("INTEGRABLE_SUM", 2750 ``!f:'a->real->real s t. 2751 FINITE t /\ 2752 (!a. a IN t ==> (f a) integrable_on s) 2753 ==> (\x. sum t (\a. f a x)) integrable_on s``, 2754 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_SUM]); 2755 2756val HAS_INTEGRAL_EQ = store_thm ("HAS_INTEGRAL_EQ", 2757 ``!f:real->real g k s. 2758 (!x. x IN s ==> (f(x) = g(x))) /\ 2759 (f has_integral k) s 2760 ==> (g has_integral k) s``, 2761 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[GSYM REAL_SUB_0] THEN 2762 ONCE_REWRITE_TAC [METIS [] ``(!x:real. x IN s ==> (f x - g x = 0:real)) = 2763 (!x:real. x IN s ==> ((\x. f x - g x) x = 0:real))``] THEN 2764 DISCH_THEN(CONJUNCTS_THEN2 (MP_TAC o MATCH_MP HAS_INTEGRAL_IS_0) MP_TAC) THEN 2765 REWRITE_TAC[AND_IMP_INTRO] THEN DISCH_THEN(MP_TAC o MATCH_MP HAS_INTEGRAL_SUB) THEN 2766 SIMP_TAC std_ss [REAL_ARITH ``x - (x - y:real) = y``, ETA_AX, REAL_SUB_RZERO]); 2767 2768val INTEGRABLE_EQ = store_thm ("INTEGRABLE_EQ", 2769 ``!f:real->real g s. 2770 (!x. x IN s ==> (f(x) = g(x))) /\ 2771 f integrable_on s 2772 ==> g integrable_on s``, 2773 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_EQ]); 2774 2775val HAS_INTEGRAL_EQ_EQ = store_thm ("HAS_INTEGRAL_EQ_EQ", 2776 ``!f:real->real g k s. 2777 (!x. x IN s ==> (f(x) = g(x))) 2778 ==> ((f has_integral k) s <=> (g has_integral k) s)``, 2779 METIS_TAC[HAS_INTEGRAL_EQ]); 2780 2781val HAS_INTEGRAL_NULL = store_thm ("HAS_INTEGRAL_NULL", 2782 ``!f:real->real a b. 2783 (content(interval[a,b]) = &0) ==> (f has_integral 0) (interval[a,b])``, 2784 REPEAT STRIP_TAC THEN REWRITE_TAC[has_integral] THEN 2785 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 2786 EXISTS_TAC ``\x:real. ball(x,&1)`` THEN REWRITE_TAC[GAUGE_TRIVIAL] THEN 2787 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_SUB_RZERO] THEN 2788 MATCH_MP_TAC(REAL_ARITH ``(x = &0) /\ &0 < e ==> x < e:real``) THEN 2789 ASM_REWRITE_TAC[ABS_ZERO] THEN METIS_TAC[SUM_CONTENT_NULL]); 2790 2791val HAS_INTEGRAL_NULL_EQ = store_thm ("HAS_INTEGRAL_NULL_EQ", 2792 ``!f a b i. (content(interval[a,b]) = &0) 2793 ==> ((f has_integral i) (interval[a,b]) <=> (i = 0))``, 2794 METIS_TAC[INTEGRAL_UNIQUE, HAS_INTEGRAL_NULL]); 2795 2796val INTEGRAL_NULL = store_thm ("INTEGRAL_NULL", 2797 ``!f a b. (content(interval[a,b]) = &0) 2798 ==> (integral(interval[a,b]) f = 0)``, 2799 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 2800 METIS_TAC[HAS_INTEGRAL_NULL]); 2801 2802val INTEGRABLE_ON_NULL = store_thm ("INTEGRABLE_ON_NULL", 2803 ``!f a b. (content(interval[a,b]) = &0) 2804 ==> f integrable_on interval[a,b]``, 2805 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_NULL]); 2806 2807val HAS_INTEGRAL_EMPTY = store_thm ("HAS_INTEGRAL_EMPTY", 2808 ``!f. (f has_integral 0) {}``, 2809 METIS_TAC[HAS_INTEGRAL_NULL, CONTENT_EMPTY, EMPTY_AS_INTERVAL]); 2810 2811val HAS_INTEGRAL_EMPTY_EQ = store_thm ("HAS_INTEGRAL_EMPTY_EQ", 2812 ``!f i. (f has_integral i) {} <=> (i = 0)``, 2813 MESON_TAC[HAS_INTEGRAL_UNIQUE, HAS_INTEGRAL_EMPTY]); 2814 2815val INTEGRABLE_ON_EMPTY = store_thm ("INTEGRABLE_ON_EMPTY", 2816 ``!f. f integrable_on {}``, 2817 REWRITE_TAC[integrable_on] THEN MESON_TAC[HAS_INTEGRAL_EMPTY]); 2818 2819val INTEGRAL_EMPTY = store_thm ("INTEGRAL_EMPTY", 2820 ``!f. integral {} f = 0``, 2821 MESON_TAC[EMPTY_AS_INTERVAL, INTEGRAL_UNIQUE, HAS_INTEGRAL_EMPTY]); 2822 2823val HAS_INTEGRAL_REFL = store_thm ("HAS_INTEGRAL_REFL", 2824 ``!f a. (f has_integral 0) (interval[a,a])``, 2825 REPEAT GEN_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_NULL THEN 2826 SIMP_TAC std_ss [INTERVAL_SING, INTERIOR_CLOSED_INTERVAL, CONTENT_EQ_0_INTERIOR]); 2827 2828val INTEGRABLE_ON_REFL = store_thm ("INTEGRABLE_ON_REFL", 2829 ``!f a. f integrable_on interval[a,a]``, 2830 REWRITE_TAC[integrable_on] THEN MESON_TAC[HAS_INTEGRAL_REFL]); 2831 2832val INTEGRAL_REFL = store_thm ("INTEGRAL_REFL", 2833 ``!f a. integral (interval[a,a]) f = 0``, 2834 MESON_TAC[INTEGRAL_UNIQUE, HAS_INTEGRAL_REFL]); 2835 2836(* ------------------------------------------------------------------------- *) 2837(* Cauchy-type criterion for integrability. *) 2838(* ------------------------------------------------------------------------- *) 2839 2840val INTEGRABLE_CAUCHY = store_thm ("INTEGRABLE_CAUCHY", 2841 ``!f:real->real a b. 2842 f integrable_on interval[a,b] <=> 2843 !e. &0 < e ==> ?d. gauge d /\ 2844 !p1 p2. p1 tagged_division_of interval[a,b] /\ d FINE p1 /\ 2845 p2 tagged_division_of interval[a,b] /\ d FINE p2 2846 ==> abs (sum p1 (\(x,k). content k * f x) - 2847 sum p2 (\(x,k). content k * f x)) < e``, 2848 REPEAT GEN_TAC THEN REWRITE_TAC[integrable_on, has_integral] THEN 2849 EQ_TAC THEN DISCH_TAC THENL 2850 [X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 2851 FIRST_X_ASSUM(X_CHOOSE_THEN ``y:real`` (MP_TAC o SPEC ``e / &2:real``)) THEN 2852 ASM_REWRITE_TAC[REAL_HALF] THEN 2853 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 2854 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 2855 REWRITE_TAC[GSYM dist] THEN MESON_TAC[DIST_TRIANGLE_HALF_L], 2856 ALL_TAC] THEN 2857 FIRST_X_ASSUM(MP_TAC o GEN ``n:num`` o SPEC ``inv(&n + &1:real)``) THEN 2858 SIMP_TAC std_ss [REAL_LT_INV_EQ, METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] 2859 ``&0 < &n + &1:real``, SKOLEM_THM] THEN 2860 DISCH_THEN(X_CHOOSE_THEN ``d:num->real->real->bool`` MP_TAC) THEN 2861 SIMP_TAC std_ss [FORALL_AND_THM] THEN STRIP_TAC THEN 2862 MP_TAC(GEN ``n:num`` 2863 (ISPECL [``\x. BIGINTER {(d:num->real->real->bool) i x | i IN 0:num..n}``, 2864 ``a:real``, ``b:real``] FINE_DIVISION_EXISTS)) THEN 2865 ASM_SIMP_TAC std_ss [GAUGE_BIGINTER, FINE_BIGINTER, FINITE_NUMSEG, SKOLEM_THM] THEN 2866 SIMP_TAC std_ss [IN_NUMSEG, LE_0, FORALL_AND_THM] THEN 2867 DISCH_THEN(X_CHOOSE_THEN ``p:num->(real#(real->bool))->bool`` 2868 STRIP_ASSUME_TAC) THEN 2869 SUBGOAL_THEN 2870 ``cauchy (\n. sum (p n) 2871 (\(x,k:real->bool). content k * (f:real->real) x))`` 2872 MP_TAC THENL 2873 [REWRITE_TAC[cauchy] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 2874 POP_ASSUM MP_TAC THEN GEN_REWR_TAC LAND_CONV [REAL_ARCH_INV] THEN 2875 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 2876 POP_ASSUM MP_TAC THEN STRIP_TAC THEN 2877 KNOW_TAC ``!m n. (\m n. 2878 m >= (N :num) /\ n >= N ==> 2879 (dist 2880 ((\(n :num). 2881 sum ((p :num -> real # (real -> bool) -> bool) n) 2882 (\((x :real),(k :real -> bool)). 2883 content k * (f :real -> real) x)) m, 2884 (\(n :num). 2885 sum (p n) (\((x :real),(k :real -> bool)). content k * f x)) 2886 n) :real) < (e :real)) m n`` THENL 2887 [ALL_TAC, SIMP_TAC std_ss []] THEN MATCH_MP_TAC WLOG_LE THEN CONJ_TAC THENL 2888 [MESON_TAC[DIST_SYM], ALL_TAC] THEN 2889 MAP_EVERY X_GEN_TAC [``m:num``, ``n:num``] THEN REWRITE_TAC[GE] THEN 2890 SIMP_TAC std_ss [] THEN REPEAT STRIP_TAC THEN 2891 MATCH_MP_TAC REAL_LTE_TRANS THEN EXISTS_TAC ``inv(&m + &1:real)`` THEN 2892 CONJ_TAC THENL 2893 [REWRITE_TAC[dist] THEN ASM_MESON_TAC[LESS_EQ_REFL], ALL_TAC] THEN 2894 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``inv(&N:real)`` THEN 2895 ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE] THEN MATCH_MP_TAC REAL_LE_INV2 THEN 2896 ASM_SIMP_TAC arith_ss [REAL_OF_NUM_ADD, REAL_OF_NUM_LE, REAL_LT], 2897 ALL_TAC] THEN 2898 REWRITE_TAC[GSYM CONVERGENT_EQ_CAUCHY, LIM_SEQUENTIALLY] THEN 2899 DISCH_THEN (X_CHOOSE_TAC ``y:real``) THEN EXISTS_TAC ``y:real`` THEN 2900 POP_ASSUM MP_TAC THEN REWRITE_TAC[dist] THEN STRIP_TAC THEN 2901 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 2902 MP_TAC(SPEC ``e / &2:real`` REAL_ARCH_INV) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 2903 DISCH_THEN(X_CHOOSE_THEN ``N1:num`` STRIP_ASSUME_TAC) THEN 2904 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 2905 DISCH_THEN(X_CHOOSE_TAC ``N2:num``) THEN EXISTS_TAC 2906 ``(d:num->real->real->bool) (N1 + N2)`` THEN 2907 ASM_REWRITE_TAC[] THEN 2908 X_GEN_TAC ``q:(real#(real->bool))->bool`` THEN STRIP_TAC THEN 2909 REWRITE_TAC[GSYM dist] THEN MATCH_MP_TAC DIST_TRIANGLE_HALF_L THEN 2910 EXISTS_TAC ``sum (p(N1+N2:num)) 2911 (\(x,k:real->bool). content k * (f:real->real) x)`` THEN 2912 CONJ_TAC THENL 2913 [REWRITE_TAC[dist] THEN MATCH_MP_TAC REAL_LTE_TRANS THEN 2914 EXISTS_TAC ``inv(&(N1 + N2) + &1:real)`` THEN CONJ_TAC THENL 2915 [FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_MESON_TAC[LESS_EQ_REFL], ALL_TAC] THEN 2916 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``inv(&N1:real)`` THEN 2917 ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE] THEN MATCH_MP_TAC REAL_LE_INV2 THEN 2918 ASM_SIMP_TAC arith_ss [REAL_OF_NUM_ADD, REAL_OF_NUM_LE, REAL_LT], 2919 ONCE_REWRITE_TAC[DIST_SYM] THEN REWRITE_TAC[dist] THEN 2920 FULL_SIMP_TAC std_ss []]); 2921 2922(* ------------------------------------------------------------------------- *) 2923(* Additivity of integral on abutting intervals. *) 2924(* ------------------------------------------------------------------------- *) 2925 2926val INTERVAL_SPLIT = store_thm ("INTERVAL_SPLIT", 2927 ``!a b:real c. (interval[a,b] INTER {x | x <= c} = interval[a,min b c]) /\ 2928 (interval[a,b] INTER {x | x >= c} = interval[max a c,b])``, 2929 REPEAT STRIP_TAC THEN 2930 SIMP_TAC std_ss [EXTENSION, IN_INTERVAL, IN_INTER, GSPECIFICATION] THEN 2931 X_GEN_TAC ``y:real`` THEN 2932 MATCH_MP_TAC(TAUT `(c ==> b) /\ (c ==> a) /\ (a /\ b ==> c) 2933 ==> (a /\ b <=> c)`) THEN 2934 (CONJ_TAC THENL 2935 [ASM_MESON_TAC[REAL_MAX_LE, REAL_LE_MIN, real_ge], ALL_TAC]) THEN 2936 SIMP_TAC std_ss [LEFT_AND_FORALL_THM, real_ge] THEN CONJ_TAC THEN 2937 ASM_MESON_TAC[REAL_MAX_LE, REAL_LE_MIN]); 2938 2939Theorem CONTENT_SPLIT : 2940 !a b:real k. (content(interval[a,b]) = 2941 content(interval[a,b] INTER {x | x <= c}) + 2942 content(interval[a,b] INTER {x | x >= c})) 2943Proof 2944 rpt GEN_TAC 2945 >> SIMP_TAC std_ss [INTERVAL_SPLIT, CONTENT_CLOSED_INTERVAL_CASES, 2946 min_def, max_def] 2947 >> rpt COND_CASES_TAC 2948 >> TRY (fs [] >> rfs [] >> rpt (POP_ASSUM MP_TAC) >> REAL_ARITH_TAC) 2949 >> (Cases_on `b <= c` >> fs [] >> rfs []) 2950QED 2951 2952val lemma = Q.prove ( 2953 `!a b:real c. 2954 ((content(interval[a,b] INTER {x | x <= c}) = &0) <=> 2955 (interior(interval[a,b] INTER {x | x <= c}) = {})) /\ 2956 ((content(interval[a,b] INTER {x | x >= c}) = &0) <=> 2957 (interior(interval[a,b] INTER {x | x >= c}) = {}))`, 2958 SIMP_TAC std_ss [INTERVAL_SPLIT, CONTENT_EQ_0_INTERIOR]); 2959 2960val DIVISION_SPLIT_LEFT_RIGHT_INJ = store_thm ("DIVISION_SPLIT_LEFT_RIGHT_INJ", 2961 ``(!d i k1 k2 k c. 2962 d division_of i /\ 2963 k1 IN d /\ k2 IN d /\ ~(k1 = k2) /\ 2964 (k1 INTER {x | x <= c} = k2 INTER {x | x <= c}) 2965 ==> (content(k1 INTER {x:real | x <= c}) = &0)) /\ 2966 (!d i k1 k2 k c. 2967 d division_of i /\ 2968 k1 IN d /\ k2 IN d /\ ~(k1 = k2) /\ 2969 (k1 INTER {x | x >= c} = k2 INTER {x | x >= c}) 2970 ==> (content(k1 INTER {x:real | x >= c}) = &0))``, 2971 REPEAT STRIP_TAC THEN 2972 REWRITE_TAC[CONTENT_EQ_0_INTERIOR] THEN 2973 UNDISCH_TAC ``d division_of i`` THEN GEN_REWR_TAC LAND_CONV [division_of] THEN 2974 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC (MP_TAC o CONJUNCT1) o CONJUNCT2) THEN 2975 DISCH_THEN(MP_TAC o SPECL 2976 [``k1:real->bool``, ``k2:real->bool``]) THEN 2977 ASM_REWRITE_TAC[PAIR_EQ] THEN DISCH_TAC THEN 2978 DISCH_THEN(MP_TAC o SPEC ``k2:real->bool``) THEN 2979 ASM_REWRITE_TAC[] THEN 2980 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 2981 DISCH_THEN(X_CHOOSE_THEN ``u:real`` (X_CHOOSE_THEN ``v:real`` 2982 SUBST_ALL_TAC)) THEN 2983 ASM_SIMP_TAC std_ss [lemma] THEN 2984 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (SET_RULE 2985 ``(s INTER t = {}) 2986 ==> u SUBSET s /\ u SUBSET t ==> (u = {})``)) THEN 2987 CONJ_TAC THEN MATCH_MP_TAC SUBSET_INTERIOR THEN ASM_SET_TAC[]); 2988 2989val DIVISION_SPLIT_LEFT_INJ = store_thm ("DIVISION_SPLIT_LEFT_INJ", 2990 ``(!d i k1 k2 k c. 2991 d division_of i /\ 2992 k1 IN d /\ k2 IN d /\ ~(k1 = k2) /\ 2993 (k1 INTER {x | x <= c} = k2 INTER {x | x <= c}) 2994 ==> (content(k1 INTER {x:real | x <= c}) = &0))``, 2995 REWRITE_TAC [DIVISION_SPLIT_LEFT_RIGHT_INJ]); 2996 2997val DIVISION_SPLIT_RIGHT_INJ = store_thm ("DIVISION_SPLIT_RIGHT_INJ", 2998 ``(!d i k1 k2 k c. 2999 d division_of i /\ 3000 k1 IN d /\ k2 IN d /\ ~(k1 = k2) /\ 3001 (k1 INTER {x | x >= c} = k2 INTER {x | x >= c}) 3002 ==> (content(k1 INTER {x:real | x >= c}) = &0))``, 3003 REWRITE_TAC [DIVISION_SPLIT_LEFT_RIGHT_INJ]); 3004 3005val TAGGED_DIVISION_SPLIT_LEFT_INJ = store_thm ("TAGGED_DIVISION_SPLIT_LEFT_INJ", 3006 ``!d i x1 k1 x2 k2 c. 3007 d tagged_division_of i /\ 3008 (x1,k1) IN d /\ (x2,k2) IN d /\ ~(k1 = k2) /\ 3009 (k1 INTER {x | x <= c} = k2 INTER {x | x <= c}) 3010 ==> (content(k1 INTER {x:real | x <= c}) = &0)``, 3011 REPEAT STRIP_TAC THEN 3012 FIRST_X_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_TAGGED_DIVISION) THEN 3013 MATCH_MP_TAC DIVISION_SPLIT_LEFT_INJ THEN 3014 EXISTS_TAC ``IMAGE SND (d:(real#(real->bool))->bool)`` THEN 3015 ASM_REWRITE_TAC[IN_IMAGE] THEN ASM_MESON_TAC[SND]); 3016 3017val TAGGED_DIVISION_SPLIT_RIGHT_INJ = store_thm ("TAGGED_DIVISION_SPLIT_RIGHT_INJ", 3018 ``!d i x1 k1 x2 k2 c. 3019 d tagged_division_of i /\ 3020 (x1,k1) IN d /\ (x2,k2) IN d /\ ~(k1 = k2) /\ 3021 (k1 INTER {x | x >= c} = k2 INTER {x | x >= c}) 3022 ==> (content(k1 INTER {x:real | x >= c}) = &0)``, 3023 REPEAT STRIP_TAC THEN 3024 FIRST_X_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_TAGGED_DIVISION) THEN 3025 MATCH_MP_TAC DIVISION_SPLIT_RIGHT_INJ THEN 3026 EXISTS_TAC ``IMAGE SND (d:(real#(real->bool))->bool)`` THEN 3027 ASM_REWRITE_TAC[IN_IMAGE] THEN ASM_MESON_TAC[SND]); 3028 3029val DIVISION_SPLIT = store_thm ("DIVISION_SPLIT", 3030 ``!p a b:real c. 3031 p division_of interval[a,b] 3032 ==> {l INTER {x | x <= c} |l| l IN p /\ ~(l INTER {x | x <= c} = {})} 3033 division_of (interval[a,b] INTER {x | x <= c}) /\ 3034 {l INTER {x | x >= c} |l| l IN p /\ ~(l INTER {x | x >= c} = {})} 3035 division_of (interval[a,b] INTER {x | x >= c})``, 3036 REPEAT GEN_TAC THEN 3037 SIMP_TAC std_ss [division_of, IMAGE_FINITE] THEN 3038 SIMP_TAC std_ss [SET_RULE ``(!x. x IN {f x | P x} ==> Q x) <=> (!x. P x ==> Q (f x))``, 3039 MESON[] ``(!x y. x IN s /\ y IN t /\ Q x y ==> P x y) <=> 3040 (!x. x IN s ==> !y. y IN t ==> Q x y ==> P x y)``, 3041 RIGHT_FORALL_IMP_THM] THEN 3042 REPEAT(MATCH_MP_TAC(TAUT 3043 `(a ==> a' /\ a'') /\ (b ==> b' /\ b'') 3044 ==> a /\ b ==> (a' /\ b') /\ (a'' /\ b'')`) THEN CONJ_TAC) THENL 3045 [KNOW_TAC ``FINITE p 3046 ==> FINITE {y | y IN IMAGE (\l. l INTER {x | x <= c:real}) p /\ ~(y = {})} /\ 3047 FINITE {y | y IN IMAGE (\l. l INTER {x | x >= c:real}) p /\ ~(y = {})}`` THENL 3048 [ALL_TAC, METIS_TAC [SET_RULE 3049 ``{f x |x| x IN s /\ ~(f x = {})} = {y | y IN IMAGE f s /\ ~(y = {})}``]] THEN 3050 SIMP_TAC std_ss [FINITE_RESTRICT, IMAGE_FINITE], 3051 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN 3052 DISCH_TAC THEN STRIP_TAC THEN POP_ASSUM (MP_TAC o Q.SPEC `l:real->bool`) THEN 3053 DISCH_THEN(fn th => CONJ_TAC THEN STRIP_TAC THEN MP_TAC th) THEN 3054 (ASM_REWRITE_TAC[] THEN MATCH_MP_TAC MONO_AND THEN 3055 CONJ_TAC THENL [SET_TAC[], ALL_TAC] THEN 3056 STRIP_TAC THEN METIS_TAC[INTERVAL_SPLIT]), 3057 DISCH_THEN(fn th => CONJ_TAC THEN MP_TAC th) THEN 3058 (DISCH_TAC THEN X_GEN_TAC ``K1:real->bool`` THEN 3059 POP_ASSUM (MP_TAC o Q.SPEC `K1:real->bool`) THEN 3060 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THEN 3061 DISCH_TAC THEN X_GEN_TAC ``K2:real->bool`` THEN 3062 POP_ASSUM (MP_TAC o Q.SPEC `K2:real->bool`) THEN 3063 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THEN 3064 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THEN 3065 KNOW_TAC ``(K1 <> K2:real->bool)`` THENL [ASM_MESON_TAC[PAIR_EQ], 3066 DISCH_TAC THEN ASM_REWRITE_TAC []] THEN 3067 MATCH_MP_TAC(SET_RULE 3068 ``s SUBSET s' /\ t SUBSET t' 3069 ==> (s' INTER t' = {}) ==> (s INTER t = {})``) THEN 3070 CONJ_TAC THEN MATCH_MP_TAC SUBSET_INTERIOR THEN SET_TAC[]), 3071 DISCH_THEN(SUBST1_TAC o SYM) THEN REWRITE_TAC[INTER_BIGUNION] THEN 3072 ONCE_REWRITE_TAC[EXTENSION] THEN REWRITE_TAC[IN_BIGUNION] THEN 3073 CONJ_TAC THEN GEN_TAC THEN AP_TERM_TAC THEN 3074 GEN_REWR_TAC I [FUN_EQ_THM] THEN GEN_TAC THEN 3075 SIMP_TAC std_ss [GSPECIFICATION, PAIR_EQ] THEN MESON_TAC[NOT_IN_EMPTY]]); 3076 3077val lemma1 = Q.prove ( 3078 `(!x k. (x,k) IN {x,f k | P x k} ==> Q x k) <=> 3079 (!x k. P x k ==> Q x (f k))`, 3080 SIMP_TAC std_ss [GSPECIFICATION, PAIR_EQ, EXISTS_PROD] THEN SET_TAC[]); 3081 3082val lemma2 = Q.prove ( 3083 `!f:'b->'b s:('a#'b)->bool. 3084 FINITE s ==> FINITE {x,f k | (x,k) IN s /\ P x k}`, 3085 REPEAT STRIP_TAC THEN MATCH_MP_TAC FINITE_SUBSET THEN 3086 EXISTS_TAC ``IMAGE (\(x:'a,k:'b). x,(f k:'b)) s`` THEN 3087 ASM_SIMP_TAC std_ss [IMAGE_FINITE] THEN 3088 SIMP_TAC std_ss [SUBSET_DEF, FORALL_PROD, lemma1, IN_IMAGE] THEN 3089 SIMP_TAC std_ss [EXISTS_PROD, PAIR_EQ] THEN MESON_TAC[]); 3090 3091val lemma3 = Q.prove ( 3092 `!f:real->real g:(real->bool)->(real->bool) p. 3093 FINITE p 3094 ==> (sum {x,g k |x,k| (x,k) IN p /\ ~(g k = {})} (\(x,k). content k * f x) = 3095 sum (IMAGE (\(x,k). x,g k) p) (\(x,k). content k * f x))`, 3096 REPEAT STRIP_TAC THEN CONV_TAC SYM_CONV THEN MATCH_MP_TAC SUM_SUPERSET THEN 3097 ASM_SIMP_TAC std_ss [IMAGE_FINITE, lemma2] THEN 3098 SIMP_TAC std_ss [IMP_CONJ, FORALL_IN_IMAGE] THEN 3099 SIMP_TAC std_ss [FORALL_PROD, SUBSET_DEF, IN_IMAGE, EXISTS_PROD] THEN 3100 SIMP_TAC std_ss [GSPECIFICATION, PAIR_EQ, REAL_ENTIRE, EXISTS_PROD] THEN 3101 METIS_TAC[CONTENT_EMPTY]); 3102 3103val lemma4 = Q.prove ( 3104 `(\(x,l). content (g l) * f x) = 3105 (\(x,l). content l * f x) o (\(x,l). x,g l)`, 3106 SIMP_TAC std_ss [FUN_EQ_THM, o_THM, FORALL_PROD]); 3107 3108val HAS_INTEGRAL_SPLIT = store_thm ("HAS_INTEGRAL_SPLIT", 3109 ``!f:real->real a b c. 3110 (f has_integral i) (interval[a,b] INTER {x | x <= c}) /\ 3111 (f has_integral j) (interval[a,b] INTER {x | x >= c}) 3112 ==> (f has_integral (i + j)) (interval[a,b])``, 3113 REPEAT GEN_TAC THEN 3114 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN REWRITE_TAC[has_integral] THEN 3115 ASM_SIMP_TAC std_ss [GSYM INTERVAL_SPLIT] THEN 3116 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN STRIP_TAC THEN 3117 FIRST_X_ASSUM(CONJUNCTS_THEN2 (MP_TAC o SPEC ``e / &2:real``) STRIP_ASSUME_TAC) THEN 3118 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 3119 DISCH_THEN(X_CHOOSE_THEN ``d2:real->real->bool`` 3120 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 3121 DISCH_THEN(X_CHOOSE_THEN ``d1:real->real->bool`` 3122 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 3123 EXISTS_TAC ``\x. if x = c then (d1(x:real) INTER d2(x)):real->bool 3124 else ball(x,abs(x - c)) INTER d1(x) INTER d2(x)`` THEN 3125 CONJ_TAC THENL 3126 [REWRITE_TAC[gauge_def] THEN GEN_TAC THEN 3127 RULE_ASSUM_TAC(REWRITE_RULE[gauge_def]) THEN BETA_TAC THEN COND_CASES_TAC THEN 3128 ASM_SIMP_TAC std_ss [OPEN_INTER, IN_INTER, OPEN_BALL, IN_BALL] THEN 3129 ASM_REWRITE_TAC[DIST_REFL, GSYM ABS_NZ, REAL_SUB_0], ALL_TAC] THEN 3130 X_GEN_TAC ``p:(real#(real->bool))->bool`` THEN STRIP_TAC THEN 3131 SUBGOAL_THEN 3132 ``(!x:real kk. (x,kk) IN p /\ ~(kk INTER {x:real | x <= c} = {}) 3133 ==> x <= c) /\ 3134 (!x:real kk. (x,kk) IN p /\ ~(kk INTER {x:real | x >= c} = {}) 3135 ==> x >= c)`` 3136 STRIP_ASSUME_TAC THENL 3137 [CONJ_TAC THEN FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 3138 DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 3139 POP_ASSUM (MP_TAC o Q.SPECL [`x:real`, `kk:real->bool`]) THEN 3140 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THEN 3141 COND_CASES_TAC THEN ASM_REWRITE_TAC[REAL_LE_REFL, real_ge] THEN DISCH_THEN 3142 (MP_TAC o MATCH_MP (SET_RULE ``k SUBSET (a INTER b) ==> k SUBSET a``)) THEN 3143 DISCH_THEN 3144 (MP_TAC o MATCH_MP (SET_RULE ``k SUBSET (a INTER b) ==> k SUBSET a``)) THEN 3145 SIMP_TAC std_ss [SUBSET_DEF, IN_BALL, dist] THEN DISCH_TAC THENL 3146 [UNDISCH_TAC ``kk INTER {x:real | x <= c} <> {}``, 3147 UNDISCH_TAC ``kk INTER {x:real | x >= c} <> {}``] THEN DISCH_TAC THEN 3148 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [GSYM MEMBER_NOT_EMPTY]) THEN 3149 DISCH_THEN(X_CHOOSE_THEN ``u:real`` MP_TAC) THEN 3150 SIMP_TAC std_ss [IN_INTER, GSPECIFICATION] THEN REPEAT STRIP_TAC THEN 3151 FIRST_X_ASSUM(MP_TAC o SPEC ``u:real``) THEN ASM_REWRITE_TAC[] THEN 3152 ONCE_REWRITE_TAC[MONO_NOT_EQ] THEN 3153 REWRITE_TAC[REAL_NOT_LE, REAL_NOT_LT] THEN STRIP_TAC THEN 3154 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``abs(x - u:real)`` THEN 3155 ASM_SIMP_TAC std_ss [REAL_LE_REFL] THEN REWRITE_TAC [abs] THEN 3156 REPEAT COND_CASES_TAC THENL 3157 [ASM_REWRITE_TAC [real_sub, REAL_LE_LADD, REAL_LE_NEG], 3158 FULL_SIMP_TAC std_ss [REAL_SUB_LE] THEN 3159 FULL_SIMP_TAC std_ss [REAL_NOT_LE] THEN CCONTR_TAC THEN 3160 UNDISCH_TAC ``x < u:real`` THEN REWRITE_TAC [REAL_NOT_LT] THEN 3161 MATCH_MP_TAC REAL_LE_TRANS THEN 3162 EXISTS_TAC ``c:real`` THEN ASM_REWRITE_TAC [REAL_LE_LT], 3163 FULL_SIMP_TAC std_ss [REAL_SUB_LE] THEN 3164 FULL_SIMP_TAC std_ss [REAL_NOT_LE] THEN METIS_TAC [REAL_LT_ANTISYM], 3165 FULL_SIMP_TAC std_ss [REAL_SUB_LE] THEN 3166 FULL_SIMP_TAC std_ss [REAL_NOT_LE] THEN METIS_TAC [REAL_LT_ANTISYM], 3167 FULL_SIMP_TAC std_ss [REAL_SUB_LE] THEN 3168 FULL_SIMP_TAC std_ss [REAL_NOT_LE] THEN METIS_TAC [REAL_LET_ANTISYM], 3169 FULL_SIMP_TAC std_ss [REAL_SUB_LE] THEN 3170 FULL_SIMP_TAC std_ss [REAL_NOT_LE] THEN METIS_TAC [REAL_LET_ANTISYM], 3171 FULL_SIMP_TAC std_ss [REAL_SUB_LE, real_ge] THEN CCONTR_TAC THEN 3172 UNDISCH_TAC ``x < c:real`` THEN REWRITE_TAC [REAL_NOT_LT] THEN 3173 MATCH_MP_TAC REAL_LE_TRANS THEN 3174 EXISTS_TAC ``u:real`` THEN ASM_REWRITE_TAC [REAL_LE_LT], 3175 ASM_REWRITE_TAC [REAL_LE_NEG, real_sub, REAL_LE_LADD] THEN 3176 ASM_REWRITE_TAC [GSYM real_ge]], ALL_TAC] THEN 3177 UNDISCH_TAC ``!p. 3178 p tagged_division_of interval [(a,b)] INTER {x | x >= c} /\ 3179 d2 FINE p ==> 3180 abs (sum p (\(x,k). content k * f x) - j) < e / 2:real`` THEN 3181 DISCH_TAC THEN POP_ASSUM (MP_TAC o SPEC 3182 ``{(x:real,kk INTER {x:real | x >= c}) |(x,kk)| 3183 (x,kk) IN p /\ ~(kk INTER {x:real | x >= c} = {})}``) THEN 3184 UNDISCH_TAC ``!p. 3185 p tagged_division_of interval [(a,b)] INTER {x | x <= c} /\ 3186 d1 FINE p ==> 3187 abs (sum p (\(x,k). content k * f x) - i) < e / 2:real`` THEN 3188 DISCH_TAC THEN POP_ASSUM (MP_TAC o SPEC 3189 ``{(x:real,kk INTER {x:real | x <= c}) |(x,kk)| 3190 (x,kk) IN p /\ ~(kk INTER {x:real | x <= c} = {})}``) THEN 3191 MATCH_MP_TAC(TAUT 3192 `(a /\ b) /\ (a' /\ b' ==> c) ==> (a ==> a') ==> (b ==> b') ==> c`) THEN 3193 CONJ_TAC THENL 3194 [UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 3195 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 3196 REWRITE_TAC[TAGGED_DIVISION_OF] THEN 3197 REPEAT(MATCH_MP_TAC(TAUT 3198 `(a ==> (a' /\ a'')) /\ (b ==> (b' /\ d) /\ (b'' /\ e)) 3199 ==> a /\ b ==> ((a' /\ b') /\ d) /\ ((a'' /\ b'') /\ e)`) THEN 3200 CONJ_TAC) THEN 3201 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 3202 SIMP_TAC std_ss [lemma1] THEN REWRITE_TAC[AND_IMP_INTRO] THENL 3203 [SIMP_TAC std_ss [lemma2], 3204 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN 3205 DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 3206 POP_ASSUM (MP_TAC o Q.SPECL [`x:real`, `kk:real->bool`]) THEN 3207 DISCH_THEN(fn th => CONJ_TAC THEN STRIP_TAC THEN MP_TAC th) THEN 3208 (ASM_REWRITE_TAC[] THEN MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 3209 [SIMP_TAC std_ss [IN_INTER, GSPECIFICATION] THEN METIS_TAC[], ALL_TAC]) THEN 3210 (MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL [SET_TAC[], ALL_TAC]) THEN 3211 METIS_TAC[INTERVAL_SPLIT], 3212 DISCH_THEN(fn th => CONJ_TAC THEN MP_TAC th) THEN 3213 (REPEAT (DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 3214 POP_ASSUM (MP_TAC o Q.SPECL [`x1:real`, `kk:real->bool`])) THEN 3215 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THEN 3216 REPEAT (DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 3217 POP_ASSUM (MP_TAC o Q.SPECL [`x2:real`, `kk':real->bool`])) THEN 3218 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss []) THENL 3219 [ALL_TAC, KNOW_TAC ``kk <> kk':real->bool`` THENL 3220 [CCONTR_TAC THEN UNDISCH_TAC ``kk:real->bool INTER {x | x <= c} <> kk' INTER {x | x <= c}`` THEN 3221 REWRITE_TAC [] THEN AP_THM_TAC THEN AP_TERM_TAC THEN FULL_SIMP_TAC std_ss [], 3222 DISCH_TAC THEN ASM_REWRITE_TAC []], 3223 ALL_TAC, KNOW_TAC ``kk <> kk':real->bool`` THENL 3224 [CCONTR_TAC THEN UNDISCH_TAC ``kk:real->bool INTER {x | x >= c} <> kk' INTER {x | x >= c}`` THEN 3225 REWRITE_TAC [] THEN AP_THM_TAC THEN AP_TERM_TAC THEN FULL_SIMP_TAC std_ss [], 3226 DISCH_TAC THEN ASM_REWRITE_TAC []]] THEN 3227 MATCH_MP_TAC(SET_RULE 3228 ``s SUBSET s' /\ t SUBSET t' 3229 ==> (s' INTER t' = {}) ==> (s INTER t = {})``) THEN 3230 CONJ_TAC THEN MATCH_MP_TAC SUBSET_INTERIOR THEN SET_TAC[], 3231 MATCH_MP_TAC(TAUT `(a ==> b /\ c) /\ d /\ e 3232 ==> (a ==> (b /\ d) /\ (c /\ e))`) THEN 3233 CONJ_TAC THENL 3234 [DISCH_THEN(fn th => CONJ_TAC THEN MP_TAC th) THEN 3235 DISCH_THEN(SUBST1_TAC o SYM) THEN REWRITE_TAC[INTER_BIGUNION] THEN 3236 ONCE_REWRITE_TAC[EXTENSION] THEN REWRITE_TAC[IN_BIGUNION] THEN 3237 X_GEN_TAC ``x:real`` THEN AP_TERM_TAC THEN 3238 GEN_REWR_TAC I [FUN_EQ_THM] THEN X_GEN_TAC ``kk:real->bool`` THEN 3239 SIMP_TAC std_ss [GSPECIFICATION, PAIR_EQ, EXISTS_PROD] THEN MESON_TAC[NOT_IN_EMPTY], 3240 ALL_TAC] THEN 3241 UNDISCH_TAC `` (\x. if x = c then d1 x INTER d2 x 3242 else ball (x,abs (x - c)) INTER d1 x INTER d2 x) FINE p`` THEN 3243 DISCH_TAC THEN 3244 CONJ_TAC THEN FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 3245 SIMP_TAC std_ss [FINE, lemma1] THEN 3246 REPEAT (DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 3247 POP_ASSUM (MP_TAC o Q.SPECL [`x:real`, `kk:real->bool`])) THEN 3248 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 3249 ASM_SIMP_TAC std_ss [] THEN SET_TAC[]], ALL_TAC] THEN 3250 DISCH_THEN(MP_TAC o MATCH_MP (METIS [REAL_HALF, REAL_LT_ADD2] 3251 ``x < e / &2 /\ y < e / &2 ==> x + y < e:real``)) THEN 3252 DISCH_THEN(MP_TAC o MATCH_MP ABS_TRIANGLE_LT) THEN 3253 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN 3254 REWRITE_TAC[REAL_ARITH 3255 ``((a - i) + (b - j) = c - (i + j)) <=> (a + b = c:real)``] THEN 3256 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 3257 MATCH_MP_TAC EQ_TRANS THEN 3258 EXISTS_TAC 3259 ``sum p (\(x,l). content (l INTER {x:real | x <= c}) * 3260 (f:real->real) x) + 3261 sum p (\(x,l). content (l INTER {x:real | x >= c}) * 3262 (f:real->real) x)`` THEN CONJ_TAC THENL 3263 [ALL_TAC, 3264 ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN MATCH_MP_TAC SUM_EQ THEN 3265 SIMP_TAC std_ss [FORALL_PROD, GSYM REAL_ADD_RDISTRIB] THEN 3266 MAP_EVERY X_GEN_TAC [``x:real``, ``l:real->bool``] THEN 3267 DISCH_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN 3268 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 3269 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 3270 ASM_REWRITE_TAC [] THEN STRIP_TAC THEN UNDISCH_TAC 3271 ``!x k. (x,k) IN p ==> 3272 x IN k /\ k SUBSET interval [(a,b)] /\ 3273 ?a b. k = interval [(a,b)]`` THEN DISCH_TAC THEN 3274 POP_ASSUM (MP_TAC o Q.SPECL [`x:real`, `l:real->bool`]) THEN 3275 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN 3276 ASM_SIMP_TAC std_ss [GSYM CONTENT_SPLIT]] THEN 3277 ASM_SIMP_TAC std_ss [lemma3] THEN BINOP_TAC THEN 3278 (ONCE_REWRITE_TAC [METIS [] ``!x:real l:real->bool. 3279 ((l INTER {x | x <= c}) = (\l. l INTER {x | x <= c}) l) /\ 3280 ((l INTER {x | x >= c}) = (\l. l INTER {x | x >= c}) l)``] THEN 3281 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [lemma4] THEN 3282 MATCH_MP_TAC SUM_IMAGE_NONZERO THEN ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 3283 REWRITE_TAC[PAIR_EQ] THEN 3284 METIS_TAC [TAGGED_DIVISION_SPLIT_LEFT_INJ, REAL_MUL_LZERO, 3285 TAGGED_DIVISION_SPLIT_RIGHT_INJ])); 3286 3287(* ------------------------------------------------------------------------- *) 3288(* A sort of converse, integrability on subintervals. *) 3289(* ------------------------------------------------------------------------- *) 3290 3291val TAGGED_DIVISION_UNION_INTERVAL = store_thm ("TAGGED_DIVISION_UNION_INTERVAL", 3292 ``!a b:real p1 p2 c. 3293 p1 tagged_division_of (interval[a,b] INTER {x | x <= c}) /\ 3294 p2 tagged_division_of (interval[a,b] INTER {x | x >= c}) 3295 ==> (p1 UNION p2) tagged_division_of (interval[a,b])``, 3296 REPEAT STRIP_TAC THEN SUBGOAL_THEN 3297 ``(interval[a,b] = (interval[a,b] INTER {x:real | x <= c}) UNION 3298 (interval[a,b] INTER {x:real | x >= c}))`` 3299 SUBST1_TAC THENL 3300 [MATCH_MP_TAC(SET_RULE 3301 ``(t UNION u = UNIV) ==> (s = (s INTER t) UNION (s INTER u))``) THEN 3302 SIMP_TAC std_ss [EXTENSION, IN_UNIV, IN_UNION, GSPECIFICATION] THEN 3303 REAL_ARITH_TAC, ALL_TAC] THEN 3304 MATCH_MP_TAC TAGGED_DIVISION_UNION THEN ASM_REWRITE_TAC[] THEN 3305 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, INTERIOR_CLOSED_INTERVAL] THEN 3306 SIMP_TAC std_ss [EXTENSION, IN_INTER, NOT_IN_EMPTY, IN_INTERVAL] THEN 3307 GEN_TAC THEN REWRITE_TAC [GSYM DE_MORGAN_THM] THEN 3308 DISCH_THEN(CONJUNCTS_THEN (MP_TAC)) THEN REWRITE_TAC [min_def, max_def] THEN 3309 REPEAT COND_CASES_TAC THENL 3310 [STRIP_TAC THEN SIMP_TAC std_ss [REAL_NOT_LT] THEN DISJ2_TAC THEN 3311 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``c:real`` THEN 3312 ASM_SIMP_TAC arith_ss [REAL_LE_LT], 3313 SIMP_TAC std_ss [REAL_NOT_LT, REAL_LE_LT], 3314 STRIP_TAC THEN KNOW_TAC ``a < b /\ b < a:real`` THENL [CONJ_TAC THENL 3315 [MATCH_MP_TAC REAL_LT_TRANS THEN EXISTS_TAC ``x:real`` THEN ASM_REWRITE_TAC [], 3316 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC ``c:real`` THEN 3317 FULL_SIMP_TAC std_ss [REAL_NOT_LE]], SIMP_TAC std_ss [REAL_LT_ANTISYM]], 3318 STRIP_TAC THEN FULL_SIMP_TAC std_ss [REAL_NOT_LE, REAL_NOT_LT] THEN 3319 DISJ2_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``a:real`` THEN 3320 ASM_SIMP_TAC std_ss [REAL_LE_LT]]); 3321 3322val HAS_INTEGRAL_SEPARATE_SIDES = store_thm ("HAS_INTEGRAL_SEPARATE_SIDES", 3323 ``!f:real->real i a b. 3324 (f has_integral i) (interval[a,b]) 3325 ==> !e. &0 < e ==> ?d. gauge d /\ 3326 !p1 p2. p1 tagged_division_of 3327 (interval[a,b] INTER {x | x <= c}) /\ d FINE p1 /\ 3328 p2 tagged_division_of 3329 (interval[a,b] INTER {x | x >= c}) /\ d FINE p2 3330 ==> abs ((sum p1 (\(x,k). content k * f x) + 3331 sum p2 (\(x,k). content k * f x)) - i) < e``, 3332 REWRITE_TAC[has_integral] THEN REPEAT GEN_TAC THEN 3333 DISCH_TAC THEN GEN_TAC THEN POP_ASSUM (MP_TAC o Q.SPEC `e:real`) THEN 3334 ASM_CASES_TAC ``&0 < e:real`` THEN ASM_REWRITE_TAC[] THEN 3335 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 3336 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 3337 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN REPEAT STRIP_TAC THEN 3338 SUBGOAL_THEN 3339 ``sum p1 (\(x,k). content k * f x) + sum p2 (\(x,k). content k * f x) = 3340 sum (p1 UNION p2) (\(x,k:real->bool). content k * (f:real->real) x)`` 3341 SUBST1_TAC THENL 3342 [ALL_TAC, METIS_TAC[TAGGED_DIVISION_UNION_INTERVAL, FINE_UNION]] THEN 3343 CONV_TAC SYM_CONV THEN MATCH_MP_TAC SUM_UNION_NONZERO THEN 3344 UNDISCH_TAC ``p2 tagged_division_of interval [(a,b)] INTER {x | x >= c}`` THEN 3345 DISCH_TAC THEN FIRST_X_ASSUM(STRIP_ASSUME_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 3346 UNDISCH_TAC ``p1 tagged_division_of interval [(a,b)] INTER {x | x <= c}`` THEN 3347 DISCH_TAC THEN FIRST_X_ASSUM(STRIP_ASSUME_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 3348 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 3349 MAP_EVERY X_GEN_TAC [``x:real``, ``l:real->bool``] THEN 3350 REWRITE_TAC [IN_INTER, REAL_ENTIRE] THEN STRIP_TAC THEN DISJ1_TAC THEN 3351 SUBGOAL_THEN 3352 ``(?a b:real. l = interval[a,b]) /\ 3353 l SUBSET (interval[a,b] INTER {x | x <= c}) /\ 3354 l SUBSET (interval[a,b] INTER {x | x >= c})`` 3355 MP_TAC THENL [ASM_MESON_TAC[], ALL_TAC] THEN 3356 DISCH_THEN(CONJUNCTS_THEN2 STRIP_ASSUME_TAC MP_TAC) THEN 3357 ASM_REWRITE_TAC[SET_RULE 3358 ``s SUBSET t /\ s SUBSET u <=> s SUBSET (t INTER u)``] THEN 3359 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, INTER_INTERVAL] THEN 3360 DISCH_THEN(MP_TAC o MATCH_MP SUBSET_INTERIOR) THEN 3361 REWRITE_TAC[INTERIOR_CLOSED_INTERVAL, CONTENT_EQ_0_INTERIOR] THEN 3362 MATCH_MP_TAC(SET_RULE ``(t = {}) ==> s SUBSET t ==> (s = {})``) THEN 3363 SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY] THEN 3364 RW_TAC std_ss [REAL_MIN_LE, REAL_LE_MAX] THEN REAL_ARITH_TAC); 3365 3366val lemma = Q.prove ( 3367 `(b - a = c) ==> 3368 abs (a:real) < e / &2 ==> abs (b) < e / &2 ==> abs (c) < e`, 3369 DISCH_THEN(SUBST1_TAC o SYM) THEN REWRITE_TAC[GSYM dist] THEN 3370 REPEAT STRIP_TAC THEN MATCH_MP_TAC DIST_TRIANGLE_HALF_L THEN 3371 EXISTS_TAC ``0:real`` THEN 3372 ASM_SIMP_TAC std_ss [dist, REAL_SUB_LZERO, REAL_SUB_RZERO, ABS_NEG]); 3373 3374val INTEGRABLE_SPLIT = store_thm ("INTEGRABLE_SPLIT", 3375 ``!f:real->real a b. 3376 f integrable_on (interval[a,b]) 3377 ==> f integrable_on (interval[a,b] INTER {x | x <= c}) /\ 3378 f integrable_on (interval[a,b] INTER {x | x >= c})``, 3379 REPEAT GEN_TAC THEN 3380 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) [integrable_on] THEN 3381 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM, GSYM LEFT_EXISTS_AND_THM] THEN 3382 X_GEN_TAC ``y:real`` THEN DISCH_TAC THEN CONJ_TAC THEN 3383 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, INTEGRABLE_CAUCHY] THEN 3384 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 3385 FIRST_ASSUM(MP_TAC o SPEC ``e / &2:real`` o 3386 MATCH_MP HAS_INTEGRAL_SEPARATE_SIDES) THEN 3387 MAP_EVERY ABBREV_TAC 3388 [``b' = min (b:real) c``, ``a' = max (a:real) c``] THEN 3389 ASM_SIMP_TAC std_ss [REAL_HALF, INTERVAL_SPLIT] THEN 3390 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 3391 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 3392 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 3393 FIRST_ASSUM(MP_TAC o MATCH_MP FINE_DIVISION_EXISTS) THENL 3394 [DISCH_THEN(MP_TAC o SPECL [``a':real``, ``b:real``]) THEN 3395 KNOW_TAC ``! (p2 :real # (real -> bool) -> bool) 3396 (p1 :real # (real -> bool) -> bool). 3397 p1 tagged_division_of interval [((a :real),(b' :real))] /\ 3398 (d :real -> real -> bool) FINE p1 /\ 3399 p2 tagged_division_of interval [((a' :real),(b :real))] /\ 3400 d FINE p2 ==> 3401 abs (sum p1 (\((x :real),(k :real -> bool)). 3402 content k * (f :real -> real) x) + 3403 sum p2 (\((x :real),(k :real -> bool)). content k * f x) - 3404 (y :real)) < (e :real) / (2 :real)`` THENL 3405 [METIS_TAC [SWAP_FORALL_THM], POP_ASSUM K_TAC THEN DISCH_TAC], 3406 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b':real``])] THEN 3407 DISCH_THEN(X_CHOOSE_THEN ``p:(real#(real->bool))->bool`` 3408 STRIP_ASSUME_TAC) THEN 3409 REPEAT STRIP_TAC THEN FIRST_X_ASSUM(fn th => 3410 MP_TAC(SPECL [``p:(real#(real->bool))->bool``, 3411 ``p1:(real#(real->bool))->bool``] th) THEN 3412 MP_TAC(SPECL [``p:(real#(real->bool))->bool``, 3413 ``p2:(real#(real->bool))->bool``] th)) THEN 3414 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC lemma THEN REAL_ARITH_TAC); 3415 3416(* ------------------------------------------------------------------------- *) 3417(* Generalized notion of additivity. *) 3418(* ------------------------------------------------------------------------- *) 3419 3420val operative = new_definition ("operative", 3421 ``operative op (f:(real->bool)->'a) <=> 3422 (!a b. (content(interval[a,b]) = &0) ==> (f(interval[a,b]) = neutral(op))) /\ 3423 (!a b c. (f(interval[a,b]) = op (f(interval[a,b] INTER {x | x <= c})) 3424 (f(interval[a,b] INTER {x | x >= c}))))``); 3425 3426val OPERATIVE_TRIVIAL = store_thm ("OPERATIVE_TRIVIAL", 3427 ``!op f a b. 3428 operative op f /\ (content(interval[a,b]) = &0) 3429 ==> (f(interval[a,b]) = neutral op)``, 3430 REWRITE_TAC[operative] THEN MESON_TAC[]); 3431 3432val PROPERTY_EMPTY_INTERVAL = store_thm ("PROPERTY_EMPTY_INTERVAL", 3433 ``!P. (!a b:real. (content(interval[a,b]) = &0) 3434 ==> P(interval[a,b])) ==> P {}``, 3435 MESON_TAC[EMPTY_AS_INTERVAL, CONTENT_EMPTY]); 3436 3437val OPERATIVE_EMPTY = store_thm ("OPERATIVE_EMPTY", 3438 ``!op f:(real->bool)->'a. operative op f ==> (f {} = neutral op)``, 3439 REPEAT GEN_TAC THEN REWRITE_TAC[operative] THEN 3440 DISCH_THEN (CONJUNCTS_THEN2 (MP_TAC o SPECL [``1:real``, ``0:real``]) ASSUME_TAC) THEN 3441 ASSUME_TAC INTERVAL_EQ_EMPTY THEN POP_ASSUM (MP_TAC o Q.SPECL [`1:real`, `0:real`]) THEN 3442 REWRITE_TAC [REAL_ARITH ``0 < 1:real``] THEN STRIP_TAC THEN 3443 ASM_REWRITE_TAC [CONTENT_EMPTY] THEN METIS_TAC []); 3444 3445(* ------------------------------------------------------------------------- *) 3446(* Using additivity of lifted function to encode definedness. *) 3447(* ------------------------------------------------------------------------- *) 3448 3449val lifted = Define 3450 `(lifted op NONE _ = NONE) /\ 3451 (lifted op _ NONE = NONE) /\ 3452 (lifted op (SOME x) (SOME y) = SOME(op x y))`; 3453 3454val NEUTRAL_LIFTED = store_thm ("NEUTRAL_LIFTED", 3455 ``!op. monoidal op ==> (neutral(lifted op) = SOME(neutral op))``, 3456 REWRITE_TAC[neutral, monoidal] THEN REPEAT STRIP_TAC THEN 3457 MATCH_MP_TAC SELECT_UNIQUE THEN 3458 SIMP_TAC std_ss [FORALL_OPTION, lifted, NOT_NONE_SOME, option_CLAUSES] THEN 3459 ASM_MESON_TAC[]); 3460 3461val MONOIDAL_LIFTED = store_thm ("MONOIDAL_LIFTED", 3462 ``!op. monoidal op ==> monoidal(lifted op)``, 3463 REPEAT STRIP_TAC THEN ASM_SIMP_TAC std_ss [NEUTRAL_LIFTED, monoidal] THEN 3464 SIMP_TAC std_ss [FORALL_OPTION, lifted, NOT_NONE_SOME, option_CLAUSES] THEN 3465 ASM_MESON_TAC[monoidal]); 3466 3467val ITERATE_SOME = store_thm ("ITERATE_SOME", 3468 ``!op. monoidal op ==> !f s. FINITE s 3469 ==> (iterate (lifted op) s (\x. SOME(f x)) = 3470 SOME(iterate op s f))``, 3471 GEN_TAC THEN DISCH_TAC THEN GEN_TAC THEN 3472 KNOW_TAC ``!(s :'b -> bool). 3473 FINITE s ==> 3474 (\s. (iterate (lifted (op :'a -> 'a -> 'a)) s 3475 (\(x :'b). SOME ((f :'b -> 'a) x)) = 3476 SOME (iterate op s f))) s`` THENL 3477 [ALL_TAC, SIMP_TAC std_ss []] THEN 3478 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 3479 ASM_SIMP_TAC std_ss [ITERATE_CLAUSES, MONOIDAL_LIFTED, NEUTRAL_LIFTED] THEN 3480 SIMP_TAC std_ss [lifted]); 3481 3482(* ------------------------------------------------------------------------- *) 3483(* Two key instances of additivity. *) 3484(* ------------------------------------------------------------------------- *) 3485 3486val OPERATIVE_CONTENT = store_thm ("OPERATIVE_CONTENT", 3487 ``operative(+) content``, 3488 REWRITE_TAC[operative, NEUTRAL_REAL_ADD, CONTENT_SPLIT]); 3489 3490val OPERATIVE_INTEGRAL = store_thm ("OPERATIVE_INTEGRAL", 3491 ``!f:real->real. operative(lifted(+)) 3492 (\i. if f integrable_on i then SOME(integral i f) else NONE)``, 3493 SIMP_TAC std_ss [operative, NEUTRAL_LIFTED, MONOIDAL_REAL_ADD] THEN 3494 SIMP_TAC std_ss [NEUTRAL_REAL_ADD] THEN 3495 REPEAT STRIP_TAC THEN REPEAT(COND_CASES_TAC THEN ASM_SIMP_TAC std_ss []) THEN 3496 REWRITE_TAC[lifted, NOT_NONE_SOME, option_CLAUSES] THENL 3497 [REWRITE_TAC [integrable_on] THEN 3498 ASM_MESON_TAC[HAS_INTEGRAL_NULL], 3499 REWRITE_TAC[integral] THEN METIS_TAC[HAS_INTEGRAL_NULL_EQ], 3500 REPEAT(FIRST_X_ASSUM(MP_TAC o MATCH_MP INTEGRABLE_INTEGRAL)) THEN 3501 METIS_TAC[HAS_INTEGRAL_SPLIT, HAS_INTEGRAL_UNIQUE], 3502 METIS_TAC[INTEGRABLE_SPLIT, integrable_on], 3503 METIS_TAC[INTEGRABLE_SPLIT], 3504 METIS_TAC[INTEGRABLE_SPLIT], 3505 RULE_ASSUM_TAC(REWRITE_RULE[integrable_on]) THEN 3506 METIS_TAC[HAS_INTEGRAL_SPLIT]]); 3507 3508(* ------------------------------------------------------------------------- *) 3509(* Points of division of a partition. *) 3510(* ------------------------------------------------------------------------- *) 3511 3512val _ = hide "division_points"; 3513 3514val division_points = new_definition ("division_points", 3515 ``division_points (k:real->bool) (d:(real->bool)->bool) = 3516 {(j,x) | (1:num <= j) /\ (j <= 1:num) /\ (interval_lowerbound k) < x /\ 3517 x < (interval_upperbound k) /\ 3518 ?i. i IN d /\ ((interval_lowerbound i = x) \/ 3519 (interval_upperbound i = x))}``); 3520 3521val DIVISION_POINTS_FINITE = store_thm ("DIVISION_POINTS_FINITE", 3522 ``!d i:real->bool. d division_of i ==> FINITE(division_points i d)``, 3523 REWRITE_TAC[division_of, division_points] THEN 3524 REPEAT STRIP_TAC THEN REWRITE_TAC[CONJ_ASSOC, GSYM IN_NUMSEG] THEN 3525 REWRITE_TAC[SPECIFICATION, GSYM CONJ_ASSOC] THEN 3526 KNOW_TAC ``FINITE {(\j x. (j,x)) j x | 3527 j IN (1 .. 1) /\ x IN (\j x. interval_lowerbound i < x /\ 3528 x < interval_upperbound i /\ ?i. d i /\ 3529 ((interval_lowerbound i = x) \/ (interval_upperbound i = x))) j }`` THENL 3530 [ALL_TAC, BETA_TAC THEN SIMP_TAC std_ss [SPECIFICATION]] THEN 3531 MATCH_MP_TAC FINITE_PRODUCT_DEPENDENT THEN 3532 SIMP_TAC std_ss [ETA_AX, FINITE_NUMSEG] THEN 3533 X_GEN_TAC ``j:num`` THEN 3534 REWRITE_TAC[IN_NUMSEG] THEN STRIP_TAC THEN 3535 MATCH_MP_TAC FINITE_SUBSET THEN EXISTS_TAC 3536 ``IMAGE (\i:real->bool. (interval_lowerbound i)) d UNION 3537 IMAGE (\i:real->bool. (interval_upperbound i)) d`` THEN 3538 ASM_SIMP_TAC std_ss [FINITE_UNION, IMAGE_FINITE] THEN 3539 SIMP_TAC std_ss [SUBSET_DEF, IN_IMAGE, IN_UNION, GSPECIFICATION] THEN 3540 REWRITE_TAC [SPECIFICATION] THEN BETA_TAC THEN 3541 MESON_TAC[SPECIFICATION]); 3542 3543val DIVISION_POINTS_SUBSET = store_thm ("DIVISION_POINTS_SUBSET", 3544 ``!a b:real c d k. 3545 d division_of interval[a,b] /\ a < b /\ a < c /\ c < b 3546 ==> division_points (interval[a,b] INTER {x | x <= c}) 3547 {l INTER {x | x <= c} | l | 3548 l IN d /\ ~(l INTER {x | x <= c} = {})} 3549 SUBSET division_points (interval[a,b]) d /\ 3550 division_points (interval[a,b] INTER {x | x >= c}) 3551 {l INTER {x | x >= c} | l | 3552 l IN d /\ ~(l INTER {x | x >= c} = {})} 3553 SUBSET division_points (interval[a,b]) d``, 3554 REPEAT STRIP_TAC THEN 3555 (SIMP_TAC std_ss [SUBSET_DEF, division_points, FORALL_PROD] THEN 3556 MAP_EVERY X_GEN_TAC [``j:num``, ``x:real``] THEN 3557 SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN SIMP_TAC std_ss [GSPECIFICATION] THEN 3558 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, 3559 REAL_LT_IMP_LE] THEN 3560 ASM_SIMP_TAC std_ss [METIS [max_def, REAL_LT_IMP_LE] ``a < c ==> (max a c = c:real)``, 3561 METIS [min_def, REAL_NOT_LE] ``c < b ==> (min b c = c:real)``] THEN 3562 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 3563 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 3564 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND, 3565 REAL_LT_IMP_LE, COND_ID, 3566 METIS [] ``(a <= if p then x else y) <=> (if p then a <= x else a <= y)``, 3567 METIS [] ``(if p then x else y) <= a <=> (if p then x <= a else y <= a)``] THEN 3568 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 3569 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 3570 DISCH_THEN(fn th => CONJ_TAC THEN MP_TAC th) THENL 3571 [DISCH_THEN(K ALL_TAC) THEN REPEAT(POP_ASSUM MP_TAC) THEN 3572 ASM_SIMP_TAC arith_ss [] THEN REAL_ARITH_TAC, ALL_TAC]) THENL 3573 [KNOW_TAC ``!l. (?i. ((l IN d /\ ~(l INTER {x | x <= c} = {})) /\ 3574 (i = l INTER {x | x <= c})) /\ 3575 ((interval_lowerbound i = x) \/ (interval_upperbound i = x))) 3576 ==> l IN d /\ 3577 ((interval_lowerbound l = x) \/ (interval_upperbound l = x))`` THENL 3578 [ALL_TAC, METIS_TAC [GSYM LEFT_EXISTS_AND_THM, SWAP_EXISTS_THM, MONO_EXISTS]], 3579 KNOW_TAC ``!l. (?i. ((l IN d /\ ~(l INTER {x | x >= c} = {})) /\ 3580 (i = l INTER {x | x >= c})) /\ 3581 ((interval_lowerbound i = x) \/ (interval_upperbound i = x))) 3582 ==> l IN d /\ 3583 ((interval_lowerbound l = x) \/ (interval_upperbound l = x))`` THENL 3584 [ALL_TAC, METIS_TAC [GSYM LEFT_EXISTS_AND_THM, SWAP_EXISTS_THM, MONO_EXISTS]]] THEN 3585 (ONCE_REWRITE_TAC[TAUT `(a /\ b) /\ c <=> b /\ a /\ c`]) THENL 3586 [KNOW_TAC ``!l. (l IN d /\ ~(l INTER {x | x <= c} = {})) /\ 3587 ((interval_lowerbound (l INTER {x | x <= c}) = x) \/ 3588 (interval_upperbound (l INTER {x | x <= c}) = x)) 3589 ==> l IN d /\ 3590 ((interval_lowerbound l = x) \/ (interval_upperbound l = x))`` THENL 3591 [ALL_TAC, METIS_TAC [UNWIND_THM2]] THEN SIMP_TAC std_ss [GSYM CONJ_ASSOC], 3592 KNOW_TAC ``!l. (l IN d /\ ~(l INTER {x | x >= c} = {})) /\ 3593 ((interval_lowerbound (l INTER {x | x >= c}) = x) \/ 3594 (interval_upperbound (l INTER {x | x >= c}) = x)) 3595 ==> l IN d /\ 3596 ((interval_lowerbound l = x) \/ (interval_upperbound l = x))`` THENL 3597 [ALL_TAC, METIS_TAC [UNWIND_THM2]] THEN SIMP_TAC std_ss [GSYM CONJ_ASSOC]] THEN 3598 (ONCE_REWRITE_TAC[IMP_CONJ] THEN 3599 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 3600 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN DISCH_TAC THEN 3601 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 3602 SUBGOAL_THEN 3603 ``(u:real) <= (v:real)`` ASSUME_TAC THENL 3604 [SIMP_TAC std_ss [GSYM INTERVAL_NE_EMPTY] THEN ASM_MESON_TAC[division_of], 3605 ALL_TAC] THEN 3606 REWRITE_TAC[INTERVAL_NE_EMPTY] THEN 3607 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 3608 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND] THEN 3609 POP_ASSUM MP_TAC THEN REWRITE_TAC [min_def, max_def] THEN 3610 REPEAT (COND_CASES_TAC) THEN FULL_SIMP_TAC arith_ss [] THEN 3611 REPEAT STRIP_TAC THEN FULL_SIMP_TAC std_ss [REAL_LT_REFL])); 3612 3613val DIVISION_POINTS_PSUBSET = store_thm ("DIVISION_POINTS_PSUBSET", 3614 ``!a b:real c d. 3615 d division_of interval[a,b] /\ a < b /\ a < c /\ c < b /\ 3616 (?l. l IN d /\ 3617 ((interval_lowerbound l = c) \/ (interval_upperbound l = c))) 3618 ==> division_points (interval[a,b] INTER {x | x <= c}) 3619 {l INTER {x | x <= c} | l | 3620 l IN d /\ ~(l INTER {x | x <= c} = {})} 3621 PSUBSET division_points (interval[a,b]) d /\ 3622 division_points (interval[a,b] INTER {x | x >= c}) 3623 {l INTER {x | x >= c} | l | 3624 l IN d /\ ~(l INTER {x | x >= c} = {})} 3625 PSUBSET division_points (interval[a,b]) d``, 3626 REPEAT STRIP_TAC THEN 3627 ASM_SIMP_TAC std_ss [PSUBSET_MEMBER, DIVISION_POINTS_SUBSET] THENL 3628 [EXISTS_TAC ``1:num,(interval_lowerbound l:real)``, 3629 EXISTS_TAC ``1:num,(interval_lowerbound l:real)``, 3630 EXISTS_TAC ``1:num,(interval_upperbound l:real)``, 3631 EXISTS_TAC ``1:num,(interval_upperbound l:real)``] THEN 3632 ASM_SIMP_TAC std_ss [division_points, IN_ELIM_PAIR_THM] THEN 3633 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, REAL_LT_IMP_LE] THEN 3634 (CONJ_TAC THENL [ASM_MESON_TAC[], ALL_TAC]) THEN 3635 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, 3636 REAL_LT_IMP_LE] THEN 3637 ASM_SIMP_TAC std_ss [METIS [max_def, REAL_LT_IMP_LE] ``a < c ==> (max a c = c:real)``, 3638 METIS [min_def, REAL_NOT_LE] ``c < b ==> (min b c = c:real)``] THEN 3639 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND, REAL_LT_IMP_LE, COND_ID, 3640 METIS [] ``(a <= if p then x else y) <=> (if p then a <= x else a <= y)``, 3641 METIS [] ``(if p then x else y) <= a <=> (if p then x <= a else y <= a)``] THEN 3642 REWRITE_TAC[REAL_LT_REFL]); 3643 3644(* ------------------------------------------------------------------------- *) 3645(* Preservation by divisions and tagged divisions. *) 3646(* ------------------------------------------------------------------------- *) 3647 3648Theorem OPERATIVE_DIVISION : 3649 !op d a b f:(real->bool)->'a. 3650 monoidal op /\ operative op f /\ d division_of interval[a,b] 3651 ==> (iterate(op) d f = f(interval[a,b])) 3652Proof 3653 REPEAT GEN_TAC THEN CONV_TAC(RAND_CONV SYM_CONV) THEN 3654 completeInduct_on 3655 `CARD (division_points (interval[a,b]:real->bool) d)` THEN 3656 REPEAT GEN_TAC THEN DISCH_TAC THEN FULL_SIMP_TAC std_ss [] THEN 3657 POP_ASSUM K_TAC THEN 3658 POP_ASSUM(fn th => REPEAT STRIP_TAC THEN MP_TAC th) THEN 3659 ASM_REWRITE_TAC[] THEN 3660 ASM_CASES_TAC ``content(interval[a:real,b]) = &0`` THENL 3661 [SUBGOAL_THEN ``iterate op d (f:(real->bool)->'a) = neutral op`` 3662 (fn th => METIS_TAC[th, operative]) THEN 3663 MATCH_MP_TAC(SIMP_RULE std_ss [RIGHT_IMP_FORALL_THM, AND_IMP_INTRO] 3664 ITERATE_EQ_NEUTRAL) THEN 3665 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 3666 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 3667 ASM_MESON_TAC[operative, DIVISION_OF_CONTENT_0], 3668 ALL_TAC] THEN 3669 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM CONTENT_LT_NZ]) THEN 3670 REWRITE_TAC[CONTENT_POS_LT_EQ] THEN STRIP_TAC THEN 3671 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 3672 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 3673 ASM_CASES_TAC ``division_points (interval[a,b]:real->bool) d = {}`` THENL 3674 [(* goal 1 (of 2) *) 3675 DISCH_THEN(K ALL_TAC) THEN 3676 SUBGOAL_THEN 3677 ``!i. i IN d 3678 ==> ?u v:real. (i = interval[u,v]) /\ 3679 ((u = (a:real)) /\ (v = a) \/ 3680 (u = (b:real)) /\ (v = b) \/ 3681 (u = a) /\ (v = b))`` 3682 (ASSUME_TAC) THENL 3683 [FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 3684 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN DISCH_TAC THEN 3685 MAP_EVERY EXISTS_TAC [``u:real``, ``v:real``] THEN REWRITE_TAC[] THEN 3686 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 3687 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 3688 ASM_REWRITE_TAC[] THEN 3689 DISCH_THEN(MP_TAC o SPEC ``interval[u:real,v]`` o CONJUNCT1) THEN 3690 ASM_REWRITE_TAC[INTERVAL_NE_EMPTY] THEN 3691 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC (ASSUME_TAC o CONJUNCT1)) THEN 3692 ASM_REWRITE_TAC[SUBSET_INTERVAL] THEN STRIP_TAC THEN 3693 MATCH_MP_TAC(REAL_ARITH 3694 ``a <= u /\ u <= v /\ v <= b /\ ~(a < u /\ u < b \/ a < v /\ v < b:real) 3695 ==> (u = a) /\ (v = a) \/ (u = b) /\ (v = b) \/ (u = a) /\ (v = b)``) THEN 3696 ASM_REWRITE_TAC [] THEN DISCH_TAC THEN 3697 UNDISCH_TAC ``division_points (interval [(a,b)]) d = {}`` THEN DISCH_TAC THEN 3698 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [EXTENSION]) THEN 3699 DISCH_THEN (MP_TAC o SIMP_RULE std_ss [division_points, NOT_IN_EMPTY, FORALL_PROD]) THEN 3700 SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN EXISTS_TAC ``1:num`` THEN 3701 REWRITE_TAC [LESS_EQ_REFL] THEN SIMP_TAC std_ss [GSYM RIGHT_EXISTS_AND_THM] THEN 3702 SIMP_TAC std_ss [NOT_EXISTS_THM] THEN 3703 KNOW_TAC ``?(i :real -> bool)(p_2 :real). 3704 interval_lowerbound (interval [((a :real),(b :real))]) < p_2 /\ 3705 p_2 < interval_upperbound (interval [(a,b)]) /\ 3706 i IN (d :(real -> bool) -> bool) /\ 3707 ((interval_lowerbound i = p_2) \/ (interval_upperbound i = p_2))`` THENL 3708 [ALL_TAC, METIS_TAC [SWAP_EXISTS_THM]] THEN 3709 EXISTS_TAC ``interval[u:real,v]`` THEN 3710 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND, REAL_LT_IMP_LE] THEN 3711 KNOW_TAC ``~(!p_2:real. ~(a < p_2 /\ p_2 < b /\ ((u = p_2) \/ (v = p_2))))`` THENL 3712 [ALL_TAC, SIMP_TAC std_ss []] THEN 3713 DISCH_THEN(fn th => 3714 MP_TAC(SPEC ``(u:real)`` th) THEN 3715 MP_TAC(SPEC ``(v:real)`` th)) THEN 3716 FIRST_X_ASSUM(DISJ_CASES_THEN MP_TAC) THEN REAL_ARITH_TAC, 3717 ALL_TAC] THEN 3718 SUBGOAL_THEN ``interval[a:real,b] IN d`` MP_TAC THENL 3719 [UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 3720 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 3721 ASM_REWRITE_TAC[] THEN DISCH_THEN(MP_TAC o last o CONJUNCTS) THEN 3722 REWRITE_TAC[EXTENSION, IN_INTERVAL, IN_BIGUNION] THEN 3723 DISCH_THEN(MP_TAC o SPEC ``inv(&2) * (a + b:real)``) THEN 3724 MATCH_MP_TAC(TAUT `b /\ (a ==> c) ==> (a <=> b) ==> c`) THEN 3725 CONJ_TAC THENL 3726 [ONCE_REWRITE_TAC [REAL_MUL_SYM] THEN REWRITE_TAC [GSYM real_div] THEN 3727 SIMP_TAC real_ss [REAL_LE_RDIV_EQ, REAL_LE_LDIV_EQ] THEN 3728 UNDISCH_TAC ``a < b:real`` THEN REAL_ARITH_TAC, 3729 ALL_TAC] THEN 3730 DISCH_THEN(X_CHOOSE_THEN ``i:real->bool`` 3731 (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC)) THEN 3732 UNDISCH_TAC ``!i. i IN d ==> 3733 ?u v:real. (i = interval [(u,v)]) /\ 3734 ((u = a) /\ (v = a) \/ (u = b) /\ (v = b) \/ (u = a) /\ (v = b))`` THEN 3735 DISCH_THEN (MP_TAC o SPEC ``i:real->bool``) THEN 3736 ASM_REWRITE_TAC[] THEN SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 3737 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN 3738 DISCH_THEN(CONJUNCTS_THEN2 SUBST_ALL_TAC MP_TAC) THEN 3739 SIMP_TAC std_ss [IN_INTERVAL] THEN 3740 SIMP_TAC std_ss [AND_IMP_INTRO, GSYM FORALL_AND_THM] THEN 3741 ONCE_REWRITE_TAC [REAL_MUL_SYM] THEN REWRITE_TAC [GSYM real_div] THEN 3742 SIMP_TAC real_ss [REAL_LE_RDIV_EQ, REAL_LE_LDIV_EQ] THEN 3743 ASM_SIMP_TAC std_ss [REAL_ARITH 3744 ``a < b 3745 ==> (((u = a) /\ (v = a) \/ (u = b) /\ (v = b) \/ (u = a) /\ (v = b)) /\ 3746 u * 2 <= (a + b) /\ (a + b) <= v * 2 <=> 3747 (u = a) /\ (v = b:real))``] THEN 3748 ASM_MESON_TAC[], 3749 ALL_TAC] THEN 3750 DISCH_THEN(fn th => ASSUME_TAC th THEN MP_TAC th) THEN 3751 DISCH_THEN(SUBST1_TAC o MATCH_MP (SET_RULE 3752 ``a IN d ==> (d = a INSERT (d DELETE a))``)) THEN 3753 ASM_SIMP_TAC std_ss [ITERATE_CLAUSES, FINITE_DELETE, IN_DELETE] THEN 3754 SUBGOAL_THEN 3755 ``iterate op (d DELETE interval[a,b]) (f:(real->bool)->'a) = neutral op`` 3756 (fn th => METIS_TAC[th, monoidal]) THEN 3757 MATCH_MP_TAC(SIMP_RULE std_ss [RIGHT_IMP_FORALL_THM, AND_IMP_INTRO] 3758 ITERATE_EQ_NEUTRAL) THEN 3759 ASM_REWRITE_TAC[] THEN X_GEN_TAC ``l:real->bool`` THEN 3760 REWRITE_TAC[IN_DELETE] THEN STRIP_TAC THEN 3761 SUBGOAL_THEN ``content(l:real->bool) = &0`` 3762 (fn th => METIS_TAC[th, operative]) THEN 3763 UNDISCH_TAC ``!i. i IN d ==> 3764 ?u v:real. (i = interval [(u,v)]) /\ 3765 ((u = a) /\ (v = a) \/ (u = b) /\ (v = b) \/ (u = a) /\ (v = b))`` THEN 3766 DISCH_THEN (MP_TAC o SPEC ``l:real->bool``) THEN 3767 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 3768 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN 3769 DISCH_THEN(CONJUNCTS_THEN2 SUBST_ALL_TAC MP_TAC) THEN 3770 UNDISCH_TAC ``~(interval[u:real,v] = interval[a,b])`` THEN 3771 ONCE_REWRITE_TAC[MONO_NOT_EQ] THEN 3772 REWRITE_TAC[] THEN DISCH_THEN(fn th => AP_TERM_TAC THEN MP_TAC th) THEN 3773 SIMP_TAC std_ss [CONS_11, PAIR_EQ, CONTENT_EQ_0] THEN 3774 REAL_ARITH_TAC, ALL_TAC] THEN 3775 KNOW_TAC `` 3776 (!(a' :real) (b' :real) (d' :(real -> bool) -> bool). 3777 (CARD (division_points (interval [(a',b')]) d') < CARD 3778 (division_points (interval [((a :real),(b :real))]) 3779 (d :(real -> bool) -> bool))) ==> 3780 d' division_of interval [(a',b')] ==> 3781 ((f :(real -> bool) -> 'a) (interval [(a',b')]) = 3782 iterate (op :'a -> 'a -> 'a) d' f)) ==> 3783 (f (interval [(a,b)]) = iterate op d f)`` THENL 3784 [ALL_TAC, METIS_TAC []] THEN 3785 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [GSYM MEMBER_NOT_EMPTY]) THEN 3786 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) [division_points] THEN 3787 SIMP_TAC std_ss [GSPECIFICATION, LEFT_IMP_EXISTS_THM, EXISTS_PROD] THEN 3788 MAP_EVERY X_GEN_TAC [``k:num``, ``c:real``] THEN 3789 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, REAL_LT_IMP_LE] THEN 3790 DISCH_THEN(REPEAT_TCL CONJUNCTS_THEN ASSUME_TAC) THEN 3791 MP_TAC(ISPECL [``a:real``, ``b:real``, ``c:real``, ``d:(real->bool)->bool``] 3792 DIVISION_POINTS_PSUBSET) THEN 3793 ASM_REWRITE_TAC[] THEN 3794 DISCH_THEN(CONJUNCTS_THEN 3795 (MP_TAC o MATCH_MP (SIMP_RULE std_ss [IMP_CONJ] 3796 (METIS [CARD_PSUBSET] ``!a b. a PSUBSET b /\ FINITE b ==> 3797 CARD a < CARD b``)))) THEN 3798 MP_TAC(ISPECL [``d:(real->bool)->bool``, ``a:real``, ``b:real``, ``c:real``] 3799 DIVISION_SPLIT) THEN 3800 ASM_SIMP_TAC std_ss [DIVISION_POINTS_FINITE] THEN 3801 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 3802 KNOW_TAC ``(max a c = c:real) /\ (min b c = c:real)`` THENL 3803 [ CONJ_TAC >- (Suff `a <= c` >- METIS_TAC [REAL_MAX_ALT] \\ 3804 MATCH_MP_TAC REAL_LT_IMP_LE >> art []) \\ 3805 Suff `c <= b` >- METIS_TAC [REAL_MIN_ALT] \\ 3806 MATCH_MP_TAC REAL_LT_IMP_LE >> art [], STRIP_TAC ] THEN 3807 ASM_SIMP_TAC std_ss [] THEN POP_ASSUM K_TAC THEN POP_ASSUM K_TAC THEN 3808 MAP_EVERY ABBREV_TAC 3809 [``d1:(real->bool)->bool = 3810 {l INTER {x | x <= c} | l | l IN d /\ ~(l INTER {x | x <= c} = {})}``, 3811 ``d2:(real->bool)->bool = 3812 {l INTER {x | x >= c} | l | l IN d /\ ~(l INTER {x | x >= c} = {})}``, 3813 ``cb:real = c``, 3814 ``ca:real = c``] THEN 3815 STRIP_TAC THEN STRIP_TAC THEN STRIP_TAC THEN 3816 DISCH_THEN(fn th => 3817 MP_TAC(SPECL [``a:real``, ``cb:real``, ``d1:(real->bool)->bool``] th) THEN 3818 MP_TAC(SPECL [``ca:real``, ``b:real``, ``d2:(real->bool)->bool``] th)) THEN 3819 ASM_REWRITE_TAC[] THEN REPEAT STRIP_TAC THEN 3820 MATCH_MP_TAC EQ_TRANS THEN 3821 EXISTS_TAC ``op (iterate op d1 (f:(real->bool)->'a)) 3822 (iterate op d2 (f:(real->bool)->'a))`` THEN 3823 CONJ_TAC THENL 3824 [FIRST_ASSUM(MP_TAC o CONJUNCT2 o REWRITE_RULE [operative]) THEN 3825 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``, ``c:real``]) THEN 3826 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 3827 KNOW_TAC ``(max a cb = cb:real) /\ (min b cb = cb:real)`` THENL 3828 [ CONJ_TAC >- (Suff `a <= cb` >- METIS_TAC [REAL_MAX_ALT] \\ 3829 MATCH_MP_TAC REAL_LT_IMP_LE >> art []) \\ 3830 Suff `cb <= b` >- METIS_TAC [REAL_MIN_ALT] \\ 3831 MATCH_MP_TAC REAL_LT_IMP_LE >> art [], STRIP_TAC ] THEN 3832 ASM_SIMP_TAC std_ss [], 3833 ALL_TAC] THEN 3834 MATCH_MP_TAC EQ_TRANS THEN 3835 EXISTS_TAC 3836 ``op (iterate op d (\l. f(l INTER {x | x <= c}):'a)) 3837 (iterate op d (\l. f(l INTER {x:real | x >= c})))`` THEN 3838 CONJ_TAC THENL 3839 [ALL_TAC, 3840 ASM_SIMP_TAC std_ss [GSYM ITERATE_OP] THEN 3841 MATCH_MP_TAC(SIMP_RULE std_ss [RIGHT_IMP_FORALL_THM, AND_IMP_INTRO] 3842 ITERATE_EQ) THEN 3843 ASM_SIMP_TAC std_ss[MATCH_MP FORALL_IN_DIVISION 3844 (ASSUME ``d division_of interval[a:real,b]``)] THEN 3845 METIS_TAC[operative]] THEN 3846 ASM_SIMP_TAC std_ss [] THEN 3847 MAP_EVERY EXPAND_TAC ["d1", "d2"] THEN BINOP_TAC THEN 3848 (KNOW_TAC ``(iterate op d (\l. f (l INTER {x | x <= cb})) = 3849 iterate op d (f o (\l:real->bool. (l INTER {x | x <= cb})))) /\ 3850 (iterate op d (\l. f (l INTER {x | x >= cb})) = 3851 iterate op d (f o (\l:real->bool. (l INTER {x | x >= cb}))))`` THENL 3852 [SIMP_TAC std_ss [o_DEF], DISCH_THEN (fn th => SIMP_TAC std_ss [th])]) THENL 3853 [KNOW_TAC ``iterate (op :'a -> 'a -> 'a) 3854 {l INTER {x | x <= (cb :real)} | 3855 l | 3856 l IN (d :(real -> bool) -> bool) /\ 3857 l INTER {x | x <= cb} <> ({} :real -> bool)} 3858 (f :(real -> bool) -> 'a) = 3859 iterate (op :'a -> 'a -> 'a) 3860 {(\l. l INTER {x | x <= (cb :real)}) l | 3861 l | 3862 l IN (d :(real -> bool) -> bool) /\ 3863 (\l. l INTER {x | x <= cb}) l <> ({} :real -> bool)} 3864 (f :(real -> bool) -> 'a)`` THENL 3865 [METIS_TAC [], DISCH_THEN (fn th => ONCE_REWRITE_TAC [th])], 3866 KNOW_TAC ``iterate (op :'a -> 'a -> 'a) 3867 {l INTER {x | x >= (cb :real)} | 3868 l | 3869 l IN (d :(real -> bool) -> bool) /\ 3870 l INTER {x | x >= cb} <> ({} :real -> bool)} 3871 (f :(real -> bool) -> 'a) = 3872 iterate (op :'a -> 'a -> 'a) 3873 {(\l. l INTER {x | x >= (cb :real)}) l | 3874 l | 3875 l IN (d :(real -> bool) -> bool) /\ 3876 (\l. l INTER {x | x >= cb}) l <> ({} :real -> bool)} 3877 (f :(real -> bool) -> 'a)`` THENL 3878 [METIS_TAC [], DISCH_THEN (fn th => ONCE_REWRITE_TAC [th])]] THEN 3879 MATCH_MP_TAC ITERATE_NONZERO_IMAGE_LEMMA THEN ASM_SIMP_TAC std_ss [] THEN 3880 (CONJ_TAC THENL [ASM_MESON_TAC[OPERATIVE_EMPTY], ALL_TAC] THEN 3881 MAP_EVERY X_GEN_TAC [``l:real->bool``, ``m:real->bool``] THEN STRIP_TAC THEN 3882 MATCH_MP_TAC(MESON[OPERATIVE_TRIVIAL] 3883 ``operative op f /\ (?a b. l = interval[a,b]) /\ (content l = &0) 3884 ==> (f l = neutral op)``) THEN 3885 ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THENL 3886 [ALL_TAC, METIS_TAC[DIVISION_SPLIT_LEFT_INJ, 3887 DIVISION_SPLIT_RIGHT_INJ]] THEN 3888 SUBGOAL_THEN ``?a b:real. m = interval[a,b]`` STRIP_ASSUME_TAC THENL 3889 [METIS_TAC[division_of], ALL_TAC] THEN 3890 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN MESON_TAC[]) 3891QED 3892 3893val lemma = Q.prove ( 3894 `(\(x,l). f l) = (f o SND)`, 3895 SIMP_TAC std_ss [FUN_EQ_THM, o_THM, FORALL_PROD]); 3896 3897val OPERATIVE_TAGGED_DIVISION = store_thm ("OPERATIVE_TAGGED_DIVISION", 3898 ``!op d a b f:(real->bool)->'a. 3899 monoidal op /\ operative op f /\ d tagged_division_of interval[a,b] 3900 ==> (iterate(op) d (\(x,l). f l) = f(interval[a,b]))``, 3901 REPEAT STRIP_TAC THEN MATCH_MP_TAC EQ_TRANS THEN EXISTS_TAC 3902 ``iterate op (IMAGE SND (d:(real#(real->bool)->bool))) f :'a`` THEN 3903 CONJ_TAC THENL 3904 [ALL_TAC, 3905 ASM_MESON_TAC[DIVISION_OF_TAGGED_DIVISION, OPERATIVE_DIVISION]] THEN 3906 REWRITE_TAC[lemma] THEN CONV_TAC SYM_CONV THEN 3907 KNOW_TAC ``monoidal (op:'a->'a->'a) /\ FINITE (d :real # (real -> bool) -> bool) /\ 3908 (!x y. x IN d /\ y IN d /\ ~(x = y) /\ (SND x = SND y) 3909 ==> ((f:(real -> bool) -> 'a) (SND x) = neutral op))`` THENL 3910 [ALL_TAC, METIS_TAC [RIGHT_IMP_FORALL_THM, AND_IMP_INTRO, ITERATE_IMAGE_NONZERO]] THEN 3911 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN CONJ_TAC THENL 3912 [ASM_MESON_TAC[TAGGED_DIVISION_OF_FINITE], ALL_TAC] THEN 3913 FIRST_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 3914 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o CONJUNCT1 o CONJUNCT2)) THEN 3915 DISCH_TAC THEN X_GEN_TAC ``x1:real`` THEN X_GEN_TAC ``k:real->bool`` THEN X_GEN_TAC ``x2:real`` THEN 3916 POP_ASSUM (MP_TAC o Q.SPECL [`x1:real`,`k:real->bool`,`x2:real`, `k:real->bool`]) THEN 3917 REWRITE_TAC[PAIR_EQ] THEN DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 3918 ASM_SIMP_TAC std_ss [INTER_ACI] THEN 3919 ASM_MESON_TAC[CONTENT_EQ_0_INTERIOR, OPERATIVE_TRIVIAL, 3920 TAGGED_DIVISION_OF]); 3921 3922(* ------------------------------------------------------------------------- *) 3923(* Additivity of content. *) 3924(* ------------------------------------------------------------------------- *) 3925 3926val ADDITIVE_CONTENT_DIVISION = store_thm ("ADDITIVE_CONTENT_DIVISION", 3927 ``!d a b:real. d division_of interval[a,b] 3928 ==> (sum d content = content(interval[a,b]))``, 3929 REPEAT GEN_TAC THEN DISCH_THEN(MP_TAC o MATCH_MP 3930 (MATCH_MP (REWRITE_RULE[TAUT `a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] 3931 OPERATIVE_DIVISION) (CONJ MONOIDAL_REAL_ADD OPERATIVE_CONTENT))) THEN 3932 REWRITE_TAC[sum_def]); 3933 3934val ADDITIVE_CONTENT_TAGGED_DIVISION = store_thm ("ADDITIVE_CONTENT_TAGGED_DIVISION", 3935 ``!d a b:real. 3936 d tagged_division_of interval[a,b] 3937 ==> (sum d (\(x,l). content l) = content(interval[a,b]))``, 3938 REPEAT GEN_TAC THEN DISCH_THEN(MP_TAC o MATCH_MP 3939 (MATCH_MP 3940 (REWRITE_RULE[TAUT `a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] 3941 OPERATIVE_TAGGED_DIVISION) 3942 (CONJ MONOIDAL_REAL_ADD OPERATIVE_CONTENT))) THEN 3943 REWRITE_TAC[sum_def]); 3944 3945val SUBADDITIVE_CONTENT_DIVISION = store_thm ("SUBADDITIVE_CONTENT_DIVISION", 3946 ``!d s a b:real. 3947 d division_of s /\ s SUBSET interval[a,b] 3948 ==> sum d content <= content(interval[a,b])``, 3949 REPEAT STRIP_TAC THEN 3950 MP_TAC(ISPECL [``d:(real->bool)->bool``, ``a:real``, ``b:real``] 3951 PARTIAL_DIVISION_EXTEND_INTERVAL) THEN 3952 KNOW_TAC ``(d :(real -> bool) -> bool) division_of BIGUNION d /\ 3953 BIGUNION d SUBSET interval [((a :real),(b :real))]`` THENL 3954 [REWRITE_TAC[BIGUNION_SUBSET] THEN 3955 ASM_MESON_TAC[division_of, DIVISION_OF_UNION_SELF, SUBSET_TRANS], 3956 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 3957 DISCH_THEN(X_CHOOSE_THEN ``p:(real->bool)->bool`` STRIP_ASSUME_TAC) THEN 3958 MATCH_MP_TAC REAL_LE_TRANS THEN 3959 EXISTS_TAC ``sum (p:(real->bool)->bool) content`` THEN CONJ_TAC THENL 3960 [MATCH_MP_TAC SUM_SUBSET_SIMPLE THEN 3961 ASM_MESON_TAC [division_of, CONTENT_POS_LE, IN_DIFF], 3962 ASM_MESON_TAC[ADDITIVE_CONTENT_DIVISION, REAL_LE_REFL]]]); 3963 3964(* ------------------------------------------------------------------------- *) 3965(* Finally, the integral of a constant! *) 3966(* ------------------------------------------------------------------------- *) 3967 3968val HAS_INTEGRAL_CONST = store_thm ("HAS_INTEGRAL_CONST", 3969 ``!a b:real c:real. 3970 ((\x. c) has_integral (content(interval[a,b]) * c)) (interval[a,b])``, 3971 REWRITE_TAC[has_integral] THEN REPEAT STRIP_TAC THEN 3972 EXISTS_TAC ``\x:real. ball(x,&1)`` THEN REWRITE_TAC[GAUGE_TRIVIAL] THEN 3973 REPEAT STRIP_TAC THEN 3974 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 3975 FIRST_X_ASSUM(fn th => 3976 ONCE_REWRITE_TAC[GSYM(MATCH_MP ADDITIVE_CONTENT_TAGGED_DIVISION th)]) THEN 3977 KNOW_TAC ``(abs 3978 (sum (p :real # (real -> bool) -> bool) 3979 (\((x :real),(k :real -> bool)). content k * (c :real)) - 3980 sum p (\((x :real),(l :real -> bool)). content l) * c) = (0:real))`` THENL 3981 [ALL_TAC, METIS_TAC []] THEN SIMP_TAC std_ss [ABS_ZERO, REAL_SUB_0] THEN 3982 REWRITE_TAC [SET_RULE `` (\(x,k). content k) = (\(x,k). (\p. content (SND p)) (x,k))``] THEN 3983 REWRITE_TAC [SET_RULE `` (\(x,k). content k * c) = 3984 (\(x,k). (\k. content (SND k) * c) (x,k))``] THEN 3985 REWRITE_TAC [GSYM LAMBDA_PROD] THEN SIMP_TAC std_ss [SUM_RMUL]); 3986 3987val INTEGRABLE_CONST = store_thm ("INTEGRABLE_CONST", 3988 ``!a b:real c:real. (\x. c) integrable_on interval[a,b]``, 3989 REPEAT STRIP_TAC THEN REWRITE_TAC[integrable_on] THEN 3990 EXISTS_TAC ``content(interval[a:real,b]) * c:real`` THEN 3991 REWRITE_TAC[HAS_INTEGRAL_CONST]); 3992 3993val INTEGRAL_CONST = store_thm ("INTEGRAL_CONST", 3994 ``!a b c. integral (interval[a,b]) (\x. c) = content(interval[a,b]) * c``, 3995 REPEAT GEN_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 3996 REWRITE_TAC[HAS_INTEGRAL_CONST]); 3997 3998(* ------------------------------------------------------------------------- *) 3999(* Bounds on the norm of Riemann sums and the integral itself. *) 4000(* ------------------------------------------------------------------------- *) 4001 4002val DSUM_BOUND = store_thm ("DSUM_BOUND", 4003 ``!p a b:real c:real e. 4004 p division_of interval[a,b] /\ abs (c) <= e 4005 ==> abs (sum p (\l. content l * c)) <= e * content(interval[a,b])``, 4006 REPEAT STRIP_TAC THEN 4007 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 4008 W(MP_TAC o PART_MATCH (lhand o rand) SUM_ABS o lhand o snd) THEN 4009 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC(REAL_ARITH 4010 ``y <= e ==> x <= y ==> x <= e:real``) THEN 4011 SIMP_TAC std_ss [LAMBDA_PROD, ABS_MUL] THEN 4012 MATCH_MP_TAC REAL_LE_TRANS THEN 4013 EXISTS_TAC ``sum p (\k:real->bool. content k * e)`` THEN 4014 CONJ_TAC THENL 4015 [MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 4016 X_GEN_TAC ``l:real->bool`` THEN DISCH_TAC THEN 4017 MATCH_MP_TAC REAL_LE_MUL2 THEN SIMP_TAC std_ss [REAL_ABS_POS, ABS_POS] THEN 4018 ASM_REWRITE_TAC[] THEN 4019 MATCH_MP_TAC(REAL_ARITH ``&0 <= x ==> abs(x) <= x:real``) THEN 4020 ASM_MESON_TAC[DIVISION_OF, CONTENT_POS_LE], 4021 SIMP_TAC std_ss [SUM_RMUL, ETA_AX] THEN 4022 ASM_MESON_TAC[ADDITIVE_CONTENT_DIVISION, REAL_LE_REFL, REAL_MUL_SYM]]); 4023 4024val RSUM_BOUND = store_thm ("RSUM_BOUND", 4025 ``!p a b f:real->real e. 4026 p tagged_division_of interval[a,b] /\ 4027 (!x. x IN interval[a,b] ==> abs(f x) <= e) 4028 ==> abs(sum p (\(x,k). content k * f x)) 4029 <= e * content(interval[a,b])``, 4030 REPEAT STRIP_TAC THEN 4031 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 4032 W(MP_TAC o PART_MATCH (lhand o rand) SUM_ABS o lhand o snd) THEN 4033 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC(REAL_ARITH 4034 ``y <= e ==> x <= y ==> x <= e:real``) THEN 4035 SIMP_TAC std_ss [LAMBDA_PROD, ABS_MUL] THEN 4036 MATCH_MP_TAC REAL_LE_TRANS THEN 4037 EXISTS_TAC ``sum p (\(x:real,k:real->bool). content k * e)`` THEN 4038 CONJ_TAC THENL 4039 [MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 4040 MAP_EVERY X_GEN_TAC [``x:real``, ``l:real->bool``] THEN DISCH_TAC THEN 4041 MATCH_MP_TAC REAL_LE_MUL2 THEN SIMP_TAC std_ss [REAL_ABS_POS, ABS_POS] THEN 4042 CONJ_TAC THENL 4043 [ASM_MESON_TAC[TAGGED_DIVISION_OF, CONTENT_POS_LE, ABS_REFL, 4044 REAL_LE_REFL], 4045 ASM_MESON_TAC[TAG_IN_INTERVAL]], 4046 FIRST_ASSUM(fn th => REWRITE_TAC 4047 [GSYM(MATCH_MP ADDITIVE_CONTENT_TAGGED_DIVISION th)]) THEN 4048 SIMP_TAC std_ss [GSYM SUM_LMUL, LAMBDA_PROD] THEN 4049 SIMP_TAC std_ss [REAL_MUL_ASSOC, REAL_MUL_SYM, REAL_LE_REFL]]); 4050 4051val RSUM_DIFF_BOUND = store_thm ("RSUM_DIFF_BOUND", 4052 ``!e p a b f g:real->real. 4053 p tagged_division_of interval[a,b] /\ 4054 (!x. x IN interval[a,b] ==> abs(f x - g x) <= e) 4055 ==> abs(sum p (\(x,k). content k * f x) - 4056 sum p (\(x,k). content k * g x)) 4057 <= e * content(interval[a,b])``, 4058 REPEAT STRIP_TAC THEN 4059 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 4060 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 4061 MATCH_MP_TAC REAL_LE_TRANS THEN 4062 EXISTS_TAC 4063 ``abs(sum p (\(x,k). 4064 content(k:real->bool) * ((f:real->real) x - g x)))`` THEN 4065 CONJ_TAC THENL 4066 [ASM_SIMP_TAC std_ss [GSYM SUM_SUB, REAL_SUB_LDISTRIB] THEN 4067 SIMP_TAC std_ss [LAMBDA_PROD, REAL_LE_REFL], 4068 ASM_SIMP_TAC std_ss [RSUM_BOUND]]); 4069 4070val lemma = Q.prove ( 4071 `abs(s) <= B ==> ~(abs(s - i) < abs(i) - B:real)`, 4072 MATCH_MP_TAC (REAL_ARITH ``n1 <= n + n2 ==> n <= B:real ==> ~(n2 < n1 - B)``) THEN 4073 ONCE_REWRITE_TAC[ABS_SUB] THEN REWRITE_TAC[ABS_TRIANGLE_SUB]); 4074 4075val HAS_INTEGRAL_BOUND = store_thm ("HAS_INTEGRAL_BOUND", 4076 ``!f:real->real a b i B. 4077 &0 <= B /\ 4078 (f has_integral i) (interval[a,b]) /\ 4079 (!x. x IN interval[a,b] ==> abs(f x) <= B) 4080 ==> abs i <= B * content(interval[a,b])``, 4081 REPEAT STRIP_TAC THEN 4082 ASM_CASES_TAC ``&0 < content(interval[a:real,b])`` THENL 4083 [ALL_TAC, 4084 SUBGOAL_THEN ``i:real = 0`` SUBST1_TAC THEN 4085 ASM_SIMP_TAC std_ss [REAL_LE_MUL, ABS_0, CONTENT_POS_LE] THEN 4086 ASM_MESON_TAC[HAS_INTEGRAL_NULL_EQ, CONTENT_LT_NZ]] THEN 4087 ONCE_REWRITE_TAC[GSYM REAL_NOT_LT] THEN DISCH_TAC THEN 4088 UNDISCH_TAC ``(f has_integral i) (interval [(a,b)])`` THEN DISCH_TAC THEN 4089 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [has_integral]) THEN 4090 DISCH_THEN(MP_TAC o SPEC 4091 ``abs(i:real) - B * content(interval[a:real,b])``) THEN 4092 ASM_REWRITE_TAC[REAL_SUB_LT] THEN 4093 DISCH_THEN(X_CHOOSE_THEN ``d:real->real->bool`` STRIP_ASSUME_TAC) THEN 4094 MP_TAC(SPECL [``d:real->real->bool``, ``a:real``, ``b:real``] 4095 FINE_DIVISION_EXISTS) THEN 4096 ASM_REWRITE_TAC[] THEN DISCH_THEN 4097 (X_CHOOSE_THEN ``p:(real#(real->bool)->bool)`` STRIP_ASSUME_TAC) THEN 4098 FIRST_X_ASSUM(MP_TAC o SPEC ``p:(real#(real->bool)->bool)``) THEN 4099 METIS_TAC[lemma, RSUM_BOUND]); 4100 4101(* ------------------------------------------------------------------------- *) 4102(* Similar theorems about relationship among components. *) 4103(* ------------------------------------------------------------------------- *) 4104 4105val RSUM_COMPONENT_LE = store_thm ("RSUM_COMPONENT_LE", 4106 ``!p a b f:real->real g:real->real. 4107 p tagged_division_of interval[a,b] /\ 4108 (!x. x IN interval[a,b] ==> (f x) <= (g x)) 4109 ==> sum p (\(x,k). content k * f x) <= 4110 sum p (\(x,k). content k * g x)``, 4111 REPEAT STRIP_TAC THEN MATCH_MP_TAC SUM_LE THEN 4112 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 4113 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 4114 REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 4115 UNDISCH_TAC `` p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 4116 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 4117 ASM_REWRITE_TAC [] THEN STRIP_TAC THEN POP_ASSUM MP_TAC THEN 4118 POP_ASSUM MP_TAC THEN 4119 POP_ASSUM (MP_TAC o Q.SPECL [`p_1:real`,`p_2:real->bool`]) THEN 4120 ASM_REWRITE_TAC [SUBSET_DEF] THEN REPEAT STRIP_TAC THEN 4121 ASM_REWRITE_TAC [] THEN Cases_on `content (interval [(a',b')]) = 0` THENL 4122 [ASM_REWRITE_TAC [] THEN REAL_ARITH_TAC, ALL_TAC] THEN 4123 MP_TAC(SPECL [``a':real``, ``b':real``] CONTENT_POS_LE) THEN 4124 GEN_REWR_TAC LAND_CONV [REAL_LE_LT] THEN 4125 GEN_REWR_TAC (LAND_CONV o RAND_CONV) [EQ_SYM_EQ] THEN ASM_REWRITE_TAC [] THEN 4126 DISCH_TAC THEN ASM_SIMP_TAC std_ss [REAL_LE_LMUL]); 4127 4128val HAS_INTEGRAL_COMPONENT_LE = store_thm ("HAS_INTEGRAL_COMPONENT_LE", 4129 ``!f:real->real g:real->real s i j. 4130 (f has_integral i) s /\ (g has_integral j) s /\ 4131 (!x. x IN s ==> (f x) <= (g x)) 4132 ==> i <= j``, 4133 SUBGOAL_THEN 4134 ``!f:real->real g:real->real a b i j. 4135 (f has_integral i) (interval[a,b]) /\ 4136 (g has_integral j) (interval[a,b]) /\ 4137 (!x. x IN interval[a,b] ==> (f x) <= (g x)) 4138 ==> i <= j`` 4139 ASSUME_TAC THENL 4140 [REPEAT STRIP_TAC THEN 4141 MATCH_MP_TAC(REAL_ARITH ``~(&0 < i - j) ==> i <= j:real``) THEN DISCH_TAC THEN 4142 UNDISCH_TAC ``((f :real -> real) has_integral (i :real)) 4143 (interval [((a :real),(b :real))])`` THEN DISCH_TAC THEN 4144 UNDISCH_TAC ``((g :real -> real) has_integral (j :real)) 4145 (interval [((a :real),(b :real))])`` THEN DISCH_TAC THEN 4146 FIRST_X_ASSUM(MP_TAC o SPEC ``((i:real) - (j:real)) / &3`` o 4147 REWRITE_RULE [has_integral]) THEN 4148 FIRST_X_ASSUM(MP_TAC o SPEC ``((i:real) - (j:real)) / &3`` o 4149 REWRITE_RULE [has_integral]) THEN 4150 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 4151 DISCH_THEN(X_CHOOSE_THEN ``d1:real->real->bool`` STRIP_ASSUME_TAC) THEN 4152 X_GEN_TAC ``d2:real->real->bool`` THEN CCONTR_TAC THEN FULL_SIMP_TAC std_ss [] THEN 4153 SUBGOAL_THEN ``?((p:real#(real->bool)->bool)). p tagged_division_of interval[a:real,b] /\ 4154 d1 FINE p /\ d2 FINE p`` 4155 STRIP_ASSUME_TAC THENL 4156 [SIMP_TAC std_ss [GSYM FINE_INTER] THEN MATCH_MP_TAC FINE_DIVISION_EXISTS THEN 4157 ASM_SIMP_TAC std_ss [GAUGE_INTER], ALL_TAC] THEN 4158 REPEAT 4159 (FIRST_X_ASSUM(MP_TAC o SPEC ``p:real#(real->bool)->bool``) THEN 4160 ASM_REWRITE_TAC[] THEN DISCH_THEN(MP_TAC o MATCH_MP REAL_LT_IMP_LE) THEN 4161 ASM_SIMP_TAC std_ss []) THEN 4162 SUBGOAL_THEN 4163 ``sum p (\(x,l:real->bool). content l * (f:real->real) x) <= 4164 sum p (\(x,l). content l * (g:real->real) x)`` 4165 MP_TAC THENL 4166 [MATCH_MP_TAC RSUM_COMPONENT_LE THEN METIS_TAC[], 4167 UNDISCH_TAC ``&0 < (i:real) - (j:real)`` THEN 4168 SPEC_TAC(``sum p (\(x:real,l:real->bool). 4169 content l * (f x):real)``, 4170 ``fs:real``) THEN 4171 SPEC_TAC(``sum p (\(x:real,l:real->bool). 4172 content l * (g x):real)``, 4173 ``gs:real``) THEN 4174 SIMP_TAC std_ss [REAL_LE_RDIV_EQ, REAL_ARITH ``0 < 3:real``] THEN 4175 REAL_ARITH_TAC], ALL_TAC] THEN 4176 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[has_integral_alt] THEN 4177 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THENL [ASM_MESON_TAC[], ALL_TAC] THEN 4178 STRIP_TAC THEN REWRITE_TAC[GSYM REAL_NOT_LT] THEN DISCH_TAC THEN 4179 UNDISCH_TAC ``!e. 0 < e ==> ?B. 0 < B /\ 4180 !a b. ball (0,B) SUBSET interval [(a,b)] ==> 4181 ?z. ((\x. if x IN s then g x else 0) has_integral z) 4182 (interval [(a,b)]) /\ abs (z - j) < e:real`` THEN 4183 UNDISCH_TAC ``!e. 0 < e ==> ?B. 0 < B /\ 4184 !a b. ball (0,B) SUBSET interval [(a,b)] ==> 4185 ?z. ((\x. if x IN s then f x else 0) has_integral z) 4186 (interval [(a,b)]) /\ abs (z - i) < e:real`` THEN 4187 DISCH_TAC THEN DISCH_TAC THEN 4188 UNDISCH_TAC ``!x:real. x IN s ==> f x <= (g x):real`` THEN 4189 REPEAT (FIRST_X_ASSUM(MP_TAC o SPEC ``((i:real) - (j:real)) / &2``)) THEN 4190 ASM_SIMP_TAC std_ss [REAL_HALF, REAL_SUB_LT] THEN 4191 DISCH_THEN(X_CHOOSE_THEN ``B1:real`` STRIP_ASSUME_TAC) THEN 4192 DISCH_THEN(X_CHOOSE_THEN ``B2:real`` STRIP_ASSUME_TAC) THEN 4193 CCONTR_TAC THEN FULL_SIMP_TAC std_ss [] THEN 4194 MP_TAC(ISPEC 4195 ``ball(0,B1) UNION ball(0:real,B2)`` 4196 BOUNDED_SUBSET_CLOSED_INTERVAL) THEN 4197 SIMP_TAC std_ss [BOUNDED_UNION, BOUNDED_BALL, UNION_SUBSET, NOT_EXISTS_THM] THEN 4198 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN REWRITE_TAC [GSYM DE_MORGAN_THM] THEN 4199 DISCH_THEN(CONJUNCTS_THEN(ANTE_RES_THEN MP_TAC)) THEN 4200 DISCH_THEN(X_CHOOSE_THEN ``w:real`` STRIP_ASSUME_TAC) THEN 4201 DISCH_THEN(X_CHOOSE_THEN ``z:real`` STRIP_ASSUME_TAC) THEN 4202 SUBGOAL_THEN ``(z:real) <= (w:real)`` MP_TAC THENL 4203 [FIRST_X_ASSUM MATCH_MP_TAC THEN 4204 MAP_EVERY EXISTS_TAC 4205 [``(\x. if x IN s then f x else 0):real->real``, 4206 ``(\x. if x IN s then g x else 0):real->real``, 4207 ``a:real``, ``b:real``] THEN 4208 METIS_TAC[REAL_LE_REFL], 4209 UNDISCH_TAC ``abs (z - i) < (i - j) / 2:real`` THEN 4210 UNDISCH_TAC ``abs (w - j) < (i - j) / 2:real`` THEN 4211 UNDISCH_TAC ``j < i:real`` THEN 4212 REWRITE_TAC [GSYM REAL_NOT_LE] THEN 4213 SIMP_TAC std_ss [REAL_LE_LDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 4214 REAL_ARITH_TAC]); 4215 4216val INTEGRAL_COMPONENT_LE = store_thm ("INTEGRAL_COMPONENT_LE", 4217 ``!f:real->real g:real->real s. 4218 f integrable_on s /\ g integrable_on s /\ 4219 (!x. x IN s ==> (f x) <= (g x)) 4220 ==> (integral s f) <= (integral s g)``, 4221 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_COMPONENT_LE THEN 4222 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]); 4223 4224val HAS_INTEGRAL_DROP_LE = store_thm ("HAS_INTEGRAL_DROP_LE", 4225 ``!f:real->real g:real->real s i j. 4226 (f has_integral i) s /\ (g has_integral j) s /\ 4227 (!x. x IN s ==> (f x) <= (g x)) 4228 ==> i <= j``, 4229 REWRITE_TAC[HAS_INTEGRAL_COMPONENT_LE]); 4230 4231val INTEGRAL_DROP_LE = store_thm ("INTEGRAL_DROP_LE", 4232 ``!f:real->real g:real->real s. 4233 f integrable_on s /\ g integrable_on s /\ 4234 (!x. x IN s ==> (f x) <= (g x)) 4235 ==> (integral s f) <= (integral s g)``, 4236 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_DROP_LE THEN 4237 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]); 4238 4239val HAS_INTEGRAL_COMPONENT_POS = store_thm ("HAS_INTEGRAL_COMPONENT_POS", 4240 ``!f:real->real s i. 4241 (f has_integral i) s /\ 4242 (!x. x IN s ==> &0 <= (f x)) 4243 ==> &0 <= i``, 4244 REPEAT STRIP_TAC THEN 4245 MP_TAC(ISPECL [``(\x. 0):real->real``, ``f:real->real``, 4246 ``s:real->bool``, ``0:real``, 4247 ``i:real``] HAS_INTEGRAL_COMPONENT_LE) THEN 4248 ASM_SIMP_TAC std_ss [HAS_INTEGRAL_0]); 4249 4250val INTEGRAL_COMPONENT_POS = store_thm ("INTEGRAL_COMPONENT_POS", 4251 ``!f:real->real s. 4252 f integrable_on s /\ 4253 (!x. x IN s ==> &0 <= (f x)) 4254 ==> &0 <= (integral s f)``, 4255 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_COMPONENT_POS THEN 4256 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]); 4257 4258val HAS_INTEGRAL_DROP_POS = store_thm ("HAS_INTEGRAL_DROP_POS", 4259 ``!f:real->real s i. 4260 (f has_integral i) s /\ 4261 (!x. x IN s ==> &0 <= (f x)) 4262 ==> &0 <= i``, 4263 REWRITE_TAC [HAS_INTEGRAL_COMPONENT_POS]); 4264 4265val INTEGRAL_DROP_POS = store_thm ("INTEGRAL_DROP_POS", 4266 ``!f:real->real s. 4267 f integrable_on s /\ 4268 (!x. x IN s ==> &0 <= (f x)) 4269 ==> &0 <= (integral s f)``, 4270 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_DROP_POS THEN 4271 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]); 4272 4273val HAS_INTEGRAL_COMPONENT_NEG = store_thm ("HAS_INTEGRAL_COMPONENT_NEG", 4274 ``!f:real->real s i. 4275 (f has_integral i) s /\ 4276 (!x. x IN s ==> (f x) <= &0) 4277 ==> i <= &0``, 4278 REPEAT STRIP_TAC THEN 4279 MP_TAC(ISPECL [``f:real->real``, ``(\x. 0):real->real``, 4280 ``s:real->bool``, ``i:real``, ``0:real``] 4281 HAS_INTEGRAL_COMPONENT_LE) THEN 4282 ASM_SIMP_TAC std_ss [HAS_INTEGRAL_0]); 4283 4284val HAS_INTEGRAL_DROP_NEG = store_thm ("HAS_INTEGRAL_DROP_NEG", 4285 ``!f:real->real s i. 4286 (f has_integral i) s /\ 4287 (!x. x IN s ==> (f x) <= &0) 4288 ==> i <= &0``, 4289 REWRITE_TAC [HAS_INTEGRAL_COMPONENT_NEG]); 4290 4291val HAS_INTEGRAL_COMPONENT_LBOUND = store_thm ("HAS_INTEGRAL_COMPONENT_LBOUND", 4292 ``!f:real->real a b i. 4293 (f has_integral i) (interval[a,b]) /\ 4294 (!x. x IN interval[a,b] ==> B <= f(x)) 4295 ==> B * content(interval[a,b]) <= i``, 4296 REPEAT STRIP_TAC THEN 4297 MP_TAC(ISPECL [``(\x. @f. f = B):real->real``, ``f:real->real``, 4298 ``interval[a:real,b]``, 4299 ``content(interval[a:real,b]) * (@f. f = B):real``, 4300 ``i:real``] HAS_INTEGRAL_COMPONENT_LE) THEN 4301 ASM_SIMP_TAC std_ss [HAS_INTEGRAL_CONST] THEN 4302 SIMP_TAC std_ss [REAL_MUL_ASSOC, REAL_MUL_SYM]); 4303 4304val HAS_INTEGRAL_COMPONENT_UBOUND = store_thm ("HAS_INTEGRAL_COMPONENT_UBOUND", 4305 ``!f:real->real a b i. 4306 (f has_integral i) (interval[a,b]) /\ 4307 (!x. x IN interval[a,b] ==> f(x) <= B) 4308 ==> i <= B * content(interval[a,b])``, 4309 REPEAT STRIP_TAC THEN 4310 MP_TAC(ISPECL [``f:real->real``, ``(\x. @f. f = B):real->real``, 4311 ``interval[a:real,b]``, ``i:real``, 4312 ``content(interval[a:real,b]) * (@f. f = B):real``] 4313 HAS_INTEGRAL_COMPONENT_LE) THEN 4314 ASM_SIMP_TAC std_ss [HAS_INTEGRAL_CONST] THEN 4315 SIMP_TAC std_ss [REAL_MUL_ASSOC, REAL_MUL_SYM]); 4316 4317val INTEGRAL_COMPONENT_LBOUND = store_thm ("INTEGRAL_COMPONENT_LBOUND", 4318 ``!f:real->real a b. 4319 f integrable_on interval[a,b] /\ 4320 (!x. x IN interval[a,b] ==> B <= f(x)) 4321 ==> B * content(interval[a,b]) <= (integral(interval[a,b]) f)``, 4322 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_COMPONENT_LBOUND THEN 4323 EXISTS_TAC ``f:real->real`` THEN 4324 ASM_REWRITE_TAC[GSYM HAS_INTEGRAL_INTEGRAL]); 4325 4326val INTEGRAL_COMPONENT_UBOUND = store_thm ("INTEGRAL_COMPONENT_UBOUND", 4327 ``!f:real->real a b. 4328 f integrable_on interval[a,b] /\ 4329 (!x. x IN interval[a,b] ==> f(x) <= B) 4330 ==> (integral(interval[a,b]) f) <= B * content(interval[a,b])``, 4331 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_COMPONENT_UBOUND THEN 4332 EXISTS_TAC ``f:real->real`` THEN 4333 ASM_REWRITE_TAC[GSYM HAS_INTEGRAL_INTEGRAL]); 4334 4335(* ------------------------------------------------------------------------- *) 4336(* Uniform limit of integrable functions is integrable. *) 4337(* ------------------------------------------------------------------------- *) 4338 4339val lemma = prove ( 4340 ``x:real <= abs(a + b) + c ==> x <= abs(a) + abs(b) + c``, 4341 MESON_TAC[REAL_ADD_ASSOC, REAL_ADD_SYM, ABS_TRIANGLE, REAL_LE_TRANS, REAL_LE_RADD]); 4342 4343val lemma12 = prove ( 4344 ``(abs(s2 - s1) <= e / &2:real /\ 4345 abs(s1 - i1) < e / &4:real /\ abs(s2 - i2) < e / &4:real 4346 ==> abs(i1 - i2) < e) /\ 4347 (abs(sf - sg) <= e / &3:real 4348 ==> abs(i - s) < e / &3:real ==> abs(sg - i) < e / &3:real ==> abs(sf - s) < e)``, 4349 CONJ_TAC THENL 4350 [REWRITE_TAC[CONJ_ASSOC] THEN 4351 GEN_REWR_TAC (LAND_CONV o LAND_CONV o ONCE_DEPTH_CONV) [ABS_SUB] THEN 4352 SIMP_TAC std_ss [REAL_LT_RDIV_EQ, REAL_LE_RDIV_EQ, 4353 REAL_ARITH ``0 < 2:real``, REAL_ARITH ``0 < 4:real``] THEN 4354 REAL_ARITH_TAC, 4355 SIMP_TAC std_ss [REAL_LT_RDIV_EQ, REAL_LE_RDIV_EQ, 4356 REAL_ARITH ``0 < 3:real``] THEN REAL_ARITH_TAC]); 4357 4358val lemma1 = prove ( 4359 ``(abs(s2 - s1) <= e / &2:real /\ 4360 abs(s1 - i1) < e / &4:real /\ abs(s2 - i2) < e / &4:real 4361 ==> abs(i1 - i2) < e)``, 4362 REWRITE_TAC [lemma12]); 4363 4364val lemma2 = prove ( 4365 ``(abs(sf - sg) <= e / &3:real 4366 ==> abs(i - s) < e / &3:real ==> abs(sg - i) < e / &3:real ==> abs(sf - s) < e)``, 4367 REWRITE_TAC [lemma12]); 4368 4369val ABS_TRIANGLE_LE = store_thm ("ABS_TRIANGLE_LE", 4370 ``!x y. abs(x) + abs(y) <= e ==> abs(x + y) <= e:real``, 4371 METIS_TAC[REAL_LE_TRANS, ABS_TRIANGLE]); 4372 4373val INTEGRABLE_UNIFORM_LIMIT = store_thm ("INTEGRABLE_UNIFORM_LIMIT", 4374 ``!f a b. (!e. &0 < e 4375 ==> ?g. (!x. x IN interval[a,b] ==> abs(f x - g x) <= e) /\ 4376 g integrable_on interval[a,b] ) 4377 ==> (f:real->real) integrable_on interval[a,b]``, 4378 REPEAT STRIP_TAC THEN 4379 ASM_CASES_TAC ``&0 < content(interval[a:real,b])`` THENL 4380 [ALL_TAC, 4381 ASM_MESON_TAC[HAS_INTEGRAL_NULL, CONTENT_LT_NZ, integrable_on]] THEN 4382 FIRST_X_ASSUM(MP_TAC o GEN ``n:num`` o SPEC ``inv(&n + &1:real)``) THEN 4383 SIMP_TAC std_ss [REAL_LT_INV_EQ, METIS 4384 [ADD1, LESS_0, REAL_OF_NUM_ADD, REAL_LT] ``&0 < &n + &1:real``] THEN 4385 SIMP_TAC std_ss [FORALL_AND_THM, SKOLEM_THM, integrable_on] THEN 4386 DISCH_THEN(X_CHOOSE_THEN ``g:num->real->real`` (CONJUNCTS_THEN2 4387 ASSUME_TAC (X_CHOOSE_TAC ``i:num->real``))) THEN 4388 SUBGOAL_THEN ``cauchy(i:num->real)`` MP_TAC THENL 4389 [REWRITE_TAC[cauchy] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 4390 MP_TAC(SPEC ``e / &4 / content(interval[a:real,b])`` 4391 REAL_ARCH_INV) THEN 4392 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 4393 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN 4394 EXISTS_TAC ``N:num`` THEN POP_ASSUM MP_TAC THEN STRIP_TAC THEN 4395 MAP_EVERY X_GEN_TAC [``m:num``, ``n:num``] THEN REWRITE_TAC[GE] THEN 4396 STRIP_TAC THEN 4397 UNDISCH_TAC ``!n:num. (g n has_integral i n) (interval [(a,b)])`` THEN 4398 DISCH_TAC THEN FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [has_integral]) THEN 4399 KNOW_TAC ``(!(e :real)(n :num). 4400 (0 :real) < e ==> 4401 ?(d :real -> real -> bool). 4402 (gauge d :bool) /\ 4403 !(p :real # (real -> bool) -> bool). 4404 p tagged_division_of interval [((a :real),(b :real))] /\ 4405 d FINE p ==> 4406 abs 4407 (sum p 4408 (\((x :real),(k :real -> bool)). 4409 content k * (g :num -> real -> real) n x) - 4410 (i :num -> real) n) < e) ==> 4411 (dist (i (m :num),i (n :num)) :real) < (e :real)`` THENL 4412 [ALL_TAC, METIS_TAC [SWAP_FORALL_THM]] THEN 4413 DISCH_THEN(MP_TAC o SPEC ``e / &4:real``) THEN 4414 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 4415 DISCH_THEN(fn th => MP_TAC(SPEC ``m:num`` th) THEN 4416 MP_TAC(SPEC ``n:num`` th)) THEN 4417 DISCH_THEN(X_CHOOSE_THEN ``gn:real->real->bool`` STRIP_ASSUME_TAC) THEN 4418 DISCH_THEN(X_CHOOSE_THEN ``gm:real->real->bool`` STRIP_ASSUME_TAC) THEN 4419 MP_TAC(ISPECL [``(\x. gm(x) INTER gn(x)):real->real->bool``, 4420 ``a:real``, ``b:real``] FINE_DIVISION_EXISTS) THEN 4421 ASM_SIMP_TAC std_ss [GAUGE_INTER, LEFT_IMP_EXISTS_THM] THEN 4422 X_GEN_TAC ``p:(real#(real->bool))->bool`` THEN STRIP_TAC THEN 4423 REPEAT(FIRST_X_ASSUM(MP_TAC o SPEC ``p:(real#(real->bool))->bool``)) THEN 4424 FIRST_ASSUM(fn th => REWRITE_TAC[CONV_RULE(REWR_CONV FINE_INTER) th]) THEN 4425 SUBGOAL_THEN ``abs(sum p (\(x,k:real->bool). content k * g (n:num) x) - 4426 sum p (\(x:real,k). content k * g m x :real)) 4427 <= e / &2:real`` MP_TAC THENL 4428 [ALL_TAC, ASM_REWRITE_TAC[dist] THEN MESON_TAC[lemma1]] THEN 4429 MATCH_MP_TAC REAL_LE_TRANS THEN 4430 EXISTS_TAC ``&2 / &N * content(interval[a:real,b])`` THEN CONJ_TAC THENL 4431 [MATCH_MP_TAC RSUM_DIFF_BOUND, 4432 ASM_SIMP_TAC std_ss [GSYM REAL_LE_RDIV_EQ] THEN 4433 KNOW_TAC ``0 < &N:real`` THENL 4434 [METIS_TAC [REAL_LT, ZERO_LESS_EQ, LESS_OR_EQ], DISCH_TAC] THEN 4435 GEN_REWR_TAC RAND_CONV [GSYM REAL_HALF] THEN 4436 REWRITE_TAC [real_div] THEN 4437 REWRITE_TAC [REAL_ARITH ``a * b * c * d = a * (b * d) * c:real``] THEN 4438 SIMP_TAC std_ss [GSYM REAL_INV_MUL, REAL_ARITH ``0 <> 2:real``] THEN 4439 REWRITE_TAC [REAL_ARITH ``2 * 2 = 4:real``] THEN REWRITE_TAC [GSYM real_div] THEN 4440 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``inv (&N) + inv (&N:real)`` THEN 4441 CONJ_TAC THENL [SIMP_TAC std_ss [REAL_DOUBLE, GSYM real_div, REAL_LE_REFL], 4442 MATCH_MP_TAC REAL_LE_ADD2 THEN ASM_REWRITE_TAC [REAL_LE_LT]]] THEN 4443 ASM_REWRITE_TAC[] THEN REPEAT STRIP_TAC THEN 4444 FIRST_X_ASSUM(fn th => MP_TAC(SPECL [``n:num``, ``x:real``] th) THEN 4445 MP_TAC(SPECL [``m:num``, ``x:real``] th)) THEN 4446 ASM_REWRITE_TAC[AND_IMP_INTRO] THEN 4447 GEN_REWR_TAC (LAND_CONV o RAND_CONV o LAND_CONV) [ABS_SUB] THEN 4448 DISCH_THEN(MP_TAC o MATCH_MP REAL_LE_ADD2) THEN 4449 DISCH_THEN(MP_TAC o MATCH_MP ABS_TRIANGLE_LE) THEN 4450 KNOW_TAC ``!u v a b x. (u = v) /\ a <= inv(x) /\ b <= inv(x) ==> 4451 u <= a + b ==> v <= &2 / x:real`` THENL 4452 [REPEAT GEN_TAC THEN STRIP_TAC THEN DISCH_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN 4453 EXISTS_TAC ``a' + b':real`` THEN UNDISCH_TAC ``u = v:real`` THEN 4454 GEN_REWR_TAC LAND_CONV [EQ_SYM_EQ] THEN DISCH_TAC THEN 4455 ASM_SIMP_TAC std_ss [EQ_SYM_EQ, real_div, GSYM REAL_DOUBLE] THEN 4456 MATCH_MP_TAC REAL_LE_ADD2 THEN ASM_SIMP_TAC std_ss [], 4457 DISCH_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC] THEN 4458 CONJ_TAC THENL [AP_TERM_TAC THEN REAL_ARITH_TAC, ALL_TAC] THEN 4459 CONJ_TAC THEN MATCH_MP_TAC REAL_LE_INV2 THEN 4460 ASM_SIMP_TAC arith_ss [REAL_OF_NUM_ADD, REAL_OF_NUM_LE, REAL_LT], 4461 ALL_TAC] THEN 4462 REWRITE_TAC[GSYM CONVERGENT_EQ_CAUCHY] THEN 4463 DISCH_THEN (X_CHOOSE_TAC ``s:real``) THEN EXISTS_TAC ``s:real`` THEN 4464 REWRITE_TAC[has_integral] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 4465 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &3:real`` o REWRITE_RULE [LIM_SEQUENTIALLY]) THEN 4466 ASM_SIMP_TAC arith_ss [dist, REAL_LT_DIV, REAL_LT] THEN 4467 DISCH_THEN(X_CHOOSE_TAC ``N1:num``) THEN 4468 MP_TAC(SPEC ``e / &3 / content(interval[a:real,b])`` REAL_ARCH_INV) THEN 4469 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 4470 DISCH_THEN(X_CHOOSE_THEN ``N2:num`` STRIP_ASSUME_TAC) THEN 4471 UNDISCH_TAC ``!n:num. (g n has_integral i n) (interval [(a,b)])`` THEN 4472 DISCH_TAC THEN FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [has_integral]) THEN 4473 DISCH_THEN(MP_TAC o SPECL [``N1 + N2:num``, ``e / &3:real``]) THEN 4474 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 4475 DISCH_THEN (X_CHOOSE_TAC ``g:real->real->bool``) THEN 4476 EXISTS_TAC ``g:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 4477 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 4478 X_GEN_TAC ``p:real#(real->bool)->bool`` THEN STRIP_TAC THEN 4479 FIRST_X_ASSUM(MP_TAC o SPEC ``p:real#(real->bool)->bool``) THEN 4480 ASM_REWRITE_TAC[] THEN 4481 FIRST_X_ASSUM(MP_TAC o C MATCH_MP (ARITH_PROVE ``N1:num <= N1 + N2``)) THEN 4482 MATCH_MP_TAC lemma2 THEN MATCH_MP_TAC REAL_LE_TRANS THEN 4483 EXISTS_TAC ``inv(&(N1 + N2) + &1) * content(interval[a:real,b])`` THEN 4484 CONJ_TAC THENL 4485 [MATCH_MP_TAC RSUM_DIFF_BOUND THEN ASM_REWRITE_TAC[], ALL_TAC] THEN 4486 ASM_SIMP_TAC std_ss [GSYM REAL_LE_RDIV_EQ] THEN 4487 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 4488 ``x < a ==> y <= x ==> y <= a:real``)) THEN 4489 MATCH_MP_TAC REAL_LE_INV2 THEN 4490 ASM_SIMP_TAC arith_ss [REAL_OF_NUM_ADD, REAL_OF_NUM_LE, REAL_LT]); 4491 4492(* ------------------------------------------------------------------------- *) 4493(* Negligible sets. *) 4494(* ------------------------------------------------------------------------- *) 4495 4496val indicator = new_definition ("indicator", 4497 ``indicator s :real->real = \x. if x IN s then 1 else 0``); 4498 4499val DROP_INDICATOR = store_thm ("DROP_INDICATOR", 4500 ``!s x. (indicator s x) = if x IN s then &1 else &0``, 4501 SIMP_TAC std_ss [indicator]); 4502 4503Theorem DROP_INDICATOR_POS_LE : 4504 !s x. &0 <= (indicator s x) 4505Proof 4506 RW_TAC real_ss [DROP_INDICATOR] 4507QED 4508 4509Theorem DROP_INDICATOR_LE_1 : 4510 !s x. (indicator s x) <= &1 4511Proof 4512 RW_TAC real_ss [DROP_INDICATOR] 4513QED 4514 4515Theorem DROP_INDICATOR_ABS_LE_1 : 4516 !s x. abs(indicator s x) <= &1 4517Proof 4518 RW_TAC real_ss [DROP_INDICATOR] 4519QED 4520 4521Theorem INDICATOR_EMPTY : 4522 indicator {} = (\x. 0) 4523Proof 4524 SET_TAC [indicator] 4525QED 4526 4527val negligible = new_definition ("negligible", 4528 ``negligible s <=> !a b. (indicator s has_integral (0)) (interval[a,b])``); 4529 4530(* ------------------------------------------------------------------------- *) 4531(* Negligibility of hyperplane. *) 4532(* ------------------------------------------------------------------------- *) 4533 4534val SUM_NONZERO_IMAGE_LEMMA = store_thm ("SUM_NONZERO_IMAGE_LEMMA", 4535 ``!s f:'a->'b g:'b->real a. 4536 FINITE s /\ (g(a) = 0) /\ 4537 (!x y. x IN s /\ y IN s /\ (f x = f y) /\ ~(x = y) ==> (g(f x) = 0)) 4538 ==> (sum {f x | x | x IN s /\ ~(f x = a)} g = 4539 sum s (g o f))``, 4540 REPEAT STRIP_TAC THEN 4541 SUBGOAL_THEN ``FINITE {(f:'a->'b) x |x| x IN s /\ ~(f x = a)}`` 4542 ASSUME_TAC THENL 4543 [MATCH_MP_TAC FINITE_SUBSET THEN EXISTS_TAC ``IMAGE (f:'a->'b) s`` THEN 4544 ASM_SIMP_TAC std_ss [IMAGE_FINITE, SUBSET_DEF, IN_IMAGE, GSPECIFICATION] THEN MESON_TAC[], 4545 ASM_SIMP_TAC std_ss [sum_def] THEN MATCH_MP_TAC ITERATE_NONZERO_IMAGE_LEMMA THEN 4546 ASM_REWRITE_TAC[NEUTRAL_REAL_ADD, MONOIDAL_REAL_ADD]]); 4547 4548Theorem INTERVAL_DOUBLESPLIT : 4549 !e a b c. interval[a,b] INTER {x:real | abs(x - c) <= e} = 4550 interval[(max (a) (c - e)), (min (b) (c + e))] 4551Proof 4552 REWRITE_TAC[REAL_ARITH ``abs(x - c) <= e <=> x >= c - e /\ x <= c + e:real``] THEN 4553 ONCE_REWRITE_TAC [METIS [] ``x >= c - e <=> (\x. x >= c - e:real) x``] THEN 4554 ONCE_REWRITE_TAC [METIS [] ``x <= c + e <=> (\x. x <= c + e:real) x``] THEN 4555 REWRITE_TAC[SET_RULE ``s INTER {x | P x /\ Q x} = 4556 (s INTER {x | Q x}) INTER {x | P x}``] THEN 4557 SIMP_TAC std_ss [INTERVAL_SPLIT] 4558QED 4559 4560val DIVISION_DOUBLESPLIT = store_thm ("DIVISION_DOUBLESPLIT", 4561 ``!p a b:real c e. 4562 p division_of interval[a,b] 4563 ==> {l INTER {x | abs(x - c) <= e} |l| 4564 l IN p /\ ~(l INTER {x | abs(x - c) <= e} = {})} 4565 division_of (interval[a,b] INTER {x | abs(x - c) <= e})``, 4566 REPEAT GEN_TAC THEN DISCH_TAC THEN 4567 FIRST_ASSUM(MP_TAC o SPEC ``c + e:real`` o MATCH_MP DIVISION_SPLIT) THEN 4568 DISCH_THEN(MP_TAC o CONJUNCT1) THEN 4569 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 4570 FIRST_ASSUM MP_TAC THEN REWRITE_TAC[AND_IMP_INTRO] THEN 4571 DISCH_THEN(MP_TAC o MATCH_MP (TAUT 4572 `(a) /\ d ==> d`)) THEN 4573 DISCH_THEN(MP_TAC o CONJUNCT2 o SPEC ``c - e:real`` o 4574 MATCH_MP DIVISION_SPLIT) THEN 4575 ASM_SIMP_TAC std_ss [INTERVAL_DOUBLESPLIT, INTERVAL_SPLIT] THEN 4576 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_TERM_TAC THEN 4577 REWRITE_TAC[REAL_ARITH ``abs(x - c) <= e <=> x >= c - e /\ x <= c + e:real``] THEN 4578 GEN_REWR_TAC I [EXTENSION] THEN SIMP_TAC std_ss [IN_INTER, GSPECIFICATION] THEN 4579 GEN_TAC THEN ONCE_REWRITE_TAC [CONJ_SYM] THEN SIMP_TAC std_ss [GSYM LEFT_EXISTS_AND_THM] THEN 4580 ONCE_REWRITE_TAC[SWAP_EXISTS_THM] THEN REWRITE_TAC[GSYM CONJ_ASSOC] THEN 4581 ONCE_REWRITE_TAC[TAUT `a /\ b /\ c /\ d <=> c /\ a /\ b /\ d`] THEN 4582 SIMP_TAC std_ss [UNWIND_THM2] THEN AP_TERM_TAC THEN ABS_TAC THEN SET_TAC[]); 4583 4584Theorem CONTENT_DOUBLESPLIT : 4585 !a b:real c e. 4586 &0 < e ==> ?d. &0 < d /\ 4587 content(interval[a,b] INTER {x | abs(x - c) <= d}) < e 4588Proof 4589 REPEAT STRIP_TAC THEN 4590 ASM_CASES_TAC ``content(interval[a:real,b]) = &0`` THENL 4591 [EXISTS_TAC ``&1:real`` THEN REWRITE_TAC[REAL_LT_01] THEN 4592 MATCH_MP_TAC REAL_LET_TRANS THEN 4593 EXISTS_TAC ``content(interval[a:real,b])`` THEN 4594 CONJ_TAC THENL [FIRST_X_ASSUM(K ALL_TAC o SYM), ASM_SIMP_TAC std_ss []] THEN 4595 ASM_SIMP_TAC std_ss [INTERVAL_DOUBLESPLIT] THEN MATCH_MP_TAC CONTENT_SUBSET THEN 4596 ASM_SIMP_TAC std_ss [GSYM INTERVAL_DOUBLESPLIT] THEN SET_TAC[], ALL_TAC] THEN 4597 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [CONTENT_EQ_0]) THEN 4598 REWRITE_TAC[REAL_NOT_LE] THEN DISCH_TAC THEN 4599 SUBGOAL_THEN ``&0 < (b:real) - (a:real)`` ASSUME_TAC THENL 4600 [ASM_REAL_ARITH_TAC, ALL_TAC] THEN 4601 ABBREV_TAC ``d = e / &3:real`` THEN 4602 EXISTS_TAC ``d:real`` THEN SUBGOAL_THEN ``&0 < d:real`` ASSUME_TAC THENL 4603 [EXPAND_TAC "d" THEN 4604 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT], 4605 ALL_TAC] THEN 4606 ASM_SIMP_TAC std_ss [content, INTERVAL_DOUBLESPLIT] THEN 4607 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN 4608 FIRST_X_ASSUM(ASSUME_TAC o REWRITE_RULE [INTERVAL_NE_EMPTY]) THEN 4609 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, REAL_LT_IMP_LE] THEN 4610 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC ``&2 * d:real`` THEN 4611 reverse CONJ_TAC 4612 >- (MATCH_MP_TAC(REAL_ARITH ``&0 < d /\ &3 * d <= x ==> &2 * d < x:real``) THEN 4613 ASM_REWRITE_TAC[] THEN 4614 FULL_SIMP_TAC std_ss [REAL_EQ_LDIV_EQ, REAL_ARITH ``0 < 3:real``] THEN 4615 REAL_ARITH_TAC) THEN 4616 fs [min_def, max_def] THEN 4617 Cases_on `a <= c - d` >> Cases_on `b <= c + d` >> fs [] THEN 4618 REAL_ASM_ARITH_TAC 4619QED 4620 4621val NEGLIGIBLE_STANDARD_HYPERPLANE = store_thm ("NEGLIGIBLE_STANDARD_HYPERPLANE", 4622 ``!c. negligible {x:real | x = c}``, 4623 REPEAT STRIP_TAC THEN REWRITE_TAC[negligible, has_integral] THEN 4624 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_SUB_RZERO] THEN 4625 MP_TAC(ISPECL [``a:real``, ``b:real``, ``c:real``, ``e:real``] 4626 CONTENT_DOUBLESPLIT) THEN 4627 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN 4628 EXISTS_TAC ``\x:real. ball(x,d)`` THEN ASM_SIMP_TAC std_ss [GAUGE_BALL] THEN 4629 ABBREV_TAC ``i = indicator {x:real | x = c}`` THEN REPEAT STRIP_TAC THEN 4630 SUBGOAL_THEN 4631 ``sum p (\(x,l). content l * i x) = 4632 sum p (\(x,l). content(l INTER {x:real | abs(x - c) <= d}) * 4633 (i:real->real) x)`` SUBST1_TAC THENL 4634 4635 [MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [FORALL_PROD] THEN 4636 MAP_EVERY X_GEN_TAC [``x:real``, ``l:real->bool``] THEN 4637 DISCH_TAC THEN EXPAND_TAC "i" THEN REWRITE_TAC[indicator] THEN 4638 SIMP_TAC std_ss [GSPECIFICATION] THEN 4639 COND_CASES_TAC THEN ASM_REWRITE_TAC[REAL_MUL_RZERO] THEN 4640 AP_THM_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN 4641 UNDISCH_TAC ``(\x. ball (x,d)) FINE p`` THEN DISCH_TAC THEN 4642 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 4643 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``l:real->bool``]) THEN 4644 ASM_REWRITE_TAC[] THEN 4645 MATCH_MP_TAC(SET_RULE ``s SUBSET t ==> l SUBSET s ==> (l = l INTER t)``) THEN 4646 SIMP_TAC std_ss [SUBSET_DEF, IN_BALL, GSPECIFICATION, dist] THEN 4647 UNDISCH_THEN ``(x:real) = c`` (SUBST1_TAC o SYM) THEN 4648 GEN_REWR_TAC (QUANT_CONV o LAND_CONV o LAND_CONV) [ABS_SUB] THEN 4649 METIS_TAC[REAL_LE_TRANS, REAL_LT_IMP_LE], ALL_TAC] THEN 4650 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC 4651 ``abs(sum p (\(x:real,l). 4652 content(l INTER {x:real | abs(x - c) <= d}) * 1:real))`` THEN 4653 CONJ_TAC THENL 4654 [UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 4655 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 4656 MATCH_MP_TAC(REAL_ARITH ``&0:real <= x /\ x <= y ==> abs(x) <= abs(y)``) THEN 4657 CONJ_TAC THENL [MATCH_MP_TAC SUM_POS_LE, MATCH_MP_TAC SUM_LE] THEN 4658 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 4659 MAP_EVERY X_GEN_TAC [``x:real``, ``l:real->bool``] THEN STRIP_TAC THENL 4660 [MATCH_MP_TAC REAL_LE_MUL, MATCH_MP_TAC REAL_LE_LMUL1] THEN 4661 EXPAND_TAC "i" THEN 4662 SIMP_TAC std_ss [DROP_INDICATOR_POS_LE, DROP_INDICATOR_LE_1] THEN 4663 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 4664 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 4665 ASM_REWRITE_TAC [] THEN 4666 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``l:real->bool``] o 4667 el 1 o CONJUNCTS) THEN 4668 ASM_REWRITE_TAC[] THEN 4669 STRIP_TAC THEN ASM_SIMP_TAC std_ss [INTERVAL_DOUBLESPLIT, CONTENT_POS_LE], 4670 ALL_TAC] THEN 4671 MP_TAC(ISPECL [``(\l. content (l INTER {x | abs (x - c) <= d}) * 1): 4672 (real->bool)->real``, 4673 ``p:real#(real->bool)->bool``, 4674 ``interval[a:real,b]``] 4675 SUM_OVER_TAGGED_DIVISION_LEMMA) THEN 4676 ASM_REWRITE_TAC[] THEN KNOW_TAC ``(!u v. 4677 interval [(u,v)] <> {} /\ (content (interval [(u,v)]) = 0) ==> 4678 ((\l. content (l INTER {x | abs (x - c) <= d}) * 1) 4679 (interval [(u,v)]) = 0))`` THENL 4680 [MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN STRIP_TAC THEN 4681 SIMP_TAC std_ss [REAL_ENTIRE] THEN DISJ1_TAC THEN 4682 MATCH_MP_TAC(REAL_ARITH ``!x. (x = &0) /\ &0 <= y /\ y <= x ==> (y = &0:real)``) THEN 4683 EXISTS_TAC ``content(interval[u:real,v])`` THEN 4684 CONJ_TAC THEN POP_ASSUM MP_TAC THEN REWRITE_TAC[] THEN 4685 DISCH_THEN(K ALL_TAC) THEN 4686 ASM_SIMP_TAC std_ss [CONTENT_POS_LE, INTERVAL_DOUBLESPLIT] THEN 4687 MATCH_MP_TAC CONTENT_SUBSET THEN 4688 ASM_SIMP_TAC std_ss [GSYM INTERVAL_DOUBLESPLIT] THEN SET_TAC[], 4689 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 4690 SIMP_TAC std_ss [] THEN DISCH_THEN SUBST1_TAC THEN 4691 MP_TAC(ISPECL 4692 [``IMAGE SND (p:real#(real->bool)->bool)``, 4693 ``\l. l INTER {x:real | abs (x - c) <= d}``, 4694 ``\l:real->bool. content l * 1 :real``, 4695 ``{}:real->bool``] SUM_NONZERO_IMAGE_LEMMA) THEN 4696 SIMP_TAC std_ss [o_DEF] THEN 4697 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_TAGGED_DIVISION) THEN 4698 KNOW_TAC ``FINITE 4699 (IMAGE (SND :real # (real -> bool) -> real -> bool) 4700 (p :real # (real -> bool) -> bool)) /\ 4701 (content ({} :real -> bool) * (1 :real) = (0 :real)) /\ 4702 (!(x :real -> bool) (y :real -> bool). 4703 x IN IMAGE (SND :real # (real -> bool) -> real -> bool) p /\ 4704 y IN IMAGE (SND :real # (real -> bool) -> real -> bool) p /\ 4705 (x INTER {x | abs (x - (c :real)) <= (d :real)} = 4706 y INTER {x | abs (x - c) <= d}) /\ x <> y ==> 4707 (content (y INTER {x | abs (x - c) <= d}) * (1 :real) = 4708 (0 : real)))`` THENL 4709 [CONJ_TAC THENL [ASM_MESON_TAC[DIVISION_OF_FINITE], ALL_TAC] THEN 4710 REWRITE_TAC[CONTENT_EMPTY, REAL_MUL_LZERO] THEN 4711 ONCE_REWRITE_TAC[IMP_CONJ] THEN 4712 SIMP_TAC std_ss [RIGHT_FORALL_IMP_THM] THEN 4713 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 4714 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN DISCH_TAC THEN 4715 X_GEN_TAC ``m:real->bool`` THEN STRIP_TAC THEN 4716 REWRITE_TAC[REAL_ENTIRE] THEN DISJ1_TAC THEN 4717 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 4718 GEN_REWR_TAC LAND_CONV [EQ_SYM_EQ] THEN DISCH_TAC THEN DISCH_TAC THEN 4719 ASM_REWRITE_TAC [] THEN 4720 SIMP_TAC std_ss [INTERVAL_DOUBLESPLIT] THEN 4721 SIMP_TAC std_ss [CONTENT_EQ_0_INTERIOR] THEN 4722 ASM_SIMP_TAC std_ss [GSYM INTERVAL_DOUBLESPLIT] THEN 4723 UNDISCH_TAC `` IMAGE (SND :real # (real -> bool) -> real -> bool) 4724 (p :real # (real -> bool) -> bool) division_of 4725 interval [((a :real),(b :real))]`` THEN DISCH_TAC THEN 4726 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 4727 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 4728 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 4729 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 4730 DISCH_THEN (MP_TAC o SPECL [``interval[u:real,v]``, ``m:real->bool``]) THEN 4731 ASM_REWRITE_TAC[] THEN 4732 UNDISCH_TAC `` (m :real -> bool) INTER {x | abs (x - (c :real)) <= (d :real)} = 4733 interval [((u :real),(v :real))] INTER {x | abs (x - c) <= d}`` THEN 4734 GEN_REWR_TAC LAND_CONV [EQ_SYM_EQ] THEN DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 4735 MATCH_MP_TAC(SET_RULE 4736 ``u SUBSET s /\ u SUBSET t ==> (s INTER t = {}) ==> (u = {})``) THEN 4737 CONJ_TAC THEN MATCH_MP_TAC SUBSET_INTERIOR THEN ASM_SET_TAC[], 4738 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 4739 SIMP_TAC std_ss [o_DEF] THEN DISCH_THEN(SUBST1_TAC o SYM) THEN 4740 MATCH_MP_TAC REAL_LET_TRANS THEN 4741 EXISTS_TAC 4742 ``&1 * content(interval[a,b] INTER {x:real | abs (x - c) <= d})`` THEN 4743 CONJ_TAC THENL [ALL_TAC, ASM_REWRITE_TAC[REAL_MUL_LID]] THEN 4744 FIRST_ASSUM(MP_TAC o MATCH_MP(REWRITE_RULE[IMP_CONJ] 4745 DIVISION_DOUBLESPLIT)) THEN 4746 DISCH_THEN(MP_TAC o SPECL [``c:real``, ``d:real``]) THEN 4747 ASM_SIMP_TAC std_ss [INTERVAL_DOUBLESPLIT] THEN DISCH_TAC THEN 4748 MATCH_MP_TAC DSUM_BOUND THEN 4749 ASM_SIMP_TAC std_ss [LESS_EQ_REFL] THEN 4750 REAL_ARITH_TAC); 4751 4752(* ------------------------------------------------------------------------- *) 4753(* A technical lemma about "refinement" of division. *) 4754(* ------------------------------------------------------------------------- *) 4755 4756val lemma1 = prove ( 4757 ``{k | ?x. (x,k) IN p} = IMAGE SND p``, 4758 SIMP_TAC std_ss [EXTENSION, EXISTS_PROD, IN_IMAGE, GSPECIFICATION] THEN 4759 METIS_TAC[]); 4760 4761val TAGGED_DIVISION_FINER = store_thm ("TAGGED_DIVISION_FINER", 4762 ``!p a b:real d. p tagged_division_of interval[a,b] /\ gauge d 4763 ==> ?q. q tagged_division_of interval[a,b] /\ d FINE q /\ 4764 !x k. (x,k) IN p /\ k SUBSET d(x) ==> (x,k) IN q``, 4765 SUBGOAL_THEN 4766 ``!a b:real d p. 4767 FINITE p 4768 ==> p tagged_partial_division_of interval[a,b] /\ gauge d 4769 ==> ?q. q tagged_division_of (BIGUNION {k | ?x. (x,k) IN p}) /\ 4770 d FINE q /\ 4771 !x k. (x,k) IN p /\ k SUBSET d(x) ==> (x,k) IN q`` 4772 ASSUME_TAC THENL 4773 [ALL_TAC, 4774 REPEAT GEN_TAC THEN DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 4775 GEN_REWR_TAC LAND_CONV [tagged_division_of] THEN 4776 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (SUBST1_TAC o SYM)) THEN 4777 FIRST_ASSUM(MATCH_MP_TAC o REWRITE_RULE [AND_IMP_INTRO]) THEN 4778 ASM_MESON_TAC[tagged_partial_division_of]] THEN 4779 GEN_TAC THEN GEN_TAC THEN GEN_TAC THEN 4780 ONCE_REWRITE_TAC [ METIS [] 4781 ``!p. (p tagged_partial_division_of interval [(a,b)] /\ gauge d ==> 4782 ?q. q tagged_division_of BIGUNION {k | ?x. (x,k) IN p} /\ d FINE q /\ 4783 !x k. (x,k) IN p /\ k SUBSET d x ==> (x,k) IN q) = 4784 (\p. ( p tagged_partial_division_of interval [(a,b)] /\ gauge d ==> 4785 ?q. q tagged_division_of BIGUNION {k | ?x. (x,k) IN p} /\ d FINE q /\ 4786 !x k. (x,k) IN p /\ k SUBSET d x ==> (x,k) IN q)) p ``] THEN 4787 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN CONJ_TAC THENL 4788 [DISCH_THEN(K ALL_TAC) THEN 4789 REWRITE_TAC[SET_RULE ``BIGUNION {k | ?x. (x,k) IN {}} = {}``] THEN 4790 EXISTS_TAC ``{}:real#(real->bool)->bool`` THEN 4791 REWRITE_TAC[FINE, NOT_IN_EMPTY, TAGGED_DIVISION_OF_EMPTY], 4792 ALL_TAC] THEN 4793 SIMP_TAC std_ss [RIGHT_IMP_FORALL_THM] THEN 4794 SIMP_TAC std_ss [FORALL_PROD] THEN MAP_EVERY X_GEN_TAC 4795 [``p:real#(real->bool)->bool``, ``x:real``, ``k:real->bool``] THEN 4796 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 4797 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 4798 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 4799 KNOW_TAC ``p tagged_partial_division_of interval [(a,b)] /\ gauge d`` THENL 4800 [ASM_REWRITE_TAC[] THEN MATCH_MP_TAC TAGGED_PARTIAL_DIVISION_SUBSET THEN 4801 EXISTS_TAC ``(x:real,k:real->bool) INSERT p`` THEN ASM_SET_TAC[], 4802 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 4803 DISCH_THEN(X_CHOOSE_THEN ``q1:real#(real->bool)->bool`` 4804 STRIP_ASSUME_TAC) THEN 4805 SUBGOAL_THEN 4806 ``BIGUNION {l:real->bool | ?y:real. (y,l) IN (x,k) INSERT p} = 4807 k UNION BIGUNION {l | ?y. (y,l) IN p}`` 4808 SUBST1_TAC THENL 4809 [GEN_REWR_TAC I [EXTENSION] THEN REWRITE_TAC[IN_UNION, IN_BIGUNION] THEN 4810 SIMP_TAC std_ss [GSPECIFICATION, IN_INSERT, PAIR_EQ] THEN MESON_TAC[], 4811 ALL_TAC] THEN 4812 SUBGOAL_THEN ``?u v:real. k = interval[u,v]`` MP_TAC THENL 4813 [ASM_MESON_TAC[IN_INSERT, tagged_partial_division_of], ALL_TAC] THEN 4814 DISCH_THEN(REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) THEN 4815 ASM_CASES_TAC ``interval[u,v] SUBSET ((d:real->real->bool) x)`` THENL 4816 [EXISTS_TAC ``{(x:real,interval[u:real,v])} UNION q1`` THEN CONJ_TAC THENL 4817 [MATCH_MP_TAC TAGGED_DIVISION_UNION THEN ASM_SIMP_TAC std_ss [] THEN 4818 CONJ_TAC THENL 4819 [MATCH_MP_TAC TAGGED_DIVISION_OF_SELF THEN 4820 UNDISCH_TAC `` (x,interval [(u,v)]) INSERT p tagged_partial_division_of 4821 interval [(a,b)]`` THEN DISCH_TAC THEN 4822 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE 4823 [tagged_partial_division_of]) THEN 4824 SIMP_TAC std_ss [IN_INSERT, PAIR_EQ] THEN METIS_TAC[], 4825 ALL_TAC], 4826 CONJ_TAC THENL 4827 [MATCH_MP_TAC FINE_UNION THEN ASM_REWRITE_TAC[] THEN 4828 SIMP_TAC std_ss [FINE, IN_SING, PAIR_EQ] THEN METIS_TAC[], 4829 ALL_TAC] THEN 4830 ASM_SIMP_TAC std_ss [IN_INSERT, PAIR_EQ, IN_UNION, IN_SING] THEN 4831 METIS_TAC[]], 4832 FIRST_ASSUM(MP_TAC o SPECL [``u:real``, ``v:real``] o MATCH_MP 4833 FINE_DIVISION_EXISTS) THEN 4834 DISCH_THEN(X_CHOOSE_THEN ``q2:real#(real->bool)->bool`` 4835 STRIP_ASSUME_TAC) THEN 4836 EXISTS_TAC ``q2 UNION q1:real#(real->bool)->bool`` THEN CONJ_TAC THENL 4837 [MATCH_MP_TAC TAGGED_DIVISION_UNION THEN ASM_REWRITE_TAC[], 4838 ASM_SIMP_TAC std_ss [FINE_UNION] THEN 4839 ASM_SIMP_TAC std_ss [IN_INSERT, PAIR_EQ, IN_UNION, IN_SING] THEN 4840 METIS_TAC[]]] THEN 4841 (MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 4842 SIMP_TAC std_ss [lemma1, GSPECIFICATION, LEFT_IMP_EXISTS_THM] THEN 4843 UNDISCH_TAC ``(x,interval [(u,v)]) INSERT p tagged_partial_division_of 4844 interval [(a,b)]`` THEN DISCH_TAC THEN 4845 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE 4846 [tagged_partial_division_of]) THEN 4847 SIMP_TAC std_ss [IN_INSERT, FINITE_INSERT, PAIR_EQ] THEN 4848 STRIP_TAC THEN ASM_SIMP_TAC std_ss [IMAGE_FINITE] THEN CONJ_TAC THENL 4849 [SIMP_TAC std_ss [INTERIOR_CLOSED_INTERVAL, OPEN_INTERVAL], ALL_TAC] THEN 4850 CONJ_TAC THENL [ASM_MESON_TAC[], ALL_TAC] THEN 4851 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 4852 ASM_MESON_TAC[])); 4853 4854(* ------------------------------------------------------------------------- *) 4855(* Hence the main theorem about negligible sets. *) 4856(* ------------------------------------------------------------------------- *) 4857 4858val lemma = prove ( 4859 ``!f:'b->real g:'a#'b->real s t. 4860 FINITE s /\ FINITE t /\ 4861 (!x y. (x,y) IN t ==> &0 <= g(x,y)) /\ 4862 (!y. y IN s ==> ?x. (x,y) IN t /\ f(y) <= g(x,y)) 4863 ==> sum s f <= sum t g``, 4864 REPEAT STRIP_TAC THEN MATCH_MP_TAC SUM_LE_INCLUDED THEN 4865 EXISTS_TAC ``SND:'a#'b->'b`` THEN 4866 SIMP_TAC std_ss [EXISTS_PROD, FORALL_PROD] THEN 4867 ASM_MESON_TAC[]); 4868 4869val REAL_MUL_POS_LT = store_thm ("REAL_MUL_POS_LT", 4870 ``!x y:real. &0 < x * y <=> &0 < x /\ &0 < y \/ x < &0 /\ y < &0``, 4871 REPEAT STRIP_TAC THEN 4872 STRIP_ASSUME_TAC(SPEC ``x:real`` REAL_LT_NEGTOTAL) THEN 4873 STRIP_ASSUME_TAC(SPEC ``y:real`` REAL_LT_NEGTOTAL) THEN 4874 ASM_REWRITE_TAC[REAL_MUL_LZERO, REAL_MUL_RZERO, REAL_LT_REFL] THEN 4875 ASSUM_LIST(MP_TAC o MATCH_MP REAL_LT_MUL o end_itlist CONJ) THEN 4876 REPEAT(POP_ASSUM MP_TAC) THEN REAL_ARITH_TAC); 4877 4878val SUP_FINITE_LEMMA = store_thm ("SUP_FINITE_LEMMA", 4879 ``!s. FINITE s /\ ~(s = {}) ==> ?b:real. b IN s /\ !x. x IN s ==> x <= b``, 4880 REWRITE_TAC[IMP_CONJ] THEN 4881 ONCE_REWRITE_TAC [METIS [] ``!s. (s <> {} ==> ?b:real. b IN s /\ !x. x IN s ==> x <= b) = 4882 (\s. s <> {} ==> ?b. b IN s /\ !x. x IN s ==> x <= b) s``] THEN 4883 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 4884 REWRITE_TAC[NOT_INSERT_EMPTY, IN_INSERT] THEN 4885 REWRITE_TAC[GSYM MEMBER_NOT_EMPTY] THEN 4886 REWRITE_TAC[GSYM MEMBER_NOT_EMPTY] THEN 4887 MESON_TAC[REAL_LE_TOTAL, REAL_LE_TRANS]); 4888 4889val SUP_FINITE = store_thm ("SUP_FINITE", 4890 ``!s:real->bool. FINITE s /\ ~(s = {}) ==> (sup s) IN s /\ !x. x IN s ==> x <= sup s``, 4891 GEN_TAC THEN DISCH_TAC THEN 4892 FIRST_ASSUM(MP_TAC o MATCH_MP SUP_FINITE_LEMMA) THEN 4893 METIS_TAC[REAL_LE_ANTISYM, REAL_LE_TOTAL, SUP, SUP_FINITE_LEMMA]); 4894 4895val REAL_SUP_LE_FINITE = store_thm ("REAL_SUP_LE_FINITE", 4896 ``!s a:real. FINITE s /\ ~(s = {}) ==> (sup s <= a <=> !x. x IN s ==> x <= a)``, 4897 METIS_TAC[SUP_FINITE, REAL_LE_TRANS]); 4898 4899val HAS_INTEGRAL_NEGLIGIBLE = store_thm ("HAS_INTEGRAL_NEGLIGIBLE", 4900 ``!f:real->real s t. 4901 negligible s /\ (!x. x IN (t DIFF s) ==> (f x = 0)) 4902 ==> (f has_integral (0)) t``, 4903 SUBGOAL_THEN 4904 ``!f:real->real s a b. 4905 negligible s /\ (!x. ~(x IN s) ==> (f x = 0)) 4906 ==> (f has_integral (0)) (interval[a,b])`` 4907 ASSUME_TAC THENL 4908 [ALL_TAC, 4909 REWRITE_TAC[IN_DIFF] THEN REPEAT STRIP_TAC THEN 4910 ONCE_REWRITE_TAC[has_integral_alt] THEN COND_CASES_TAC THENL 4911 [MATCH_MP_TAC HAS_INTEGRAL_EQ THEN 4912 EXISTS_TAC ``\x. if x IN t then (f:real->real) x else 0`` THEN 4913 SIMP_TAC std_ss [] THEN 4914 FIRST_X_ASSUM(CHOOSE_THEN(CHOOSE_THEN SUBST_ALL_TAC)) THEN 4915 FIRST_X_ASSUM MATCH_MP_TAC THEN METIS_TAC[], 4916 ALL_TAC] THEN 4917 GEN_TAC THEN DISCH_TAC THEN EXISTS_TAC ``&1:real`` THEN 4918 REWRITE_TAC[REAL_LT_01] THEN 4919 REPEAT STRIP_TAC THEN EXISTS_TAC ``0:real`` THEN 4920 ASM_REWRITE_TAC[ABS_0, REAL_SUB_REFL] THEN 4921 FIRST_X_ASSUM MATCH_MP_TAC THEN 4922 EXISTS_TAC ``s:real->bool`` THEN METIS_TAC[]] THEN 4923 SIMP_TAC std_ss [negligible, has_integral, RIGHT_FORALL_IMP_THM] THEN 4924 REPEAT GEN_TAC THEN DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 4925 DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 4926 POP_ASSUM (MP_TAC o Q.SPECL [`a:real`,`b:real`]) THEN 4927 REWRITE_TAC[REAL_SUB_RZERO] THEN DISCH_TAC THEN 4928 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 4929 FIRST_X_ASSUM(MP_TAC o GEN ``n:num`` o 4930 SPEC ``e / &2 / ((&n + &1:real) * &2 pow n)``) THEN 4931 REWRITE_TAC[real_div, REAL_MUL_POS_LT] THEN REWRITE_TAC[GSYM real_div] THEN 4932 ASM_SIMP_TAC arith_ss [REAL_LT_INV_EQ, REAL_LT_MUL, REAL_POW_LT, REAL_LT, 4933 FORALL_AND_THM, METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] 4934 ``&0 < &n + &1:real``, SKOLEM_THM] THEN 4935 DISCH_THEN(X_CHOOSE_THEN ``d:num->real->real->bool`` STRIP_ASSUME_TAC) THEN 4936 EXISTS_TAC ``\x. (d:num->real->real->bool) (flr(abs(f x:real))) x`` THEN 4937 CONJ_TAC THENL [REWRITE_TAC[gauge_def] THEN METIS_TAC[gauge_def], ALL_TAC] THEN 4938 X_GEN_TAC ``p:real#(real->bool)->bool`` THEN STRIP_TAC THEN 4939 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 4940 ASM_CASES_TAC ``p:real#(real->bool)->bool = {}`` THEN 4941 ASM_REWRITE_TAC[SUM_CLAUSES, ABS_0] THEN 4942 MP_TAC(SPEC ``sup(IMAGE (\(x,k:real->bool). abs((f:real->real) x)) p)`` 4943 SIMP_REAL_ARCH) THEN 4944 ASM_SIMP_TAC std_ss [REAL_SUP_LE_FINITE, IMAGE_FINITE, IMAGE_EQ_EMPTY] THEN 4945 SIMP_TAC std_ss [FORALL_IN_IMAGE, FORALL_PROD] THEN 4946 DISCH_THEN(X_CHOOSE_TAC ``N:num``) THEN 4947 MP_TAC(GEN ``i:num`` 4948 (ISPECL [``p:real#(real->bool)->bool``, ``a:real``, ``b:real``, 4949 ``(d:num->real->real->bool) i``] TAGGED_DIVISION_FINER)) THEN 4950 ASM_SIMP_TAC std_ss [SKOLEM_THM, RIGHT_IMP_EXISTS_THM, FORALL_AND_THM] THEN 4951 DISCH_THEN(X_CHOOSE_THEN ``q:num->real#(real->bool)->bool`` 4952 STRIP_ASSUME_TAC) THEN 4953 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC 4954 ``sum((0:num)..N+1:num) (\i. (&i + &1) * 4955 abs(sum (q i) (\(x:real,k:real->bool). 4956 content k * indicator s x)))`` THEN 4957 CONJ_TAC THENL 4958 [ALL_TAC, 4959 MATCH_MP_TAC REAL_LET_TRANS THEN 4960 EXISTS_TAC ``sum ((0:num)..N+1:num) (\i. e / &2 / (&2:real) pow i)`` THEN CONJ_TAC THENL 4961 [ALL_TAC, 4962 SIMP_TAC std_ss [real_div, SUM_LMUL, GSYM REAL_POW_INV] THEN 4963 SIMP_TAC std_ss [SUM_GP, LT] THEN 4964 SIMP_TAC std_ss [METIS [REAL_ARITH ``1 <> 2:real``, REAL_INV_1OVER, REAL_EQ_LDIV_EQ, 4965 REAL_ARITH ``0 < 2:real``, REAL_MUL_LID] ``inv 2 <> 1:real``, 4966 pow, REAL_INV_1OVER] THEN 4967 SIMP_TAC std_ss [METIS [REAL_HALF_DOUBLE, REAL_EQ_SUB_RADD] ``1 - 1 / 2 = 1 / 2:real``] THEN 4968 REWRITE_TAC [METIS [GSYM pow] ``(1 / 2) * (1 / 2:real) pow (N + 1:num) = 4969 (1 / 2) pow SUC (N + 1)``] THEN 4970 KNOW_TAC ``!e x. e * (&1 / &2) * ((&1 - x) / (&1 / &2)) < e <=> 4971 &0 < e * x:real`` THENL 4972 [GEN_TAC THEN GEN_TAC THEN REWRITE_TAC [real_div, REAL_MUL_LID, REAL_INV_INV] THEN 4973 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * (c * d) = (a * (b * d)) * c:real``] THEN 4974 SIMP_TAC std_ss [REAL_MUL_LID, REAL_ARITH ``2 <> 0:real``, 4975 REAL_MUL_LINV, REAL_MUL_RID] THEN REAL_ARITH_TAC, ALL_TAC] THEN 4976 DISCH_TAC THEN ASM_SIMP_TAC std_ss [REAL_MUL_LID, REAL_INV_INV] THEN 4977 KNOW_TAC ``&0 < &1 / &2:real`` THENL 4978 [SIMP_TAC std_ss [REAL_LT_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 4979 REAL_ARITH_TAC, DISCH_TAC] THEN 4980 ASM_SIMP_TAC std_ss [REAL_LT_MUL, REAL_POW_LT, REAL_INV_1OVER]] THEN 4981 MATCH_MP_TAC SUM_LE_NUMSEG THEN REPEAT STRIP_TAC THEN 4982 SIMP_TAC std_ss [] THEN ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 4983 ASM_SIMP_TAC std_ss [GSYM REAL_LE_RDIV_EQ, METIS 4984 [ADD1, LESS_0, REAL_OF_NUM_ADD, REAL_LT] ``&0 < &n + &1:real``] THEN 4985 REWRITE_TAC[real_div] THEN ONCE_REWRITE_TAC[GSYM REAL_MUL_ASSOC] THEN 4986 KNOW_TAC ``(2 pow i) <> 0:real /\ (&i + 1) <> 0:real`` THENL 4987 [CONJ_TAC THENL [MATCH_MP_TAC POW_NZ THEN REAL_ARITH_TAC, ALL_TAC] THEN 4988 REWRITE_TAC [REAL_OF_NUM_ADD, GSYM ADD1] THEN 4989 REWRITE_TAC [REAL_LT_NZ, REAL_LT, LESS_0], STRIP_TAC] THEN 4990 ASM_SIMP_TAC std_ss [GSYM REAL_INV_MUL] THEN REWRITE_TAC[GSYM real_div] THEN 4991 GEN_REWR_TAC (RAND_CONV o ONCE_DEPTH_CONV) [REAL_MUL_SYM] THEN 4992 MATCH_MP_TAC REAL_LT_IMP_LE THEN 4993 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[]] THEN 4994 FIRST_ASSUM(ASSUME_TAC o GEN ``i:num`` o 4995 MATCH_MP TAGGED_DIVISION_OF_FINITE o SPEC ``i:num``) THEN 4996 GEN_REWR_TAC (RAND_CONV o ONCE_DEPTH_CONV) [abs] THEN 4997 SUBGOAL_THEN 4998 ``!i:num. &0 <= sum (q i) (\(x:real,y:real->bool). 4999 content y * (indicator s x))`` 5000 ASSUME_TAC THENL 5001 [REPEAT GEN_TAC THEN MATCH_MP_TAC SUM_POS_LE THEN 5002 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 5003 REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THEN MATCH_MP_TAC REAL_LE_MUL THEN 5004 REWRITE_TAC[DROP_INDICATOR_POS_LE] THEN 5005 ASM_MESON_TAC[TAGGED_DIVISION_OF, CONTENT_POS_LE], 5006 ALL_TAC] THEN 5007 ASM_REWRITE_TAC[GSYM SUM_LMUL] THEN 5008 SIMP_TAC std_ss [LAMBDA_PROD] THEN 5009 W(MP_TAC o PART_MATCH (lhand o rand) SUM_ABS o lhand o snd) THEN 5010 ASM_REWRITE_TAC[] THEN 5011 MATCH_MP_TAC(REAL_ARITH ``x <= y ==> n <= x ==> n <= y:real``) THEN 5012 ASM_SIMP_TAC std_ss [SUM_SUM_PRODUCT, FINITE_NUMSEG] THEN 5013 MATCH_MP_TAC lemma THEN 5014 ASM_SIMP_TAC std_ss [FINITE_PRODUCT_DEPENDENT, FORALL_PROD, FINITE_NUMSEG] THEN 5015 SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN CONJ_TAC THENL 5016 [REPEAT STRIP_TAC THEN MATCH_MP_TAC REAL_LE_MUL THEN 5017 CONJ_TAC THENL [METIS_TAC [ADD1, LESS_0, REAL_OF_NUM_ADD, REAL_LT, REAL_LE_LT], 5018 MATCH_MP_TAC REAL_LE_MUL] THEN 5019 REWRITE_TAC[DROP_INDICATOR_POS_LE] THEN 5020 ASM_MESON_TAC[TAGGED_DIVISION_OF, CONTENT_POS_LE], 5021 ALL_TAC] THEN 5022 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 5023 UNDISCH_TAC ``(\(x :real). 5024 (d :num -> real -> real -> bool) 5025 (flr (abs ((f :real -> real) x))) x) FINE 5026 (p :real # (real -> bool) -> bool)`` THEN DISCH_TAC THEN 5027 FIRST_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 5028 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``k:real->bool``]) THEN 5029 ASM_SIMP_TAC std_ss [] THEN ABBREV_TAC 5030 ``n = (flr(abs((f:real->real) x)))`` THEN 5031 SUBGOAL_THEN ``&n <= abs((f:real->real) x) /\ 5032 abs(f x) < &n + &1`` 5033 STRIP_ASSUME_TAC THENL 5034 [EXPAND_TAC "n" THEN 5035 SIMP_TAC std_ss [NUM_FLOOR_LE, ABS_POS] THEN 5036 REWRITE_TAC [REAL_OF_NUM_ADD] THEN 5037 REWRITE_TAC [METIS [REAL_OVER1, REAL_MUL_RID] 5038 ``&(flr (abs ((f :real -> real) x)) + 1):real = 5039 &(flr ((abs (f x)) / 1) + 1) * 1``] THEN 5040 MATCH_MP_TAC NUM_FLOOR_DIV_LOWERBOUND THEN REAL_ARITH_TAC, ALL_TAC] THEN 5041 DISCH_TAC THEN EXISTS_TAC ``n:num`` THEN ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THENL 5042 [ASM_SIMP_TAC std_ss [IN_NUMSEG, LE_0] THEN 5043 REWRITE_TAC[GSYM REAL_OF_NUM_LE, GSYM REAL_OF_NUM_ADD] THEN 5044 MATCH_MP_TAC REAL_LE_TRANS THEN 5045 EXISTS_TAC ``abs((f:real->real) x)`` THEN ASM_REWRITE_TAC[] THEN 5046 MATCH_MP_TAC(REAL_ARITH ``x <= n ==> x <= n + &1:real``) THEN 5047 ASM_MESON_TAC[], ALL_TAC] THEN 5048 ASM_CASES_TAC ``(x:real) IN s`` THEN ASM_SIMP_TAC std_ss [indicator] THEN 5049 SIMP_TAC std_ss [REAL_MUL_RZERO, ABS_0, 5050 REAL_MUL_RZERO, REAL_LE_REFL] THEN 5051 ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 5052 REWRITE_TAC[REAL_MUL_RID, ABS_MUL] THEN 5053 SUBGOAL_THEN ``&0 <= content(k:real->bool)`` ASSUME_TAC THENL 5054 [ASM_MESON_TAC[TAGGED_DIVISION_OF, CONTENT_POS_LE], ALL_TAC] THEN 5055 ASM_REWRITE_TAC[abs] THEN GEN_REWR_TAC LAND_CONV [REAL_MUL_SYM] THEN 5056 POP_ASSUM MP_TAC THEN GEN_REWR_TAC LAND_CONV [REAL_LE_LT] THEN 5057 STRIP_TAC THENL [ASM_SIMP_TAC std_ss [REAL_LE_LMUL] THEN 5058 REWRITE_TAC [GSYM abs] THEN ASM_REWRITE_TAC [REAL_LE_LT], 5059 POP_ASSUM (MP_TAC o ONCE_REWRITE_RULE [EQ_SYM_EQ]) THEN DISCH_TAC THEN 5060 ASM_REWRITE_TAC []] THEN REAL_ARITH_TAC); 5061 5062val HAS_INTEGRAL_SPIKE = store_thm ("HAS_INTEGRAL_SPIKE", 5063 ``!f:real->real g s t y. 5064 negligible s /\ (!x. x IN (t DIFF s) ==> (g x = f x)) /\ 5065 (f has_integral y) t ==> (g has_integral y) t``, 5066 SUBGOAL_THEN 5067 ``!f:real->real g s a b y. 5068 negligible s /\ (!x. x IN (interval[a,b] DIFF s) ==> (g x = f x)) 5069 ==> (f has_integral y) (interval[a,b]) 5070 ==> (g has_integral y) (interval[a,b])`` 5071 ASSUME_TAC THENL 5072 [REPEAT STRIP_TAC THEN 5073 SUBGOAL_THEN 5074 ``((\x. (f:real->real)(x) + (g(x) - f(x))) has_integral (y + 0)) 5075 (interval[a,b])`` 5076 MP_TAC THENL 5077 [ALL_TAC, 5078 SIMP_TAC std_ss [REAL_ARITH ``((f:real->real) x + (g x - f x) = g x) /\ 5079 (f x + 0 = f x)``, ETA_AX, REAL_ADD_RID]] THEN 5080 ONCE_REWRITE_TAC [METIS [] ``(g x - (f:real->real) x) = (\x. g x - f x) x``] THEN 5081 MATCH_MP_TAC HAS_INTEGRAL_ADD THEN ASM_REWRITE_TAC[] THEN 5082 MATCH_MP_TAC HAS_INTEGRAL_NEGLIGIBLE THEN 5083 EXISTS_TAC ``s:real->bool`` THEN ASM_SIMP_TAC std_ss [REAL_SUB_0], 5084 ALL_TAC] THEN 5085 REPEAT GEN_TAC THEN 5086 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 5087 ONCE_REWRITE_TAC[has_integral_alt] THEN COND_CASES_TAC THEN 5088 ASM_REWRITE_TAC[] THENL 5089 [FIRST_X_ASSUM(CHOOSE_THEN(CHOOSE_THEN SUBST_ALL_TAC)) THEN ASM_MESON_TAC[], 5090 ALL_TAC] THEN 5091 DISCH_TAC THEN GEN_TAC THEN POP_ASSUM (MP_TAC o Q.SPEC `e:real`) THEN 5092 MATCH_MP_TAC MONO_IMP THEN 5093 REWRITE_TAC[] THEN DISCH_THEN (X_CHOOSE_TAC ``B:real``) THEN 5094 EXISTS_TAC ``B:real`` THEN POP_ASSUM MP_TAC THEN 5095 MATCH_MP_TAC MONO_AND THEN REWRITE_TAC[] THEN 5096 DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 5097 POP_ASSUM (MP_TAC o Q.SPECL [`a:real`,`b:real`]) THEN 5098 MATCH_MP_TAC MONO_IMP THEN REWRITE_TAC[] THEN 5099 DISCH_THEN (X_CHOOSE_TAC ``z:real``) THEN EXISTS_TAC ``z:real`` THEN 5100 POP_ASSUM MP_TAC THEN 5101 MATCH_MP_TAC MONO_AND THEN REWRITE_TAC[] THEN 5102 FIRST_X_ASSUM MATCH_MP_TAC THEN EXISTS_TAC ``s:real->bool`` THEN 5103 ASM_REWRITE_TAC[] THEN ASM_SET_TAC[]); 5104 5105val HAS_INTEGRAL_SPIKE_EQ = store_thm ("HAS_INTEGRAL_SPIKE_EQ", 5106 ``!f:real->real g s t y. 5107 negligible s /\ (!x. x IN (t DIFF s) ==> (g x = f x)) 5108 ==> ((f has_integral y) t <=> (g has_integral y) t)``, 5109 REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THEN 5110 MATCH_MP_TAC HAS_INTEGRAL_SPIKE THENL 5111 [EXISTS_TAC ``f:real->real``, EXISTS_TAC ``g:real->real``] THEN 5112 EXISTS_TAC ``s:real->bool`` THEN ASM_SIMP_TAC std_ss [] THEN 5113 ASM_MESON_TAC[ABS_SUB]); 5114 5115val INTEGRABLE_SPIKE = store_thm ("INTEGRABLE_SPIKE", 5116 ``!f:real->real g s t. 5117 negligible s /\ (!x. x IN (t DIFF s) ==> (g x = f x)) 5118 ==> f integrable_on t ==> g integrable_on t``, 5119 REPEAT GEN_TAC THEN DISCH_TAC THEN REWRITE_TAC[integrable_on] THEN 5120 STRIP_TAC THEN EXISTS_TAC ``y:real`` THEN POP_ASSUM (MP_TAC) THEN 5121 MP_TAC(SPEC_ALL HAS_INTEGRAL_SPIKE) THEN ASM_REWRITE_TAC[]); 5122 5123val INTEGRABLE_SPIKE_EQ = store_thm ("INTEGRABLE_SPIKE_EQ", 5124 ``!f:real->real g s t. 5125 negligible s /\ (!x. x IN t DIFF s ==> (g x = f x)) 5126 ==> (f integrable_on t <=> g integrable_on t)``, 5127 MESON_TAC[INTEGRABLE_SPIKE]); 5128 5129val INTEGRAL_SPIKE = store_thm ("INTEGRAL_SPIKE", 5130 ``!f:real->real g s t y. 5131 negligible s /\ (!x. x IN (t DIFF s) ==> (g x = f x)) 5132 ==> (integral t f = integral t g)``, 5133 REPEAT STRIP_TAC THEN REWRITE_TAC[integral] THEN 5134 AP_TERM_TAC THEN ABS_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_SPIKE_EQ THEN 5135 ASM_MESON_TAC[]); 5136 5137(* ------------------------------------------------------------------------- *) 5138(* Some other trivialities about negligible sets. *) 5139(* ------------------------------------------------------------------------- *) 5140 5141val NEGLIGIBLE_SUBSET = store_thm ("NEGLIGIBLE_SUBSET", 5142 ``!s:real->bool t:real->bool. 5143 negligible s /\ t SUBSET s ==> negligible t``, 5144 REPEAT STRIP_TAC THEN REWRITE_TAC[negligible] THEN 5145 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 5146 MATCH_MP_TAC HAS_INTEGRAL_SPIKE THEN 5147 MAP_EVERY EXISTS_TAC [``(\x. 0):real->real``, ``s:real->bool``] THEN 5148 ASM_REWRITE_TAC[HAS_INTEGRAL_0] THEN 5149 REWRITE_TAC[indicator] THEN ASM_SET_TAC[]); 5150 5151val NEGLIGIBLE_DIFF = store_thm ("NEGLIGIBLE_DIFF", 5152 ``!s t:real->bool. negligible s ==> negligible(s DIFF t)``, 5153 REPEAT STRIP_TAC THEN MATCH_MP_TAC NEGLIGIBLE_SUBSET THEN 5154 EXISTS_TAC ``s:real->bool`` THEN ASM_SIMP_TAC std_ss [DIFF_SUBSET]); 5155 5156val NEGLIGIBLE_INTER = store_thm ("NEGLIGIBLE_INTER", 5157 ``!s t. negligible s \/ negligible t ==> negligible(s INTER t)``, 5158 METIS_TAC [NEGLIGIBLE_SUBSET, INTER_SUBSET]); 5159 5160val NEGLIGIBLE_UNION = store_thm ("NEGLIGIBLE_UNION", 5161 ``!s t:real->bool. 5162 negligible s /\ negligible t ==> negligible (s UNION t)``, 5163 REPEAT GEN_TAC THEN DISCH_TAC THEN FIRST_ASSUM MP_TAC THEN 5164 SIMP_TAC std_ss [negligible, GSYM FORALL_AND_THM] THEN 5165 DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 5166 POP_ASSUM (MP_TAC o Q.SPECL [`a:real`,`b:real`]) THEN 5167 DISCH_THEN(MP_TAC o MATCH_MP HAS_INTEGRAL_ADD) THEN 5168 REWRITE_TAC[REAL_ADD_LID] THEN MATCH_MP_TAC EQ_IMPLIES THEN 5169 MATCH_MP_TAC HAS_INTEGRAL_SPIKE_EQ THEN 5170 EXISTS_TAC ``s:real->bool`` THEN ASM_SIMP_TAC std_ss [] THEN 5171 SIMP_TAC std_ss [indicator, IN_UNION, IN_DIFF, REAL_ADD_LID]); 5172 5173val NEGLIGIBLE_UNION_EQ = store_thm ("NEGLIGIBLE_UNION_EQ", 5174 ``!s t:real->bool. 5175 negligible (s UNION t) <=> negligible s /\ negligible t``, 5176 METIS_TAC[NEGLIGIBLE_UNION, SUBSET_UNION, NEGLIGIBLE_SUBSET]); 5177 5178val NEGLIGIBLE_SING = store_thm ("NEGLIGIBLE_SING", 5179 ``!a:real. negligible {a}``, 5180 GEN_TAC THEN MATCH_MP_TAC NEGLIGIBLE_SUBSET THEN 5181 EXISTS_TAC ``{x | (x:real) = (a:real)}`` THEN 5182 SIMP_TAC std_ss [NEGLIGIBLE_STANDARD_HYPERPLANE, LESS_EQ_REFL] THEN 5183 SET_TAC[]); 5184 5185val NEGLIGIBLE_INSERT = store_thm ("NEGLIGIBLE_INSERT", 5186 ``!a:real s. negligible(a INSERT s) <=> negligible s``, 5187 ONCE_REWRITE_TAC[SET_RULE ``a INSERT s = {a} UNION s``] THEN 5188 REWRITE_TAC[NEGLIGIBLE_UNION_EQ, NEGLIGIBLE_SING]); 5189 5190val NEGLIGIBLE_EMPTY = store_thm ("NEGLIGIBLE_EMPTY", 5191 ``negligible {}``, 5192 METIS_TAC [EMPTY_SUBSET, NEGLIGIBLE_SUBSET, NEGLIGIBLE_SING]); 5193 5194val NEGLIGIBLE_FINITE = store_thm ("NEGLIGIBLE_FINITE", 5195 ``!s. FINITE s ==> negligible s``, 5196 ONCE_REWRITE_TAC [METIS [] ``!s. (negligible s) = (\s. negligible s) s``] THEN 5197 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 5198 SIMP_TAC std_ss [NEGLIGIBLE_EMPTY, NEGLIGIBLE_INSERT]); 5199 5200val NEGLIGIBLE_BIGUNION = store_thm ("NEGLIGIBLE_BIGUNION", 5201 ``!s. FINITE s /\ (!t. t IN s ==> negligible t) 5202 ==> negligible(BIGUNION s)``, 5203 REWRITE_TAC[IMP_CONJ] THEN 5204 ONCE_REWRITE_TAC [METIS [] 5205 ``!s. ((!t. t IN s ==> negligible t) ==> negligible(BIGUNION s)) = 5206 (\s. (!t. t IN s ==> negligible t) ==> negligible(BIGUNION s)) s``] THEN 5207 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 5208 SIMP_TAC std_ss [BIGUNION_EMPTY, BIGUNION_INSERT, NEGLIGIBLE_EMPTY, IN_INSERT] THEN 5209 SIMP_TAC std_ss [NEGLIGIBLE_UNION]); 5210 5211val NEGLIGIBLE = store_thm ("NEGLIGIBLE", 5212 ``!s:real->bool. negligible s <=> !t. (indicator s has_integral 0) t``, 5213 GEN_TAC THEN EQ_TAC THENL 5214 [ALL_TAC, REWRITE_TAC[negligible] THEN SIMP_TAC std_ss []] THEN 5215 DISCH_TAC THEN GEN_TAC THEN ONCE_REWRITE_TAC[has_integral_alt] THEN 5216 COND_CASES_TAC THENL [ASM_MESON_TAC[negligible], ALL_TAC] THEN 5217 GEN_TAC THEN DISCH_TAC THEN EXISTS_TAC ``&1:real`` THEN REWRITE_TAC[REAL_LT_01] THEN 5218 REPEAT STRIP_TAC THEN EXISTS_TAC ``0:real`` THEN 5219 MP_TAC(ISPECL [``s:real->bool``, ``s INTER t:real->bool``] 5220 NEGLIGIBLE_SUBSET) THEN 5221 ASM_SIMP_TAC std_ss [INTER_SUBSET, negligible, REAL_SUB_REFL, ABS_0] THEN 5222 DISCH_TAC THEN POP_ASSUM (MP_TAC o Q.SPECL [`a:real`,`b:real`]) THEN 5223 SIMP_TAC std_ss [indicator, IN_INTER] THEN MATCH_MP_TAC EQ_IMPLIES THEN 5224 AP_THM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN SET_TAC []); 5225 5226(* ------------------------------------------------------------------------- *) 5227(* Finite or empty cases of the spike theorem are quite commonly needed. *) 5228(* ------------------------------------------------------------------------- *) 5229 5230val HAS_INTEGRAL_SPIKE_FINITE = store_thm ("HAS_INTEGRAL_SPIKE_FINITE", 5231 ``!f:real->real g s t y. 5232 FINITE s /\ (!x. x IN (t DIFF s) ==> (g x = f x)) /\ 5233 (f has_integral y) t 5234 ==> (g has_integral y) t``, 5235 MESON_TAC [HAS_INTEGRAL_SPIKE, NEGLIGIBLE_FINITE]); 5236 5237val HAS_INTEGRAL_SPIKE_FINITE_EQ = store_thm ("HAS_INTEGRAL_SPIKE_FINITE_EQ", 5238 ``!f:real->real g s t y. 5239 FINITE s /\ (!x. x IN (t DIFF s) ==> (g x = f x)) 5240 ==> ((f has_integral y) t <=> (g has_integral y) t)``, 5241 MESON_TAC[HAS_INTEGRAL_SPIKE_FINITE]); 5242 5243val INTEGRABLE_SPIKE_FINITE = store_thm ("INTEGRABLE_SPIKE_FINITE", 5244 ``!f:real->real g s. 5245 FINITE s /\ (!x. x IN (t DIFF s) ==> (g x = f x)) 5246 ==> f integrable_on t 5247 ==> g integrable_on t``, 5248 REPEAT GEN_TAC THEN DISCH_TAC THEN REWRITE_TAC[integrable_on] THEN 5249 STRIP_TAC THEN EXISTS_TAC ``y:real`` THEN POP_ASSUM MP_TAC THEN 5250 MP_TAC(SPEC_ALL HAS_INTEGRAL_SPIKE_FINITE) THEN ASM_REWRITE_TAC[]); 5251 5252val INTEGRAL_EQ = store_thm ("INTEGRAL_EQ", 5253 ``!f:real->real g s. 5254 (!x. x IN s ==> (f x = g x)) ==> (integral s f = integral s g)``, 5255 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_SPIKE THEN 5256 EXISTS_TAC ``{}:real->bool`` THEN ASM_SIMP_TAC std_ss [NEGLIGIBLE_EMPTY, IN_DIFF]); 5257 5258val INTEGRAL_EQ_0 = store_thm ("INTEGRAL_EQ_0", 5259 ``!f:real->real s. (!x. x IN s ==> (f x = 0)) ==> (integral s f = 0)``, 5260 REPEAT STRIP_TAC THEN MATCH_MP_TAC EQ_TRANS THEN 5261 EXISTS_TAC ``integral s ((\x. 0):real->real)`` THEN 5262 CONJ_TAC THENL 5263 [MATCH_MP_TAC INTEGRAL_EQ THEN ASM_REWRITE_TAC[], 5264 REWRITE_TAC[INTEGRAL_0]]); 5265 5266(* ------------------------------------------------------------------------- *) 5267(* In particular, the boundary of an interval is negligible. *) 5268(* ------------------------------------------------------------------------- *) 5269 5270val NEGLIGIBLE_FRONTIER_INTERVAL = store_thm ("NEGLIGIBLE_FRONTIER_INTERVAL", 5271 ``!a b:real. negligible(interval[a,b] DIFF interval(a,b))``, 5272 REPEAT GEN_TAC THEN MATCH_MP_TAC NEGLIGIBLE_SUBSET THEN 5273 EXISTS_TAC ``BIGUNION ({{x:real | x = (a:real)} UNION 5274 {x:real | x = (b:real)}})`` THEN 5275 CONJ_TAC THENL 5276 [MATCH_MP_TAC NEGLIGIBLE_BIGUNION THEN 5277 SRW_TAC [][] THEN MATCH_MP_TAC NEGLIGIBLE_UNION THEN 5278 REWRITE_TAC [NEGLIGIBLE_SING], 5279 SIMP_TAC std_ss [SUBSET_DEF, IN_DIFF, IN_INTERVAL, IN_BIGUNION, EXISTS_IN_IMAGE] THEN 5280 SIMP_TAC std_ss [IN_NUMSEG, IN_UNION, GSPECIFICATION, REAL_LT_LE] THEN 5281 SRW_TAC [][]]); 5282 5283val HAS_INTEGRAL_SPIKE_INTERIOR = store_thm ("HAS_INTEGRAL_SPIKE_INTERIOR", 5284 ``!f:real->real g a b y. 5285 (!x. x IN interval(a,b) ==> (g x = f x)) /\ 5286 (f has_integral y) (interval[a,b]) 5287 ==> (g has_integral y) (interval[a,b])``, 5288 REPEAT GEN_TAC THEN REWRITE_TAC[IMP_CONJ] THEN DISCH_TAC THEN 5289 MATCH_MP_TAC(REWRITE_RULE[TAUT `a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] 5290 HAS_INTEGRAL_SPIKE) THEN 5291 EXISTS_TAC ``interval[a:real,b] DIFF interval(a,b)`` THEN 5292 REWRITE_TAC[NEGLIGIBLE_FRONTIER_INTERVAL] THEN ASM_SET_TAC[]); 5293 5294val HAS_INTEGRAL_SPIKE_INTERIOR_EQ = store_thm ("HAS_INTEGRAL_SPIKE_INTERIOR_EQ", 5295 ``!f:real->real g a b y. 5296 (!x. x IN interval(a,b) ==> (g x = f x)) 5297 ==> ((f has_integral y) (interval[a,b]) <=> 5298 (g has_integral y) (interval[a,b]))``, 5299 MESON_TAC[HAS_INTEGRAL_SPIKE_INTERIOR]); 5300 5301val INTEGRABLE_SPIKE_INTERIOR = store_thm ("INTEGRABLE_SPIKE_INTERIOR", 5302 ``!f:real->real g a b. 5303 (!x. x IN interval(a,b) ==> (g x = f x)) 5304 ==> f integrable_on (interval[a,b]) 5305 ==> g integrable_on (interval[a,b])``, 5306 REPEAT GEN_TAC THEN DISCH_TAC THEN REWRITE_TAC[integrable_on] THEN 5307 STRIP_TAC THEN EXISTS_TAC ``y:real`` THEN POP_ASSUM MP_TAC THEN 5308 MP_TAC(SPEC_ALL HAS_INTEGRAL_SPIKE_INTERIOR) THEN ASM_REWRITE_TAC[]); 5309 5310(* ------------------------------------------------------------------------- *) 5311(* Integrability of continuous functions. *) 5312(* ------------------------------------------------------------------------- *) 5313 5314val NEUTRAL_AND = store_thm ("NEUTRAL_AND", 5315 ``neutral(/\) = T``, 5316 SIMP_TAC std_ss [neutral, FORALL_BOOL] THEN METIS_TAC[]); 5317 5318val MONOIDAL_AND = store_thm ("MONOIDAL_AND", 5319 ``monoidal(/\)``, 5320 REWRITE_TAC [monoidal] THEN 5321 SIMP_TAC std_ss [NEUTRAL_AND, CONJ_ACI]); 5322 5323val ITERATE_AND = store_thm ("ITERATE_AND", 5324 ``!p s. FINITE s ==> (iterate(/\) s p <=> !x. x IN s ==> p x)``, 5325 GEN_TAC THEN 5326 ONCE_REWRITE_TAC [METIS [] ``!s. ((iterate(/\) s p <=> !x. x IN s ==> p x)) = 5327 (\s. (iterate(/\) s p <=> !x. x IN s ==> p x)) s``] THEN 5328 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 5329 ASM_SIMP_TAC std_ss [MONOIDAL_AND, NEUTRAL_AND, ITERATE_CLAUSES] THEN SET_TAC[]); 5330 5331val OPERATIVE_DIVISION_AND = store_thm ("OPERATIVE_DIVISION_AND", 5332 ``!P d a b. operative(/\) P /\ d division_of interval[a,b] 5333 ==> ((!i. i IN d ==> P i) <=> P(interval[a,b]))``, 5334 REPEAT GEN_TAC THEN DISCH_THEN(ASSUME_TAC o CONJ MONOIDAL_AND) THEN 5335 FIRST_ASSUM(MP_TAC o MATCH_MP OPERATIVE_DIVISION) THEN 5336 ASM_MESON_TAC[ITERATE_AND, DIVISION_OF_FINITE]); 5337 5338val OPERATIVE_APPROXIMABLE = store_thm ("OPERATIVE_APPROXIMABLE", 5339 ``!f:real->real e. 5340 &0 <= e 5341 ==> operative(/\) 5342 (\i. ?g. (!x. x IN i ==> abs (f x - g x) <= e) /\ 5343 g integrable_on i)``, 5344 REPEAT STRIP_TAC THEN REWRITE_TAC[operative, NEUTRAL_AND] THEN CONJ_TAC THENL 5345 [REPEAT STRIP_TAC THEN BETA_TAC THEN EXISTS_TAC ``f:real->real`` THEN 5346 ASM_SIMP_TAC std_ss [REAL_SUB_REFL, ABS_0, integrable_on] THEN 5347 METIS_TAC[HAS_INTEGRAL_NULL], 5348 ALL_TAC] THEN 5349 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``, ``c:real``] THEN EQ_TAC THENL 5350 [METIS_TAC[INTEGRABLE_SPLIT, IN_INTER], ALL_TAC] THEN BETA_TAC THEN 5351 DISCH_THEN(CONJUNCTS_THEN2 5352 (X_CHOOSE_THEN ``g1:real->real`` STRIP_ASSUME_TAC) 5353 (X_CHOOSE_THEN ``g2:real->real`` STRIP_ASSUME_TAC)) THEN 5354 EXISTS_TAC ``\x. if x = c then (f:real->real)(x) else 5355 if x <= c then g1(x) else g2(x)`` THEN 5356 CONJ_TAC THENL 5357 [GEN_TAC THEN STRIP_TAC THEN SIMP_TAC std_ss [] THEN 5358 COND_CASES_TAC THEN ASM_REWRITE_TAC[REAL_SUB_REFL, ABS_0] THEN 5359 RULE_ASSUM_TAC(SIMP_RULE std_ss [IN_INTER, GSPECIFICATION]) THEN 5360 METIS_TAC[REAL_ARITH ``x <= c \/ x >= c:real``], 5361 ALL_TAC] THEN 5362 SUBGOAL_THEN 5363 ``(\x:real. if x = c then f x else if x <= c then g1 x else g2 x) 5364 integrable_on (interval[u,v] INTER {x | x <= c}) /\ 5365 (\x. if x = c then f x :real else if x <= c then g1 x else g2 x) 5366 integrable_on (interval[u,v] INTER {x | x >= c})`` 5367 MP_TAC THENL 5368 [ALL_TAC, 5369 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_SPLIT]] THEN 5370 CONJ_TAC THENL 5371 [UNDISCH_TAC 5372 ``(g1:real->real) integrable_on (interval[u,v] INTER {x | x <= c})``, 5373 UNDISCH_TAC 5374 ``(g2:real->real) integrable_on (interval[u,v] INTER {x | x >= c})``] THEN 5375 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN MATCH_MP_TAC INTEGRABLE_SPIKE THEN 5376 ASM_SIMP_TAC std_ss [GSYM INTERVAL_SPLIT] THEN 5377 EXISTS_TAC ``{x:real | x = c}`` THEN 5378 ASM_SIMP_TAC std_ss [NEGLIGIBLE_STANDARD_HYPERPLANE, IN_DIFF, IN_INTER, GSPECIFICATION, 5379 REAL_ARITH ``x >= c /\ ~(x = c) ==> ~(x <= c:real)``]); 5380 5381val APPROXIMABLE_ON_DIVISION = store_thm ("APPROXIMABLE_ON_DIVISION", 5382 ``!f:real->real d a b e. 5383 &0 <= e /\ 5384 (d division_of interval[a,b]) /\ 5385 (!i. i IN d 5386 ==> ?g. (!x. x IN i ==> abs (f x - g x) <= e) /\ 5387 g integrable_on i) 5388 ==> ?g. (!x. x IN interval[a,b] ==> abs (f x - g x) <= e) /\ 5389 g integrable_on interval[a,b]``, 5390 REPEAT STRIP_TAC THEN 5391 MP_TAC(ISPECL [``(/\)``, ``d:(real->bool)->bool``, 5392 ``a:real``, ``b:real``, 5393 ``\i. ?g:real->real. 5394 (!x. x IN i ==> abs (f x - g x) <= e) /\ 5395 g integrable_on i``] 5396 OPERATIVE_DIVISION) THEN 5397 ASM_SIMP_TAC std_ss [OPERATIVE_APPROXIMABLE, MONOIDAL_AND] THEN 5398 DISCH_THEN(SUBST1_TAC o SYM) THEN 5399 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 5400 ASM_SIMP_TAC std_ss [ITERATE_AND]); 5401 5402val INTEGRABLE_CONTINUOUS = store_thm ("INTEGRABLE_CONTINUOUS", 5403 ``!f:real->real a b. 5404 f continuous_on interval[a,b] ==> f integrable_on interval[a,b]``, 5405 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRABLE_UNIFORM_LIMIT THEN 5406 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 5407 MATCH_MP_TAC APPROXIMABLE_ON_DIVISION THEN 5408 ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE] THEN 5409 FIRST_ASSUM(MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 5410 COMPACT_UNIFORMLY_CONTINUOUS)) THEN 5411 REWRITE_TAC[COMPACT_INTERVAL, uniformly_continuous_on] THEN 5412 DISCH_THEN(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[dist] THEN 5413 DISCH_THEN(X_CHOOSE_THEN ``d:real`` STRIP_ASSUME_TAC) THEN 5414 SUBGOAL_THEN 5415 ``?p. p tagged_division_of interval[a:real,b] /\ (\x. ball(x,d)) FINE p`` 5416 STRIP_ASSUME_TAC THENL 5417 [METIS_TAC[FINE_DIVISION_EXISTS, GAUGE_BALL], ALL_TAC] THEN 5418 EXISTS_TAC ``IMAGE SND (p:real#(real->bool)->bool)`` THEN 5419 ASM_SIMP_TAC std_ss [DIVISION_OF_TAGGED_DIVISION] THEN 5420 SIMP_TAC std_ss [FORALL_IN_IMAGE, FORALL_PROD] THEN 5421 MAP_EVERY X_GEN_TAC [``x:real``, ``l:real->bool``] THEN 5422 DISCH_TAC THEN EXISTS_TAC ``\y:real. (f:real->real) x`` THEN 5423 UNDISCH_TAC `` p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 5424 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 5425 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 5426 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC STRIP_ASSUME_TAC) THEN 5427 DISCH_THEN(MP_TAC o 5428 SPECL [``x:real``, ``l:real->bool``]) THEN 5429 ASM_REWRITE_TAC[SUBSET_DEF] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 5430 UNDISCH_TAC ``(\x. ball (x,d)) FINE p`` THEN DISCH_TAC THEN 5431 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN BETA_TAC THEN 5432 REWRITE_TAC[SUBSET_DEF, IN_BALL, dist] THEN 5433 FIRST_X_ASSUM SUBST_ALL_TAC THEN REPEAT STRIP_TAC THENL 5434 [METIS_TAC[REAL_LT_IMP_LE, ABS_SUB], 5435 REWRITE_TAC[integrable_on] THEN 5436 EXISTS_TAC ``content(interval[a':real,b']) * (f:real->real) x`` THEN 5437 REWRITE_TAC[HAS_INTEGRAL_CONST]]); 5438 5439(* ------------------------------------------------------------------------- *) 5440(* Specialization of additivity to one dimension. *) 5441(* ------------------------------------------------------------------------- *) 5442 5443val OPERATIVE_1_LT = store_thm ("OPERATIVE_1_LT", 5444 ``!op. monoidal op 5445 ==> !f. operative op f <=> 5446 (!a b. b <= a ==> (f(interval[a,b]) = neutral op)) /\ 5447 (!a b c. a < c /\ c < b 5448 ==> (op (f(interval[a,c])) (f(interval[c,b])) = 5449 f(interval[a,b])))``, 5450 REPEAT STRIP_TAC THEN REWRITE_TAC[operative, CONTENT_EQ_0] THEN 5451 MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> (a /\ b <=> a /\ c)`) THEN 5452 DISCH_TAC THEN 5453 AP_TERM_TAC THEN SIMP_TAC std_ss [FUN_EQ_THM] THEN X_GEN_TAC ``a:real`` THEN 5454 AP_TERM_TAC THEN SIMP_TAC std_ss [FUN_EQ_THM] THEN X_GEN_TAC ``b:real`` THEN 5455 EQ_TAC THEN DISCH_TAC THENL 5456 [X_GEN_TAC ``c:real`` THEN FIRST_ASSUM(SUBST1_TAC o SPEC ``c:real``) THEN 5457 DISCH_TAC THEN FIRST_ASSUM(ASSUME_TAC o MATCH_MP REAL_LT_TRANS) THEN 5458 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, LESS_EQ_REFL, REAL_LT_IMP_LE] THEN 5459 BINOP_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN 5460 SIMP_TAC std_ss [CONS_11, PAIR_EQ] THEN 5461 SIMP_TAC std_ss [LESS_EQ_REFL, min_def, max_def] THENL 5462 [FULL_SIMP_TAC std_ss [GSYM REAL_NOT_LE], 5463 ASM_SIMP_TAC std_ss [REAL_LE_LT]], ALL_TAC] THEN 5464 X_GEN_TAC ``c:real`` THEN 5465 SIMP_TAC std_ss [INTERVAL_SPLIT, LESS_EQ_REFL] THEN 5466 DISJ_CASES_TAC(REAL_ARITH ``c <= a \/ a < c:real``) THENL 5467 [SUBGOAL_THEN 5468 ``(content(interval [(a,min b c)]) = &0) /\ 5469 (interval [(max a c,b)] = interval[a,b])`` 5470 (CONJUNCTS_THEN2 MP_TAC SUBST1_TAC) THENL 5471 [CONJ_TAC THENL 5472 [SIMP_TAC std_ss [CONTENT_EQ_0, min_def] THEN METIS_TAC [REAL_LE_TRANS], 5473 AP_TERM_TAC THEN SIMP_TAC std_ss [CONS_11, PAIR_EQ, max_def] THEN 5474 METIS_TAC [REAL_LE_ANTISYM]], 5475 REWRITE_TAC[CONTENT_EQ_0] THEN 5476 DISCH_THEN(ANTE_RES_THEN SUBST1_TAC) THEN METIS_TAC[monoidal]], 5477 ALL_TAC] THEN 5478 DISJ_CASES_TAC(REAL_ARITH ``b <= c \/ c < b:real``) THENL 5479 [SUBGOAL_THEN 5480 ``(interval [(a,min b c)] = interval[a,b]) /\ 5481 (content(interval [(max a c,b)]) = &0)`` 5482 (CONJUNCTS_THEN2 SUBST1_TAC MP_TAC) THENL 5483 [CONJ_TAC THENL 5484 [AP_TERM_TAC THEN SIMP_TAC std_ss [CONS_11, PAIR_EQ] THEN METIS_TAC [min_def], 5485 SIMP_TAC std_ss [CONTENT_EQ_0, max_def] THEN METIS_TAC [REAL_LE_LT]], 5486 REWRITE_TAC[CONTENT_EQ_0] THEN 5487 DISCH_THEN(ANTE_RES_THEN SUBST1_TAC) THEN ASM_MESON_TAC[monoidal]], 5488 ALL_TAC] THEN 5489 SUBGOAL_THEN 5490 ``(min b c = c:real) /\ (max a c = c:real)`` 5491 (fn th => REWRITE_TAC[th] THEN ASM_MESON_TAC[]) THEN 5492 SIMP_TAC std_ss [LESS_EQ_REFL, min_def, max_def] THEN 5493 FULL_SIMP_TAC std_ss [GSYM REAL_NOT_LE] THEN 5494 FULL_SIMP_TAC std_ss [REAL_NOT_LE, REAL_LE_LT]); 5495 5496val OPERATIVE_1_LE = store_thm ("OPERATIVE_1_LE", 5497 ``!op. monoidal op 5498 ==> !f. operative op f <=> 5499 (!a b. b <= a ==> (f(interval[a,b]) = neutral op)) /\ 5500 (!a b c. a <= c /\ c <= b 5501 ==> (op (f(interval[a,c])) (f(interval[c,b])) = 5502 f(interval[a,b])))``, 5503 GEN_TAC THEN DISCH_TAC THEN GEN_TAC THEN EQ_TAC THENL 5504 [ALL_TAC, ASM_SIMP_TAC std_ss [OPERATIVE_1_LT] THEN MESON_TAC[REAL_LT_IMP_LE]] THEN 5505 REWRITE_TAC[operative, CONTENT_EQ_0] THEN 5506 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN ASM_REWRITE_TAC[] THEN 5507 DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 5508 POP_ASSUM (MP_TAC o Q.SPECL [`a:real`,`b:real`]) THEN DISCH_TAC THEN 5509 X_GEN_TAC ``c:real`` THEN FIRST_ASSUM(SUBST1_TAC o SPEC ``c:real``) THEN 5510 DISCH_TAC THEN FIRST_ASSUM(ASSUME_TAC o MATCH_MP REAL_LE_TRANS) THEN 5511 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, LESS_EQ_REFL] THEN 5512 BINOP_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN 5513 SIMP_TAC std_ss [CONS_11, PAIR_EQ] THEN 5514 SIMP_TAC std_ss [LESS_EQ_REFL, min_def, max_def] THEN 5515 METIS_TAC [REAL_LE_ANTISYM]); 5516 5517(* ------------------------------------------------------------------------- *) 5518(* Special case of additivity we need for the FTC. *) 5519(* ------------------------------------------------------------------------- *) 5520 5521val ADDITIVE_TAGGED_DIVISION_1 = store_thm ("ADDITIVE_TAGGED_DIVISION_1", 5522 ``!f:real->real p a b. 5523 a <= b /\ 5524 p tagged_division_of interval[a,b] 5525 ==> (sum p 5526 (\(x,k). f(interval_upperbound k) - f(interval_lowerbound k)) = 5527 f b - f a)``, 5528 REPEAT STRIP_TAC THEN 5529 MP_TAC(ISPECL 5530 [``(+):real->real->real``, 5531 ``p:(real#(real->bool)->bool)``, 5532 ``a:real``, ``b:real``, 5533 ``(\k. if k = {} then 0 5534 else f(interval_upperbound k) - f(interval_lowerbound k)): 5535 ((real->bool)->real)``] OPERATIVE_TAGGED_DIVISION) THEN 5536 ASM_SIMP_TAC std_ss [MONOIDAL_REAL_ADD, OPERATIVE_1_LT, NEUTRAL_REAL_ADD, 5537 INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 5538 KNOW_TAC ``(!(a' :real) (b' :real). 5539 b' <= a' ==> 5540 ((if interval [(a',b')] = ({} :real -> bool) then (0 :real) 5541 else 5542 (f :real -> real) (interval_upperbound (interval [(a',b')])) - 5543 f (interval_lowerbound (interval [(a',b')]))) = 5544 (0 : 5545 real))) /\ 5546 (!(a :real) (b :real) (c :real). 5547 a < c /\ c < b ==> 5548 ((if interval [(a,c)] = ({} :real -> bool) then (0 :real) 5549 else 5550 f (interval_upperbound (interval [(a,c)])) - 5551 f (interval_lowerbound (interval [(a,c)]))) + 5552 (if interval [(c,b)] = ({} :real -> bool) then (0 :real) 5553 else 5554 f (interval_upperbound (interval [(c,b)])) - 5555 f (interval_lowerbound (interval [(c,b)]))) = 5556 if interval [(a,b)] = ({} :real -> bool) then (0 :real) 5557 else 5558 f (interval_upperbound (interval [(a,b)])) - 5559 f (interval_lowerbound (interval [(a,b)]))))`` THENL 5560 [ASM_SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, REAL_ARITH ``a <= b ==> ~(b < a:real)``, 5561 REAL_LT_IMP_LE, CONTENT_EQ_0, 5562 INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 5563 SIMP_TAC std_ss [REAL_ARITH ``b <= a ==> (b < a <=> ~(b = a:real))``] THEN 5564 SIMP_TAC std_ss [METIS [] ``(if ~p then x else y) = (if p then y else x)``] THEN 5565 SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, REAL_LE_REFL] THEN 5566 SIMP_TAC std_ss [REAL_SUB_REFL, COND_ID] THEN 5567 REPEAT GEN_TAC THEN DISCH_TAC THEN ONCE_REWRITE_TAC [EQ_SYM_EQ] THEN 5568 FIRST_ASSUM(ASSUME_TAC o MATCH_MP REAL_LT_TRANS) THEN 5569 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, 5570 REAL_ARITH ``b < a ==> ~(a < b:real)``, REAL_LT_IMP_LE] THEN 5571 MESON_TAC[REAL_ARITH ``(c - a) + (b - c):real = b - a``], 5572 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 5573 ASM_SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, GSYM REAL_NOT_LE] THEN 5574 DISCH_THEN(SUBST1_TAC o SYM) THEN 5575 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 5576 ASM_SIMP_TAC std_ss [GSYM sum_def] THEN MATCH_MP_TAC SUM_EQ THEN 5577 SIMP_TAC std_ss [FORALL_PROD] THEN 5578 METIS_TAC[TAGGED_DIVISION_OF, MEMBER_NOT_EMPTY]); 5579 5580(* ------------------------------------------------------------------------- *) 5581(* A useful lemma allowing us to factor out the content size. *) 5582(* ------------------------------------------------------------------------- *) 5583 5584val HAS_INTEGRAL_FACTOR_CONTENT = store_thm ("HAS_INTEGRAL_FACTOR_CONTENT", 5585 ``!f:real->real i a b. 5586 (f has_integral i) (interval[a,b]) <=> 5587 (!e. &0 < e 5588 ==> ?d. gauge d /\ 5589 (!p. p tagged_division_of interval[a,b] /\ d FINE p 5590 ==> abs (sum p (\(x,k). content k * f x) - i) 5591 <= e * content(interval[a,b])))``, 5592 REPEAT GEN_TAC THEN 5593 ASM_CASES_TAC ``content(interval[a:real,b]) = &0`` THENL 5594 [MP_TAC(SPECL [``f:real->real``, ``a:real``, ``b:real``] 5595 SUM_CONTENT_NULL) THEN 5596 ASM_SIMP_TAC std_ss [HAS_INTEGRAL_NULL_EQ, REAL_SUB_LZERO, ABS_NEG] THEN 5597 DISCH_TAC THEN REWRITE_TAC[REAL_MUL_RZERO, ABS_LE_0] THEN 5598 METIS_TAC[FINE_DIVISION_EXISTS, GAUGE_TRIVIAL, REAL_LT_01], 5599 ALL_TAC] THEN 5600 REWRITE_TAC[has_integral] THEN EQ_TAC THEN DISCH_TAC THEN 5601 X_GEN_TAC ``e:real`` THEN DISCH_TAC THENL 5602 [FIRST_X_ASSUM(MP_TAC o SPEC ``e * content(interval[a:real,b])``) THEN 5603 ASM_SIMP_TAC std_ss [REAL_LT_MUL, CONTENT_LT_NZ] THEN METIS_TAC[REAL_LT_IMP_LE], 5604 ALL_TAC] THEN 5605 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2 / content(interval[a:real,b])``) THEN 5606 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, CONTENT_LT_NZ, REAL_LT] THEN 5607 ASM_SIMP_TAC std_ss [REAL_DIV_RMUL] THEN 5608 KNOW_TAC ``!e x:real. &0 < e /\ x <= e / &2 ==> x < e`` THENL 5609 [SIMP_TAC std_ss [REAL_LE_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 5610 REAL_ARITH_TAC, DISCH_TAC] THEN METIS_TAC[]); 5611 5612(* ------------------------------------------------------------------------- *) 5613(* Attempt a systematic general set of "offset" results for components. *) 5614(* ------------------------------------------------------------------------- *) 5615 5616val GAUGE_MODIFY = store_thm ("GAUGE_MODIFY", 5617 ``!f:real->real. 5618 (!s. open s ==> open {x | f(x) IN s}) 5619 ==> !d. gauge d ==> gauge (\x y. d (f x) (f y))``, 5620 GEN_TAC THEN DISCH_TAC THEN GEN_TAC THEN 5621 SIMP_TAC std_ss [gauge_def, IN_DEF] THEN DISCH_TAC THEN 5622 X_GEN_TAC ``x:real`` THEN 5623 FIRST_X_ASSUM(MP_TAC o SPEC ``(f:real->real) x``) THEN 5624 DISCH_THEN(ANTE_RES_THEN MP_TAC o CONJUNCT2) THEN 5625 MATCH_MP_TAC EQ_IMPLIES THEN 5626 AP_TERM_TAC THEN SIMP_TAC std_ss [EXTENSION, GSPECIFICATION] THEN 5627 SIMP_TAC std_ss [IN_DEF]); 5628 5629(* ------------------------------------------------------------------------- *) 5630(* Integrabibility on subintervals. *) 5631(* ------------------------------------------------------------------------- *) 5632 5633val OPERATIVE_INTEGRABLE = store_thm ("OPERATIVE_INTEGRABLE", 5634 ``!f. operative (/\) (\i. f integrable_on i)``, 5635 GEN_TAC THEN REWRITE_TAC[operative, NEUTRAL_AND] THEN CONJ_TAC THENL 5636 [REWRITE_TAC[integrable_on] THEN MESON_TAC[HAS_INTEGRAL_NULL_EQ], 5637 REPEAT STRIP_TAC THEN EQ_TAC THEN ASM_SIMP_TAC std_ss [INTEGRABLE_SPLIT] THEN 5638 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_SPLIT]]); 5639 5640val INTEGRABLE_SUBINTERVAL = store_thm ("INTEGRABLE_SUBINTERVAL", 5641 ``!f:real->real a b c d. 5642 f integrable_on interval[a,b] /\ 5643 interval[c,d] SUBSET interval[a,b] 5644 ==> f integrable_on interval[c,d]``, 5645 REPEAT STRIP_TAC THEN 5646 ASM_CASES_TAC ``interval[c:real,d] = {}`` THENL 5647 [ASM_REWRITE_TAC[integrable_on] THEN 5648 METIS_TAC[HAS_INTEGRAL_NULL, CONTENT_EMPTY, EMPTY_AS_INTERVAL], 5649 METIS_TAC[OPERATIVE_INTEGRABLE, OPERATIVE_DIVISION_AND, 5650 PARTIAL_DIVISION_EXTEND_1]]); 5651 5652(* ------------------------------------------------------------------------- *) 5653(* Combining adjacent intervals in 1 dimension. *) 5654(* ------------------------------------------------------------------------- *) 5655 5656val HAS_INTEGRAL_COMBINE = store_thm ("HAS_INTEGRAL_COMBINE", 5657 ``!f i:real j a b c. 5658 a <= c /\ c <= b /\ 5659 (f has_integral i) (interval[a,c]) /\ 5660 (f has_integral j) (interval[c,b]) 5661 ==> (f has_integral (i + j)) (interval[a,b])``, 5662 REPEAT STRIP_TAC THEN MP_TAC 5663 ((CONJUNCT2 o REWRITE_RULE 5664 [MATCH_MP OPERATIVE_1_LE(MATCH_MP MONOIDAL_LIFTED MONOIDAL_REAL_ADD)]) 5665 (ISPEC ``f:real->real`` OPERATIVE_INTEGRAL)) THEN 5666 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``, ``c:real``]) THEN 5667 ASM_REWRITE_TAC[] THEN BETA_TAC THEN 5668 REPEAT(COND_CASES_TAC THEN 5669 ASM_SIMP_TAC std_ss [lifted, NOT_NONE_SOME, SOME_11, option_CLAUSES]) THEN 5670 METIS_TAC[INTEGRABLE_INTEGRAL, HAS_INTEGRAL_UNIQUE, integrable_on, 5671 INTEGRAL_UNIQUE]); 5672 5673val INTEGRAL_COMBINE = store_thm ("INTEGRAL_COMBINE", 5674 ``!f:real->real a b c. 5675 a <= c /\ c <= b /\ f integrable_on (interval[a,b]) 5676 ==> (integral(interval[a,c]) f + integral(interval[c,b]) f = 5677 integral(interval[a,b]) f)``, 5678 REPEAT STRIP_TAC THEN CONV_TAC SYM_CONV THEN 5679 MATCH_MP_TAC INTEGRAL_UNIQUE THEN MATCH_MP_TAC HAS_INTEGRAL_COMBINE THEN 5680 EXISTS_TAC ``c:real`` THEN ASM_REWRITE_TAC[] THEN CONJ_TAC THEN 5681 MATCH_MP_TAC INTEGRABLE_INTEGRAL THEN 5682 MATCH_MP_TAC INTEGRABLE_SUBINTERVAL THEN 5683 MAP_EVERY EXISTS_TAC [``a:real``, ``b:real``] THEN 5684 ASM_REWRITE_TAC[SUBSET_INTERVAL, REAL_LE_REFL]); 5685 5686val INTEGRABLE_COMBINE = store_thm ("INTEGRABLE_COMBINE", 5687 ``!f a b c. 5688 a <= c /\ c <= b /\ 5689 f integrable_on interval[a,c] /\ 5690 f integrable_on interval[c,b] 5691 ==> f integrable_on interval[a,b]``, 5692 REWRITE_TAC[integrable_on] THEN MESON_TAC[HAS_INTEGRAL_COMBINE]); 5693 5694(* ------------------------------------------------------------------------- *) 5695(* Reduce integrability to "local" integrability. *) 5696(* ------------------------------------------------------------------------- *) 5697 5698val INTEGRABLE_ON_LITTLE_SUBINTERVALS = store_thm ("INTEGRABLE_ON_LITTLE_SUBINTERVALS", 5699 ``!f:real->real a b. 5700 (!x. x IN interval[a,b] 5701 ==> ?d. &0 < d /\ 5702 !u v. x IN interval[u,v] /\ 5703 interval[u,v] SUBSET ball(x,d) /\ 5704 interval[u,v] SUBSET interval[a,b] 5705 ==> f integrable_on interval[u,v]) 5706 ==> f integrable_on interval[a,b]``, 5707 REPEAT GEN_TAC THEN 5708 SIMP_TAC std_ss [RIGHT_IMP_EXISTS_THM, GAUGE_EXISTENCE_LEMMA] THEN 5709 SIMP_TAC std_ss [SKOLEM_THM, FORALL_AND_THM] THEN 5710 DISCH_THEN(X_CHOOSE_THEN ``d:real->real`` STRIP_ASSUME_TAC) THEN 5711 MP_TAC(ISPECL [``\x:real. ball(x,d x)``, ``a:real``, ``b:real``] 5712 FINE_DIVISION_EXISTS) THEN 5713 ASM_SIMP_TAC std_ss [GAUGE_BALL_DEPENDENT, LEFT_IMP_EXISTS_THM] THEN 5714 X_GEN_TAC ``p:real#(real->bool)->bool`` THEN STRIP_TAC THEN 5715 MP_TAC(MATCH_MP (REWRITE_RULE[IMP_CONJ] OPERATIVE_DIVISION_AND) 5716 (ISPEC ``f:real->real`` OPERATIVE_INTEGRABLE)) THEN 5717 DISCH_THEN(MP_TAC o SPECL 5718 [``IMAGE SND (p:real#(real->bool)->bool)``, ``a:real``, ``b:real``]) THEN 5719 ASM_SIMP_TAC std_ss [DIVISION_OF_TAGGED_DIVISION] THEN 5720 DISCH_THEN(SUBST1_TAC o SYM) THEN REWRITE_TAC[FORALL_IN_IMAGE] THEN 5721 SIMP_TAC std_ss [FORALL_PROD] THEN 5722 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 5723 UNDISCH_TAC `` p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 5724 FIRST_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 5725 STRIP_TAC THEN UNDISCH_TAC `` !(x :real) (k :real -> bool). 5726 (x,k) IN (p :real # (real -> bool) -> bool) ==> 5727 x IN k /\ k SUBSET interval [((a :real),(b :real))] /\ 5728 ?(a :real) (b :real). k = interval [(a,b)]`` THEN 5729 UNDISCH_TAC ``(\x. ball (x,d x)) FINE p`` THEN DISCH_TAC THEN 5730 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 5731 SIMP_TAC std_ss [AND_IMP_INTRO, GSYM FORALL_AND_THM] THEN 5732 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``k:real->bool``]) THEN 5733 ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[SUBSET_DEF]); 5734 5735(* ------------------------------------------------------------------------- *) 5736(* Second FCT or existence of antiderivative. *) 5737(* ------------------------------------------------------------------------- *) 5738 5739val INTEGRAL_HAS_VECTOR_DERIVATIVE_POINTWISE = store_thm ("INTEGRAL_HAS_VECTOR_DERIVATIVE_POINTWISE", 5740 ``!f:real->real a b x. 5741 f integrable_on interval[a,b] /\ x IN interval[a,b] /\ 5742 f continuous (at x within interval[a,b]) 5743 ==> ((\u. integral (interval [a,u]) f) has_vector_derivative f x) 5744 (at x within interval [a,b])``, 5745 REWRITE_TAC[IN_INTERVAL] THEN REPEAT STRIP_TAC THEN 5746 REWRITE_TAC[has_vector_derivative, HAS_DERIVATIVE_WITHIN_ALT] THEN 5747 CONJ_TAC THENL 5748 [SIMP_TAC std_ss [linear] THEN 5749 CONJ_TAC THEN REAL_ARITH_TAC, 5750 ALL_TAC] THEN 5751 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 5752 UNDISCH_TAC ``f continuous (at x within interval [(a,b)])`` THEN DISCH_TAC THEN 5753 FIRST_ASSUM(MP_TAC o REWRITE_RULE [continuous_within]) THEN 5754 DISCH_THEN(MP_TAC o SPEC ``e:real``) THEN 5755 ASM_REWRITE_TAC[IN_INTERVAL, dist] THEN 5756 STRIP_TAC THEN EXISTS_TAC ``d:real`` THEN 5757 ASM_REWRITE_TAC[] THEN X_GEN_TAC ``y:real`` THEN STRIP_TAC THEN 5758 SIMP_TAC std_ss [] THEN 5759 DISJ_CASES_TAC(REAL_ARITH ``x <= y \/ y <= x:real``) THENL 5760 [ASM_SIMP_TAC std_ss [REAL_ARITH ``x <= y ==> (abs(y - x) = y - x:real)``], 5761 ONCE_REWRITE_TAC[REAL_ARITH 5762 ``fy - fx - (x - y) * c:real = -(fx - fy - (y - x) * c)``] THEN 5763 ASM_SIMP_TAC std_ss [ABS_NEG, REAL_ARITH ``x <= y ==> (abs(x - y) = y - x:real)``]] THEN 5764 ASM_SIMP_TAC std_ss [GSYM CONTENT_CLOSED_INTERVAL] THEN MATCH_MP_TAC HAS_INTEGRAL_BOUND THEN 5765 EXISTS_TAC ``(\u. f(u) - f(x)):real->real`` THEN 5766 (ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE] THEN CONJ_TAC THENL 5767 [ALL_TAC, 5768 REPEAT STRIP_TAC THEN 5769 MATCH_MP_TAC REAL_LT_IMP_LE THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 5770 REPEAT(POP_ASSUM MP_TAC) THEN 5771 SIMP_TAC std_ss [IN_INTERVAL] THEN 5772 REAL_ARITH_TAC] THEN 5773 ONCE_REWRITE_TAC [METIS [] ``(\u:real. f u - (f:real->real) x) = (\u:real. f u - (\u. f x) u)``] THEN 5774 MATCH_MP_TAC HAS_INTEGRAL_SUB THEN REWRITE_TAC[HAS_INTEGRAL_CONST]) THENL 5775 [SUBGOAL_THEN 5776 ``(integral(interval[a,x]) f + integral(interval[x,y]) f = 5777 integral(interval[a,y]) f) /\ 5778 ((f:real->real) has_integral integral(interval[x,y]) f) 5779 (interval[x,y])`` 5780 (fn th => METIS_TAC[th, 5781 REAL_ARITH ``(a + b = c:real) ==> (c - a = b:real)``]), 5782 SUBGOAL_THEN 5783 ``(integral(interval[a,y]) f + integral(interval[y,x]) f = 5784 integral(interval[a,x]) f) /\ 5785 ((f:real->real) has_integral integral(interval[y,x]) f) 5786 (interval[y,x])`` 5787 (fn th => METIS_TAC[th, 5788 REAL_ARITH ``(a + b = c:real) ==> (c - a = b:real)``])] THEN 5789 (CONJ_TAC THENL 5790 [MATCH_MP_TAC INTEGRAL_COMBINE, 5791 MATCH_MP_TAC INTEGRABLE_INTEGRAL] THEN 5792 ASM_REWRITE_TAC[] THEN 5793 MATCH_MP_TAC INTEGRABLE_SUBINTERVAL THEN 5794 MAP_EVERY EXISTS_TAC [``a:real``, ``b:real``] THEN 5795 ASM_SIMP_TAC std_ss [INTEGRABLE_CONTINUOUS, SUBSET_INTERVAL, REAL_LE_REFL] THEN 5796 ASM_REAL_ARITH_TAC)); 5797 5798val INTEGRAL_HAS_VECTOR_DERIVATIVE = store_thm ("INTEGRAL_HAS_VECTOR_DERIVATIVE", 5799 ``!f:real->real a b. 5800 f continuous_on interval[a,b] 5801 ==> !x. x IN interval[a,b] 5802 ==> ((\u. integral (interval[a,u]) f) has_vector_derivative f(x)) 5803 (at x within interval[a,b])``, 5804 REPEAT STRIP_TAC THEN 5805 MATCH_MP_TAC INTEGRAL_HAS_VECTOR_DERIVATIVE_POINTWISE THEN 5806 ASM_MESON_TAC[INTEGRABLE_CONTINUOUS, CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN]); 5807 5808val ANTIDERIVATIVE_CONTINUOUS = store_thm ("ANTIDERIVATIVE_CONTINUOUS", 5809 ``!f:real->real a b. 5810 f continuous_on interval[a,b] 5811 ==> ?g. !x. x IN interval[a,b] 5812 ==> (g has_vector_derivative f(x)) 5813 (at x within interval[a,b])``, 5814 METIS_TAC[INTEGRAL_HAS_VECTOR_DERIVATIVE]); 5815 5816(* ------------------------------------------------------------------------- *) 5817(* General "twiddling" for interval-to-interval function image. *) 5818(* ------------------------------------------------------------------------- *) 5819 5820val lemma0 = prove ( 5821 ``(!x k. (x,k) IN IMAGE (\(x,k). f x,g k) p ==> P x k) <=> 5822 (!x k. (x,k) IN p ==> P (f x) (g k))``, 5823 SIMP_TAC std_ss [IN_IMAGE, EXISTS_PROD, PAIR_EQ] THEN MESON_TAC[]); 5824 5825val lemma1 = prove ( 5826 ``{k | ?x. (x,k) IN p} = IMAGE SND p``, 5827 SIMP_TAC std_ss [EXTENSION, EXISTS_PROD, IN_IMAGE, GSPECIFICATION] THEN 5828 MESON_TAC[]); 5829 5830val lemma2 = prove ( 5831 ``(SND o (\(x,k). f x,g k)) = (g o SND)``, 5832 SIMP_TAC std_ss [FUN_EQ_THM, FORALL_PROD, o_DEF]); 5833 5834val HAS_INTEGRAL_TWIDDLE = store_thm ("HAS_INTEGRAL_TWIDDLE", 5835 ``!f:real->real (g:real->real) h r i a b. 5836 &0 < r /\ 5837 (!x. h(g x) = x) /\ (!x. g(h x) = x) /\ (!x. g continuous at x) /\ 5838 (!u v. ?w z. IMAGE g (interval[u,v]) = interval[w,z]) /\ 5839 (!u v. ?w z. IMAGE h (interval[u,v]) = interval[w,z]) /\ 5840 (!u v. content(IMAGE g (interval[u,v])) = r * content(interval[u,v])) /\ 5841 (f has_integral i) (interval[a,b]) 5842 ==> ((\x. f(g x)) has_integral (inv r) * i) (IMAGE h (interval[a,b]))``, 5843 REPEAT GEN_TAC THEN ASM_CASES_TAC ``interval[a:real,b] = {}`` THEN 5844 ASM_SIMP_TAC std_ss [IMAGE_EMPTY, IMAGE_INSERT, HAS_INTEGRAL_EMPTY_EQ, REAL_MUL_RZERO] THEN 5845 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 5846 REWRITE_TAC[has_integral] THEN 5847 ASM_REWRITE_TAC[has_integral_def, has_integral_compact_interval] THEN 5848 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 5849 FIRST_X_ASSUM(MP_TAC o SPEC ``e * r:real``) THEN 5850 ASM_SIMP_TAC std_ss [REAL_LT_MUL] THEN 5851 DISCH_THEN(X_CHOOSE_THEN ``d:real->real->bool`` STRIP_ASSUME_TAC) THEN 5852 EXISTS_TAC ``\x y:real. (d:real->real->bool) (g x) (g y)`` THEN 5853 CONJ_TAC THENL 5854 [UNDISCH_TAC ``gauge d`` THEN DISCH_TAC THEN 5855 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [gauge_def]) THEN 5856 SIMP_TAC std_ss [gauge_def, IN_DEF, FORALL_AND_THM] THEN 5857 STRIP_TAC THEN X_GEN_TAC ``x:real`` THEN 5858 SUBGOAL_THEN ``(\y:real. (d:real->real->bool) (g x) (g y)) = 5859 {y | g y IN (d (g x))}`` SUBST1_TAC 5860 THENL [SET_TAC[], ASM_SIMP_TAC std_ss [CONTINUOUS_OPEN_PREIMAGE_UNIV]], 5861 ALL_TAC] THEN 5862 X_GEN_TAC ``p:real#(real->bool)->bool`` THEN STRIP_TAC THEN 5863 FIRST_X_ASSUM(MP_TAC o SPEC 5864 ``IMAGE (\(x,k). (g:real->real) x, IMAGE g k) p``) THEN 5865 KNOW_TAC ``IMAGE (\((x :real),(k :real -> bool)). ((g :real -> real) x,IMAGE g k)) 5866 (p :real # (real -> bool) -> bool) tagged_division_of 5867 interval [((a :real),(b :real))] /\ 5868 (d :real -> real -> bool) FINE 5869 IMAGE (\((x :real),(k :real -> bool)). (g x,IMAGE g k)) p `` THENL 5870 [CONJ_TAC THENL 5871 [ALL_TAC, 5872 UNDISCH_TAC ``(\(x :real) (y :real). 5873 (d :real -> real -> bool) ((g :real -> real) x) (g y)) FINE 5874 (p :real # (real -> bool) -> bool)`` THEN DISCH_TAC THEN 5875 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 5876 SIMP_TAC std_ss [FINE, lemma0] THEN 5877 STRIP_TAC THEN REPEAT GEN_TAC THEN DISCH_THEN(ANTE_RES_THEN MP_TAC) THEN 5878 ASM_SET_TAC[]] THEN 5879 SUBGOAL_THEN 5880 ``interval[a,b] = IMAGE ((g:real->real) o h) (interval[a,b])`` 5881 SUBST1_TAC THENL [SIMP_TAC std_ss [o_DEF] THEN ASM_SET_TAC[], ALL_TAC] THEN 5882 SUBGOAL_THEN ``?u v. IMAGE (h:real->real) (interval[a,b]) = 5883 interval[u,v]`` 5884 (REPEAT_TCL CHOOSE_THEN 5885 (fn th => SUBST_ALL_TAC th THEN ASSUME_TAC th)) THENL 5886 [METIS_TAC[], ALL_TAC] THEN 5887 UNDISCH_TAC ``p tagged_division_of interval [(u,v)]`` THEN DISCH_TAC THEN 5888 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 5889 SIMP_TAC std_ss [TAGGED_DIVISION_OF, IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 5890 SIMP_TAC std_ss [lemma0] THEN REWRITE_TAC[AND_IMP_INTRO, GSYM CONJ_ASSOC] THEN 5891 REPEAT GEN_TAC THEN STRIP_TAC THEN CONJ_TAC THENL 5892 [ASM_SIMP_TAC std_ss [IMAGE_FINITE], ALL_TAC] THEN 5893 CONJ_TAC THENL 5894 [MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN 5895 DISCH_TAC THEN 5896 UNDISCH_TAC 5897 `` !x:real k. 5898 (x,k) IN p ==> 5899 x IN k /\ k SUBSET interval [(u,v)] /\ 5900 ?a b. k = interval [(a,b)]`` THEN 5901 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``k:real->bool``]) THEN 5902 ASM_SIMP_TAC std_ss [] THEN 5903 REPEAT(MATCH_MP_TAC MONO_AND THEN CONJ_TAC) THENL 5904 [SET_TAC[], 5905 REWRITE_TAC[IMAGE_COMPOSE] THEN ASM_SET_TAC[], 5906 STRIP_TAC THEN ASM_REWRITE_TAC[]], 5907 ALL_TAC] THEN 5908 CONJ_TAC THENL 5909 [ALL_TAC, 5910 ASM_REWRITE_TAC[IMAGE_COMPOSE] THEN FIRST_X_ASSUM(SUBST1_TAC o SYM) THEN 5911 SIMP_TAC std_ss [lemma1, GSYM IMAGE_COMPOSE, lemma2] THEN 5912 METIS_TAC [IMAGE_COMPOSE, GSYM IMAGE_BIGUNION, ETA_AX]] THEN 5913 MAP_EVERY X_GEN_TAC [``x1:real``, ``k1:real->bool``] THEN DISCH_TAC THEN 5914 ONCE_REWRITE_TAC [REAL_ARITH ``(a <> b) = ~(a = b:real)``, GSYM DE_MORGAN_THM] THEN 5915 MAP_EVERY X_GEN_TAC [``x2:real``, ``k2:real->bool``] THEN 5916 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o REWRITE_RULE [GSYM PAIR_EQ])) THEN 5917 DISCH_TAC THEN 5918 UNDISCH_TAC 5919 ``!x1:real k1:real->bool. 5920 (x1,k1) IN p ==> 5921 !x2 k2. 5922 (x2,k2) IN p /\ (x1 <> x2 \/ k1 <> k2) ==> 5923 (interior k1 INTER interior k2 = {})`` THEN 5924 DISCH_THEN(MP_TAC o SPECL [``x1:real``, ``k1:real->bool``]) THEN 5925 ASM_REWRITE_TAC[] THEN 5926 DISCH_THEN(MP_TAC o SPECL [``x2:real``, ``k2:real->bool``]) THEN 5927 ASM_REWRITE_TAC[] THEN 5928 KNOW_TAC ``((x1 :real) <> (x2 :real)) \/ 5929 ((k1 :real -> bool) <> (k2 :real -> bool))`` THENL 5930 [METIS_TAC[PAIR_EQ], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 5931 MATCH_MP_TAC(SET_RULE 5932 ``interior(IMAGE f s) SUBSET IMAGE f (interior s) /\ 5933 interior(IMAGE f t) SUBSET IMAGE f (interior t) /\ 5934 (!x y. (f x = f y) ==> (x = y)) 5935 ==> (interior s INTER interior t = {}) 5936 ==> (interior(IMAGE f s) INTER interior(IMAGE f t) = {})``) THEN 5937 REPEAT CONJ_TAC THEN TRY(MATCH_MP_TAC INTERIOR_IMAGE_SUBSET) THEN 5938 ASM_MESON_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 5939 W(fn (asl,w) => MP_TAC(PART_MATCH (lhand o rand) SUM_IMAGE 5940 (lhand(rand(lhand(lhand w)))))) THEN 5941 KNOW_TAC ``(!(x :real # (real -> bool)) (y :real # (real -> bool)). 5942 x IN (p :real # (real -> bool) -> bool) /\ y IN p /\ 5943 ((\((x :real),(k :real -> bool)). ((g :real -> real) x,IMAGE g k)) 5944 x = 5945 (\((x :real),(k :real -> bool)). (g x,IMAGE g k)) y) ==> 5946 (x = y))`` THENL 5947 [FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 5948 ASM_SIMP_TAC std_ss [FORALL_PROD, PAIR_EQ] THEN 5949 REPEAT GEN_TAC THEN DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 5950 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 5951 MATCH_MP_TAC MONO_AND THEN CONJ_TAC THEN ASM_SET_TAC[], 5952 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 5953 DISCH_THEN SUBST1_TAC THEN SIMP_TAC std_ss [o_DEF, LAMBDA_PROD] THEN 5954 DISCH_TAC THEN MATCH_MP_TAC REAL_LT_LCANCEL_IMP THEN 5955 EXISTS_TAC ``abs r:real`` THEN ASM_SIMP_TAC std_ss [REAL_ARITH ``&0 < x ==> &0 < abs x:real``] THEN 5956 REWRITE_TAC[GSYM ABS_MUL] THEN ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE, 5957 REAL_ARITH ``0 < r ==> (abs r = r:real)``] THEN 5958 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 5959 ``x < a * b ==> (x = y) ==> y < b * a:real``)) THEN 5960 AP_TERM_TAC THEN REWRITE_TAC[REAL_SUB_LDISTRIB] THEN 5961 ASM_SIMP_TAC std_ss [REAL_MUL_ASSOC, REAL_MUL_RINV, REAL_LT_IMP_NE] THEN 5962 REWRITE_TAC[REAL_MUL_LID, GSYM SUM_LMUL] THEN 5963 AP_THM_TAC THEN AP_TERM_TAC THEN MATCH_MP_TAC SUM_EQ THEN 5964 SIMP_TAC std_ss [FORALL_PROD, REAL_MUL_ASSOC] THEN 5965 REPEAT STRIP_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN 5966 METIS_TAC[TAGGED_DIVISION_OF]); 5967 5968(* ------------------------------------------------------------------------- *) 5969(* Special case of a basic affine transformation. *) 5970(* ------------------------------------------------------------------------- *) 5971 5972val INTERVAL_IMAGE_AFFINITY_INTERVAL = store_thm ("INTERVAL_IMAGE_AFFINITY_INTERVAL", 5973 ``!a b m c. ?u v. IMAGE (\x. m * x + c) (interval[a,b]) = interval[u,v]``, 5974 REWRITE_TAC[IMAGE_AFFINITY_INTERVAL] THEN 5975 METIS_TAC[EMPTY_AS_INTERVAL]); 5976 5977val CONTENT_IMAGE_AFFINITY_INTERVAL = store_thm ("CONTENT_IMAGE_AFFINITY_INTERVAL", 5978 ``!a b:real m c. 5979 content(IMAGE (\x. m * x + c) (interval[a,b])) = 5980 (abs m) pow (1:num) * content(interval[a,b])``, 5981 REPEAT STRIP_TAC THEN REWRITE_TAC[IMAGE_AFFINITY_INTERVAL] THEN 5982 COND_CASES_TAC THEN ASM_REWRITE_TAC[CONTENT_EMPTY, REAL_MUL_RZERO] THEN 5983 RULE_ASSUM_TAC(REWRITE_RULE[INTERVAL_NE_EMPTY]) THEN COND_CASES_TAC THEN 5984 W(fn (asl,w) => MP_TAC(PART_MATCH (lhand o rand) CONTENT_CLOSED_INTERVAL 5985 (lhs w))) THENL 5986 [KNOW_TAC ``m * a + c <= m * b + c:real`` THENL 5987 [MATCH_MP_TAC REAL_LE_ADD2 THEN REWRITE_TAC [REAL_LE_REFL] THEN 5988 MATCH_MP_TAC REAL_LE_LMUL_IMP THEN ASM_REWRITE_TAC [], 5989 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 5990 DISCH_THEN SUBST1_TAC THEN ASM_SIMP_TAC std_ss [abs, CONTENT_CLOSED_INTERVAL, POW_1] THEN 5991 REAL_ARITH_TAC, ALL_TAC] THEN 5992 KNOW_TAC ``m * b + c <= m * a + c:real`` THENL 5993 [MATCH_MP_TAC REAL_LE_ADD2 THEN REWRITE_TAC [REAL_LE_REFL] THEN 5994 ONCE_REWRITE_TAC[REAL_ARITH ``m * b <= m * a <=> -m * a <= -m * b:real``] THEN 5995 MATCH_MP_TAC REAL_LE_LMUL_IMP THEN ASM_REAL_ARITH_TAC, 5996 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 5997 DISCH_THEN SUBST1_TAC THEN 5998 ASM_SIMP_TAC std_ss [abs, CONTENT_CLOSED_INTERVAL, POW_1] THEN 5999 REAL_ARITH_TAC); 6000 6001val HAS_INTEGRAL_AFFINITY = store_thm ("HAS_INTEGRAL_AFFINITY", 6002 ``!f:real->real i a b m c. 6003 (f has_integral i) (interval[a,b]) /\ ~(m = &0) 6004 ==> ((\x. f(m * x + c)) has_integral 6005 (inv(abs(m) pow (1:num)) * i)) 6006 (IMAGE (\x. inv m * x + -(inv(m) * c)) (interval[a,b]))``, 6007 REPEAT STRIP_TAC THEN 6008 ONCE_REWRITE_TAC [METIS [] ``(m * x + c) = (\x:real. (m * x + c)) x``] THEN 6009 MATCH_MP_TAC HAS_INTEGRAL_TWIDDLE THEN 6010 ASM_SIMP_TAC std_ss [INTERVAL_IMAGE_AFFINITY_INTERVAL, GSYM ABS_NZ, 6011 REAL_POW_LT, CONTENT_IMAGE_AFFINITY_INTERVAL] THEN 6012 ASM_SIMP_TAC std_ss [CONTINUOUS_CMUL, CONTINUOUS_AT_ID, CONTINUOUS_CONST, 6013 CONTINUOUS_ADD] THEN 6014 REWRITE_TAC[REAL_ADD_LDISTRIB, REAL_MUL_ASSOC, REAL_MUL_RNEG] THEN 6015 ASM_SIMP_TAC std_ss [REAL_MUL_LINV, REAL_MUL_RINV] THEN 6016 CONJ_TAC THEN REAL_ARITH_TAC); 6017 6018val INTEGRABLE_AFFINITY = store_thm ("INTEGRABLE_AFFINITY", 6019 ``!f:real->real a b m c. 6020 f integrable_on interval[a,b] /\ ~(m = &0) 6021 ==> (\x. f(m * x + c)) integrable_on 6022 (IMAGE (\x. inv m * x + -(inv(m) * c)) (interval[a,b]))``, 6023 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_AFFINITY]); 6024 6025(* ------------------------------------------------------------------------- *) 6026(* Special case of stretching coordinate axes separately. *) 6027(* ------------------------------------------------------------------------- *) 6028 6029Theorem CONTENT_IMAGE_STRETCH_INTERVAL : 6030 !a b:real m. 6031 content(IMAGE (\x. m 1 * x) (interval[a,b]):real->bool) = 6032 abs(product((1:num)..(1:num)) m) * content(interval[a,b]) 6033Proof 6034 rpt GEN_TAC >> REWRITE_TAC [content, IMAGE_EQ_EMPTY] 6035 >> COND_CASES_TAC >> ASM_REWRITE_TAC [REAL_MUL_RZERO] 6036 >> ASM_SIMP_TAC std_ss [SIMP_RULE std_ss [] IMAGE_STRETCH_INTERVAL] 6037 >> RULE_ASSUM_TAC (REWRITE_RULE [INTERVAL_NE_EMPTY]) 6038(* TODO: a common lemma between min,max *) 6039 >> Know `!x:real y. min x y <= max x y` 6040 >- (RW_TAC std_ss [min_def, max_def] \\ 6041 MATCH_MP_TAC REAL_LT_IMP_LE >> fs [real_lte]) 6042 >> DISCH_THEN (ASSUME_TAC o (Q.SPECL [`(m :num->real) 1 * a`, 6043 `(m :num->real) 1 * b`])) 6044 >> ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND] 6045(* TODO: a common lemma between min,max,abs *) 6046 >> Know `!x:real y. max x y - min x y = abs (y - x)` 6047 >- (RW_TAC real_ss [min_def, max_def, abs] >> REAL_ASM_ARITH_TAC) 6048 >> Rewr' 6049 >> ASM_REWRITE_TAC [GSYM REAL_SUB_LDISTRIB, ABS_MUL] 6050 >> ASM_SIMP_TAC std_ss [NUMSEG_SING, PRODUCT_SING, FINITE_NUMSEG, 6051 REAL_ARITH ``a <= b ==> (abs(b - a) = b - a:real)``] 6052QED 6053 6054Theorem HAS_INTEGRAL_STRETCH : 6055 !f:real->real i m a b. 6056 (f has_integral i) (interval[a,b]) /\ 6057 ~(m (1:num) = &0) 6058 ==> ((\x:real. f(m (1:num) * x)) has_integral 6059 (inv(abs(product((1:num)..(1:num)) m)) * i)) 6060 (IMAGE (\x. inv(m 1) * x) (interval[a,b])) 6061Proof 6062 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_TWIDDLE THEN 6063 SIMP_TAC std_ss [] THEN 6064 ASM_SIMP_TAC real_ss [REAL_MUL_ASSOC, REAL_MUL_LINV, REAL_MUL_RINV, REAL_MUL_LID] THEN 6065 ASM_SIMP_TAC real_ss [GSYM ABS_NZ, PRODUCT_EQ_0_NUMSEG] THEN 6066 CONJ_TAC THENL [GEN_TAC THEN ASM_CASES_TAC ``x = 1:num`` THENL 6067 [ASM_SIMP_TAC arith_ss [], ALL_TAC] THEN 6068 ONCE_REWRITE_TAC [TAUT `a \/ b \/ c <=> c \/ a \/ b`] THEN DISJ2_TAC THEN 6069 POP_ASSUM MP_TAC THEN SIMP_TAC arith_ss [NOT_LESS_EQUAL], ALL_TAC] THEN 6070 CONJ_TAC THENL 6071 [GEN_TAC THEN MATCH_MP_TAC LINEAR_CONTINUOUS_AT THEN 6072 SIMP_TAC std_ss [linear] THEN REAL_ARITH_TAC, ALL_TAC] THEN 6073 KNOW_TAC ``!(u :real) (v :real). 6074 content (IMAGE ($* (m (1 :num))) (interval [(u,v)])) = 6075 abs (product ((1 :num) .. (1 :num)) m) * content (interval [(u,v)])`` THENL 6076 [SIMP_TAC std_ss [GSYM CONTENT_IMAGE_STRETCH_INTERVAL] THEN 6077 METIS_TAC [], DISCH_TAC] THEN ASM_REWRITE_TAC [] THEN 6078 REPEAT STRIP_TAC THENL 6079 [ALL_TAC, 6080 SIMP_TAC std_ss [SIMP_RULE std_ss [] IMAGE_STRETCH_INTERVAL] THEN 6081 METIS_TAC[EMPTY_AS_INTERVAL]] THEN 6082 METIS_TAC [SIMP_RULE std_ss [] IMAGE_STRETCH_INTERVAL] 6083QED 6084 6085val INTEGRABLE_STRETCH = store_thm ("INTEGRABLE_STRETCH", 6086 ``!f:real->real m a b. 6087 f integrable_on interval[a,b] /\ ~(m (1:num) = &0) 6088 ==> (\x:real. f(m (1:num) * x)) integrable_on 6089 (IMAGE (\x. inv(m 1) * x) (interval[a,b]))``, 6090 REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_STRETCH]); 6091 6092(* ------------------------------------------------------------------------- *) 6093(* Even more special cases. *) 6094(* ------------------------------------------------------------------------- *) 6095 6096val HAS_INTEGRAL_REFLECT_LEMMA = store_thm ("HAS_INTEGRAL_REFLECT_LEMMA", 6097 ``!f:real->real i a b. 6098 (f has_integral i) (interval[a,b]) 6099 ==> ((\x. f(-x)) has_integral i) (interval[-b,-a])``, 6100 REPEAT STRIP_TAC THEN 6101 FIRST_ASSUM(MP_TAC o C CONJ (REAL_ARITH ``~(- &1 = &0:real)``)) THEN 6102 DISCH_THEN(MP_TAC o MATCH_MP HAS_INTEGRAL_AFFINITY) THEN 6103 DISCH_THEN(MP_TAC o SPEC ``0:real``) THEN 6104 REWRITE_TAC[IMAGE_AFFINITY_INTERVAL] THEN 6105 SIMP_TAC std_ss [REAL_MUL_RZERO, ABS_NEG, ABS_1] THEN 6106 KNOW_TAC ``~(&0 <= inv (- &1:real))`` THENL 6107 [KNOW_TAC ``-1 <> 0:real`` THENL [REAL_ARITH_TAC, DISCH_TAC] THEN 6108 REWRITE_TAC [REAL_NOT_LE] THEN 6109 ONCE_REWRITE_TAC [GSYM REAL_LT_NEG] THEN ASM_SIMP_TAC std_ss [REAL_NEG_INV] THEN 6110 SIMP_TAC std_ss [REAL_NEG_NEG, REAL_NEG_0, REAL_INV1] THEN REAL_ARITH_TAC, 6111 DISCH_TAC] THEN FULL_SIMP_TAC std_ss [] THEN 6112 KNOW_TAC ``inv (-1) = -1:real`` THENL 6113 [KNOW_TAC ``-1 <> 0:real`` THENL [REAL_ARITH_TAC, DISCH_TAC] THEN 6114 ONCE_REWRITE_TAC [GSYM REAL_EQ_NEG] THEN ASM_SIMP_TAC std_ss [REAL_NEG_INV] THEN 6115 SIMP_TAC std_ss [REAL_NEG_NEG, REAL_NEG_0, REAL_INV1] THEN REAL_ARITH_TAC, 6116 DISCH_TAC] THEN 6117 ASM_REWRITE_TAC[ABS_NEG, ABS_N, POW_ONE] THEN 6118 REWRITE_TAC[REAL_MUL_RZERO, REAL_NEG_0] THEN 6119 REWRITE_TAC[REAL_NEG_INV, REAL_INV1] THEN 6120 REWRITE_TAC[REAL_ARITH ``- &1 * x + 0 = -x:real``] THEN 6121 REWRITE_TAC[REAL_MUL_LID] THEN MATCH_MP_TAC EQ_IMPLIES THEN 6122 AP_TERM_TAC THEN POP_ASSUM(K ALL_TAC) THEN 6123 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN CONV_TAC SYM_CONV THEN 6124 POP_ASSUM MP_TAC THEN SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY] THEN 6125 REWRITE_TAC[TAUT `a /\ b /\ c <=> ~(a /\ b ==> ~c)`] THEN 6126 SIMP_TAC std_ss [REAL_LT_NEG]); 6127 6128val HAS_INTEGRAL_REFLECT = store_thm ("HAS_INTEGRAL_REFLECT", 6129 ``!f:real->real i a b. 6130 ((\x. f(-x)) has_integral i) (interval[-b,-a]) <=> 6131 (f has_integral i) (interval[a,b])``, 6132 REPEAT GEN_TAC THEN EQ_TAC THEN 6133 DISCH_THEN(MP_TAC o MATCH_MP HAS_INTEGRAL_REFLECT_LEMMA) THEN 6134 SIMP_TAC std_ss [REAL_NEG_NEG, ETA_AX]); 6135 6136val INTEGRABLE_REFLECT = store_thm ("INTEGRABLE_REFLECT", 6137 ``!f:real->real a b. 6138 (\x. f(-x)) integrable_on (interval[-b,-a]) <=> 6139 f integrable_on (interval[a,b])``, 6140 SIMP_TAC std_ss [integrable_on, HAS_INTEGRAL_REFLECT]); 6141 6142val INTEGRAL_REFLECT = store_thm ("INTEGRAL_REFLECT", 6143 ``!f:real->real a b. 6144 integral (interval[-b,-a]) (\x. f(-x)) = 6145 integral (interval[a,b]) f``, 6146 SIMP_TAC std_ss [integral, HAS_INTEGRAL_REFLECT]); 6147 6148(* ------------------------------------------------------------------------- *) 6149(* Technical lemmas about how many non-trivial intervals of a division a *) 6150(* point can be in (we sometimes need this for bounding sums). *) 6151(* ------------------------------------------------------------------------- *) 6152 6153val lemma = prove ( 6154 ``!f s. (!x y. x IN s /\ y IN s /\ (f x = f y) ==> (x = y)) /\ 6155 FINITE s /\ CARD(IMAGE f s) <= n 6156 ==> CARD(s) <= n``, 6157 MESON_TAC[CARD_IMAGE_INJ]); 6158 6159Theorem DIVISION_COMMON_POINT_BOUND : 6160 !d s:real->bool x. 6161 d division_of s 6162 ==> CARD {k | k IN d /\ ~(content k = &0) /\ x IN k} 6163 <= 2 EXP (1:num) 6164Proof 6165 REPEAT STRIP_TAC THEN 6166 SUBGOAL_THEN ``!k. k IN d ==> ?a b:real. interval[a,b] = k`` MP_TAC THENL 6167 [ASM_MESON_TAC[division_of], ALL_TAC] THEN 6168 SIMP_TAC std_ss [RIGHT_IMP_EXISTS_THM, SKOLEM_THM, LEFT_IMP_EXISTS_THM] THEN 6169 MAP_EVERY X_GEN_TAC 6170 [``A:(real->bool)->real``, ``B:(real->bool)->real``] THEN 6171 STRIP_TAC THEN MATCH_MP_TAC(ISPEC 6172 ``\d. ((x:real) = (A:(real->bool)->real)(d)):bool`` 6173 lemma) THEN 6174 REPEAT CONJ_TAC THENL 6175 [ALL_TAC, 6176 ONCE_REWRITE_TAC [METIS [] ``{k | k IN d /\ content k <> 0 /\ x IN k} = 6177 {k | k IN d /\ (\k. content k <> 0 /\ x IN k) k}``] THEN 6178 MATCH_MP_TAC FINITE_RESTRICT THEN ASM_MESON_TAC[division_of], 6179 MATCH_MP_TAC LESS_EQ_TRANS THEN EXISTS_TAC ``CARD univ(:bool)`` THEN CONJ_TAC THENL 6180 [KNOW_TAC ``(IMAGE (\(d :real -> bool). (x :real) = (A :(real -> bool) -> real) d) 6181 {k | k IN (d :(real -> bool) -> bool) /\ content k <> (0 :real) /\ 6182 x IN k}) SUBSET univ(:bool)`` THENL [REWRITE_TAC [SUBSET_UNIV], ALL_TAC] THEN 6183 MATCH_MP_TAC CARD_SUBSET THEN 6184 SIMP_TAC std_ss [FINITE_BOOL], 6185 SIMP_TAC std_ss [FINITE_BOOL, CARD_CART_UNIV, CARD_BOOL, LESS_EQ_REFL]]] THEN 6186 MAP_EVERY X_GEN_TAC [``k:real->bool``, ``l:real->bool``] THEN 6187 SIMP_TAC std_ss [GSPECIFICATION] THEN STRIP_TAC THEN 6188 UNDISCH_TAC ``d division_of s`` THEN DISCH_TAC THEN 6189 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 6190 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 6191 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 6192 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 6193 DISCH_THEN(MP_TAC o SPECL [``k:real->bool``, ``l:real->bool``]) THEN 6194 ASM_REWRITE_TAC[GSYM INTERIOR_INTER] THEN 6195 MATCH_MP_TAC(TAUT `~q ==> (~p ==> q) ==> p`) THEN 6196 MAP_EVERY UNDISCH_TAC 6197 [``(x:real) IN k``, ``(x:real) IN l``, 6198 ``~(content(k:real->bool) = &0)``, 6199 ``~(content(l:real->bool) = &0)``] THEN 6200 SUBGOAL_THEN 6201 ``(k = interval[A k:real,B k]) /\ (l = interval[A l,B l])`` 6202 (CONJUNCTS_THEN SUBST1_TAC) 6203 THENL [ASM_MESON_TAC[], REWRITE_TAC[INTER_INTERVAL]] THEN 6204 SIMP_TAC std_ss [CONTENT_EQ_0_INTERIOR, INTERIOR_CLOSED_INTERVAL] THEN 6205 SIMP_TAC std_ss [IN_INTERVAL, INTERVAL_NE_EMPTY] THEN 6206 UNDISCH_TAC ``(x = A k) <=> (x = (A:(real->bool)->real) l)`` THEN 6207 REWRITE_TAC[min_def, max_def] THEN 6208 Cases_on `A k <= A l` >> Cases_on `B k <= B l` >> rw [] 6209 >- (`A l < x \/ (A l = x)` by PROVE_TAC [REAL_LE_LT] 6210 >- (MATCH_MP_TAC REAL_LTE_TRANS >> Q.EXISTS_TAC `x` >> art []) \\ 6211 METIS_TAC []) \\ 6212 `A k < x \/ (A k = x)` by PROVE_TAC [REAL_LE_LT] 6213 >- (MATCH_MP_TAC REAL_LTE_TRANS >> Q.EXISTS_TAC `x` >> art []) \\ 6214 METIS_TAC [] 6215QED 6216 6217val lemma = prove ( 6218 ``!f s. (!x y. x IN s /\ y IN s /\ (f x = f y) ==> (x = y)) /\ 6219 FINITE s /\ CARD(IMAGE f s) <= n 6220 ==> CARD(s) <= n``, 6221 MESON_TAC[CARD_IMAGE_INJ]); 6222 6223val TAGGED_PARTIAL_DIVISION_COMMON_POINT_BOUND = store_thm ("TAGGED_PARTIAL_DIVISION_COMMON_POINT_BOUND", 6224 ``!p s:real->bool y. 6225 p tagged_partial_division_of s 6226 ==> CARD {(x,k) | (x,k) IN p /\ y IN k /\ ~(content k = &0)} 6227 <= 2 EXP (1:num)``, 6228 REPEAT STRIP_TAC THEN MATCH_MP_TAC(ISPEC ``SND`` lemma) THEN 6229 REPEAT CONJ_TAC THENL 6230 [SIMP_TAC std_ss [IMP_CONJ, FORALL_IN_GSPEC, RIGHT_FORALL_IMP_THM, PAIR_EQ] THEN 6231 MAP_EVERY X_GEN_TAC [``x1:real``, ``k1:real->bool``] THEN 6232 REPEAT DISCH_TAC THEN X_GEN_TAC ``x2:real`` THEN 6233 REPEAT DISCH_TAC THEN 6234 UNDISCH_TAC ``p tagged_partial_division_of s`` THEN DISCH_TAC THEN 6235 FIRST_ASSUM(MP_TAC o REWRITE_RULE [tagged_partial_division_of]) THEN 6236 DISCH_THEN(MP_TAC o SPECL 6237 [``x1:real``, ``k1:real->bool``, ``x2:real``, ``k1:real->bool``] o 6238 CONJUNCT2 o CONJUNCT2) THEN 6239 ASM_SIMP_TAC std_ss [PAIR_EQ] THEN 6240 MATCH_MP_TAC(TAUT `~q ==> (~p ==> q) ==> p`) THEN 6241 SIMP_TAC std_ss [INTER_ACI] THEN 6242 ASM_MESON_TAC[CONTENT_EQ_0_INTERIOR, tagged_partial_division_of], 6243 MATCH_MP_TAC FINITE_SUBSET THEN 6244 EXISTS_TAC ``p:real#(real->bool)->bool`` THEN CONJ_TAC THENL 6245 [ASM_MESON_TAC[tagged_partial_division_of], 6246 SIMP_TAC std_ss [LAMBDA_PAIR] THEN SET_TAC[]], 6247 FIRST_ASSUM(MP_TAC o MATCH_MP PARTIAL_DIVISION_OF_TAGGED_DIVISION) THEN 6248 DISCH_THEN(MP_TAC o SPEC ``y:real`` o 6249 MATCH_MP DIVISION_COMMON_POINT_BOUND) THEN 6250 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LESS_EQ_TRANS) THEN 6251 KNOW_TAC ``(IMAGE (SND :real # (real -> bool) -> real -> bool) 6252 {(x,k) | (x,k) IN (p :real # (real -> bool) -> bool) /\ (y :real) IN k /\ 6253 content k <> (0 :real)}) SUBSET 6254 {k | k IN IMAGE (SND :real # (real -> bool) -> real -> bool) p /\ 6255 content k <> (0 :real) /\ y IN k}`` THENL 6256 [SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_IMAGE, FORALL_IN_GSPEC] THEN 6257 SIMP_TAC std_ss [GSPECIFICATION, IN_IMAGE, EXISTS_PROD] THEN MESON_TAC[], 6258 ALL_TAC] THEN 6259 MATCH_MP_TAC CARD_SUBSET THEN 6260 ONCE_REWRITE_TAC [METIS [] 6261 ``{k | k IN IMAGE SND p /\ content k <> 0 /\ y IN k} = 6262 {k | k IN IMAGE SND p /\ (\k. content k <> 0 /\ y IN k) k}``] THEN 6263 MATCH_MP_TAC FINITE_RESTRICT THEN MATCH_MP_TAC IMAGE_FINITE THEN 6264 ASM_MESON_TAC[tagged_partial_division_of]]); 6265 6266val TAGGED_PARTIAL_DIVISION_COMMON_TAGS = store_thm ("TAGGED_PARTIAL_DIVISION_COMMON_TAGS", 6267 ``!p s:real->bool x. 6268 p tagged_partial_division_of s 6269 ==> CARD {(x,k) | k | (x,k) IN p /\ ~(content k = &0)} 6270 <= 2 EXP (1:num)``, 6271 REPEAT STRIP_TAC THEN FIRST_ASSUM(MP_TAC o SPEC ``x:real`` o 6272 MATCH_MP TAGGED_PARTIAL_DIVISION_COMMON_POINT_BOUND) THEN 6273 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] LESS_EQ_TRANS) THEN 6274 KNOW_TAC ``{((x :real),k) | 6275 k | (x,k) IN (p :real # (real -> bool) -> bool) /\ 6276 content k <> (0 :real)} SUBSET 6277 {(x',k) | (x',k) IN p /\ x IN k /\ content k <> (0 :real)}`` THENL 6278 [SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC, IN_ELIM_PAIR_THM] THEN 6279 ASM_MESON_TAC[tagged_partial_division_of], ALL_TAC] THEN 6280 MATCH_MP_TAC CARD_SUBSET THEN 6281 MATCH_MP_TAC FINITE_SUBSET THEN 6282 EXISTS_TAC ``p:real#(real->bool)->bool`` THEN CONJ_TAC THENL 6283 [ASM_MESON_TAC[tagged_partial_division_of], 6284 SIMP_TAC std_ss [LAMBDA_PAIR] THEN SET_TAC[]]); 6285 6286(* ------------------------------------------------------------------------- *) 6287(* Integrating characteristic function of an interval. *) 6288(* ------------------------------------------------------------------------- *) 6289 6290val HAS_INTEGRAL_RESTRICT_OPEN_SUBINTERVAL = store_thm ("HAS_INTEGRAL_RESTRICT_OPEN_SUBINTERVAL", 6291 ``!f:real->real a b c d i. 6292 (f has_integral i) (interval[c,d]) /\ 6293 interval[c,d] SUBSET interval[a,b] 6294 ==> ((\x. if x IN interval(c,d) then f x else 0) has_integral i) 6295 (interval[a,b])``, 6296 REPEAT GEN_TAC THEN ASM_CASES_TAC ``interval[c:real,d] = {}`` THENL 6297 [FIRST_ASSUM(MP_TAC o AP_TERM 6298 ``interior:(real->bool)->(real->bool)``) THEN 6299 SIMP_TAC std_ss [INTERIOR_CLOSED_INTERVAL, INTERIOR_EMPTY] THEN 6300 ASM_SIMP_TAC std_ss [NOT_IN_EMPTY, HAS_INTEGRAL_0_EQ, HAS_INTEGRAL_EMPTY_EQ], 6301 ALL_TAC] THEN 6302 ABBREV_TAC ``g:real->real = 6303 \x. if x IN interval(c,d) then f x else 0`` THEN 6304 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 6305 UNDISCH_TAC ``interval [(c,d)] <> {}`` THEN 6306 REWRITE_TAC[TAUT `a ==> b ==> c <=> b /\ a ==> c`] THEN 6307 DISCH_THEN(MP_TAC o MATCH_MP PARTIAL_DIVISION_EXTEND_1) THEN 6308 DISCH_THEN(X_CHOOSE_THEN ``p:(real->bool)->bool`` STRIP_ASSUME_TAC) THEN 6309 MP_TAC(ISPECL 6310 [``lifted((+):real->real->real)``, 6311 ``p:(real->bool)->bool``, 6312 ``a:real``, ``b:real``, 6313 ``\i. if (g:real->real) integrable_on i 6314 then SOME (integral i g) else NONE``] 6315 OPERATIVE_DIVISION) THEN 6316 ASM_SIMP_TAC std_ss [OPERATIVE_INTEGRAL, MONOIDAL_LIFTED, MONOIDAL_REAL_ADD] THEN 6317 SUBGOAL_THEN 6318 ``iterate (lifted (+)) p 6319 (\i. if (g:real->real) integrable_on i 6320 then SOME (integral i g) else NONE) = 6321 SOME i`` 6322 SUBST1_TAC THENL 6323 [ALL_TAC, 6324 COND_CASES_TAC THEN 6325 SIMP_TAC std_ss [FORALL_OPTION, lifted, NOT_NONE_SOME, option_CLAUSES] THEN 6326 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]] THEN 6327 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 6328 FIRST_ASSUM(SUBST1_TAC o MATCH_MP (SET_RULE 6329 ``x IN s ==> (s = x INSERT (s DELETE x))``)) THEN 6330 ASM_SIMP_TAC std_ss [ITERATE_CLAUSES, MONOIDAL_LIFTED, MONOIDAL_REAL_ADD, 6331 FINITE_DELETE, IN_DELETE] THEN 6332 SUBGOAL_THEN ``(g:real->real) integrable_on interval[c,d]`` 6333 ASSUME_TAC THENL 6334 [FIRST_ASSUM(MP_TAC o MATCH_MP HAS_INTEGRAL_INTEGRABLE) THEN 6335 MATCH_MP_TAC INTEGRABLE_SPIKE_INTERIOR THEN 6336 EXPAND_TAC "g" THEN SIMP_TAC std_ss [], 6337 ALL_TAC] THEN 6338 ASM_REWRITE_TAC[] THEN 6339 SUBGOAL_THEN 6340 ``iterate (lifted (+)) (p DELETE interval[c,d]) 6341 (\i. if (g:real->real) integrable_on i 6342 then SOME (integral i g) else NONE) = SOME(0)`` 6343 SUBST1_TAC THENL 6344 [ALL_TAC, 6345 REWRITE_TAC[lifted, REAL_ADD_RID] THEN AP_TERM_TAC THEN 6346 MATCH_MP_TAC INTEGRAL_UNIQUE THEN 6347 MATCH_MP_TAC HAS_INTEGRAL_SPIKE_INTERIOR THEN 6348 EXISTS_TAC ``f:real->real`` THEN 6349 EXPAND_TAC "g" THEN ASM_SIMP_TAC std_ss []] THEN 6350 SIMP_TAC std_ss [GSYM NEUTRAL_REAL_ADD, GSYM NEUTRAL_LIFTED, 6351 MONOIDAL_REAL_ADD] THEN 6352 MATCH_MP_TAC(MATCH_MP ITERATE_EQ_NEUTRAL 6353 (MATCH_MP MONOIDAL_LIFTED(SPEC_ALL MONOIDAL_REAL_ADD))) THEN 6354 SIMP_TAC std_ss [NEUTRAL_LIFTED, NEUTRAL_REAL_ADD, MONOIDAL_REAL_ADD] THEN 6355 X_GEN_TAC ``k:real->bool`` THEN REWRITE_TAC[IN_DELETE] THEN STRIP_TAC THEN 6356 SUBGOAL_THEN ``((g:real->real) has_integral (0)) k`` 6357 (fn th => METIS_TAC[th, integrable_on, INTEGRAL_UNIQUE]) THEN 6358 SUBGOAL_THEN ``?u v:real. k = interval[u,v]`` MP_TAC THENL 6359 [ASM_MESON_TAC[division_of], ALL_TAC] THEN 6360 DISCH_THEN(REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) THEN 6361 MATCH_MP_TAC HAS_INTEGRAL_SPIKE_INTERIOR THEN 6362 EXISTS_TAC ``(\x. 0):real->real`` THEN 6363 REWRITE_TAC[HAS_INTEGRAL_0] THEN X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 6364 UNDISCH_TAC ``p division_of interval [(a,b)]`` THEN DISCH_TAC THEN 6365 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 6366 STRIP_TAC THEN UNDISCH_TAC `` !(k1 :real -> bool) (k2 :real -> bool). 6367 k1 IN (p :(real -> bool) -> bool) /\ k2 IN p /\ k1 <> k2 ==> 6368 (interior k1 INTER interior k2 = ({} :real -> bool))`` THEN 6369 DISCH_THEN(MP_TAC o SPECL 6370 [``interval[c:real,d]``, ``interval[u:real,v]``]) THEN 6371 ASM_REWRITE_TAC[INTERIOR_CLOSED_INTERVAL] THEN 6372 EXPAND_TAC "g" THEN REWRITE_TAC[] THEN COND_CASES_TAC THEN ASM_SET_TAC[]); 6373 6374val HAS_INTEGRAL_RESTRICT_CLOSED_SUBINTERVAL = store_thm ("HAS_INTEGRAL_RESTRICT_CLOSED_SUBINTERVAL", 6375 ``!f:real->real a b c d i. 6376 (f has_integral i) (interval[c,d]) /\ 6377 interval[c,d] SUBSET interval[a,b] 6378 ==> ((\x. if x IN interval[c,d] then f x else 0) has_integral i) 6379 (interval[a,b])``, 6380 REPEAT GEN_TAC THEN 6381 DISCH_THEN(MP_TAC o MATCH_MP HAS_INTEGRAL_RESTRICT_OPEN_SUBINTERVAL) THEN 6382 MATCH_MP_TAC(REWRITE_RULE[TAUT `a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] 6383 HAS_INTEGRAL_SPIKE) THEN 6384 EXISTS_TAC ``interval[c:real,d] DIFF interval(c,d)`` THEN 6385 REWRITE_TAC[NEGLIGIBLE_FRONTIER_INTERVAL] THEN REWRITE_TAC[IN_DIFF] THEN 6386 MP_TAC(ISPECL [``c:real``, ``d:real``] INTERVAL_OPEN_SUBSET_CLOSED) THEN 6387 SET_TAC[]); 6388 6389val HAS_INTEGRAL_RESTRICT_CLOSED_SUBINTERVALS_EQ = store_thm ("HAS_INTEGRAL_RESTRICT_CLOSED_SUBINTERVALS_EQ", 6390 ``!f:real->real a b c d i. 6391 interval[c,d] SUBSET interval[a,b] 6392 ==> (((\x. if x IN interval[c,d] then f x else 0) has_integral i) 6393 (interval[a,b]) <=> 6394 (f has_integral i) (interval[c,d]))``, 6395 REPEAT STRIP_TAC THEN ASM_CASES_TAC ``interval[c:real,d] = {}`` THENL 6396 [ASM_SIMP_TAC std_ss [NOT_IN_EMPTY, HAS_INTEGRAL_0_EQ, HAS_INTEGRAL_EMPTY_EQ], 6397 ALL_TAC] THEN 6398 EQ_TAC THEN DISCH_TAC THEN 6399 ASM_SIMP_TAC std_ss [HAS_INTEGRAL_RESTRICT_CLOSED_SUBINTERVAL] THEN 6400 SUBGOAL_THEN ``(f:real->real) integrable_on interval[c,d]`` MP_TAC THENL 6401 [MATCH_MP_TAC INTEGRABLE_EQ THEN 6402 EXISTS_TAC ``\x. if x IN interval[c:real,d] 6403 then f x:real else 0`` THEN 6404 SIMP_TAC std_ss [] THEN MATCH_MP_TAC INTEGRABLE_SUBINTERVAL THEN 6405 ASM_MESON_TAC[integrable_on], 6406 ALL_TAC] THEN 6407 DISCH_THEN(fn th => ASSUME_TAC th THEN MP_TAC th) THEN 6408 DISCH_THEN(MP_TAC o MATCH_MP INTEGRABLE_INTEGRAL) THEN 6409 MP_TAC(ASSUME ``interval[c:real,d] SUBSET interval[a,b]``) THEN 6410 REWRITE_TAC[AND_IMP_INTRO] THEN ONCE_REWRITE_TAC[CONJ_SYM] THEN 6411 DISCH_THEN(MP_TAC o MATCH_MP HAS_INTEGRAL_RESTRICT_CLOSED_SUBINTERVAL) THEN 6412 ASM_MESON_TAC[HAS_INTEGRAL_UNIQUE, INTEGRABLE_INTEGRAL]); 6413 6414(* ------------------------------------------------------------------------- *) 6415(* Hence we can apply the limit process uniformly to all integrals. *) 6416(* ------------------------------------------------------------------------- *) 6417 6418val HAS_INTEGRAL = store_thm ("HAS_INTEGRAL", 6419 ``!f:real->real i s. 6420 (f has_integral i) s <=> 6421 !e. &0 < e 6422 ==> ?B. &0 < B /\ 6423 !a b. ball(0,B) SUBSET interval[a,b] 6424 ==> ?z. ((\x. if x IN s then f(x) else 0) 6425 has_integral z) (interval[a,b]) /\ 6426 abs(z - i) < e``, 6427 REPEAT GEN_TAC THEN GEN_REWR_TAC LAND_CONV [has_integral_alt] THEN 6428 COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN 6429 POP_ASSUM(X_CHOOSE_THEN ``a:real`` (X_CHOOSE_THEN ``b:real`` 6430 SUBST_ALL_TAC)) THEN 6431 MP_TAC(ISPECL [``a:real``, ``b:real``] (CONJUNCT1 BOUNDED_INTERVAL)) THEN 6432 REWRITE_TAC[BOUNDED_POS] THEN 6433 DISCH_THEN(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) THEN EQ_TAC THENL 6434 [DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 6435 EXISTS_TAC ``B + &1:real`` THEN ASM_SIMP_TAC std_ss [REAL_LT_ADD, REAL_LT_01] THEN 6436 MAP_EVERY X_GEN_TAC [``c:real``, ``d:real``] THEN 6437 SIMP_TAC std_ss [SUBSET_DEF, IN_BALL, DIST_0] THEN 6438 DISCH_TAC THEN EXISTS_TAC ``i:real`` THEN 6439 ASM_REWRITE_TAC[REAL_SUB_REFL, ABS_0] THEN 6440 MATCH_MP_TAC HAS_INTEGRAL_RESTRICT_CLOSED_SUBINTERVAL THEN 6441 ASM_MESON_TAC[SUBSET_DEF, REAL_ARITH ``n <= B ==> n < B + &1:real``], 6442 ALL_TAC] THEN 6443 DISCH_TAC THEN 6444 SUBGOAL_THEN ``?y. ((f:real->real) has_integral y) (interval[a,b])`` 6445 MP_TAC THENL 6446 [SUBGOAL_THEN 6447 ``?c d. interval[a,b] SUBSET interval[c,d] /\ 6448 (\x. if x IN interval[a,b] then (f:real->real) x 6449 else 0) integrable_on interval[c,d]`` 6450 STRIP_ASSUME_TAC THENL 6451 [FIRST_X_ASSUM(MP_TAC o C MATCH_MP REAL_LT_01) THEN 6452 DISCH_THEN(X_CHOOSE_THEN ``C:real`` STRIP_ASSUME_TAC) THEN 6453 ABBREV_TAC ``c:real = @f. f = -(max B C)`` THEN 6454 ABBREV_TAC ``d:real = @f. f = max B C`` THEN 6455 MAP_EVERY EXISTS_TAC [``c:real``, ``d:real``] THEN CONJ_TAC THENL 6456 [REWRITE_TAC[SUBSET_DEF] THEN X_GEN_TAC ``x:real`` THEN 6457 DISCH_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 6458 MAP_EVERY EXPAND_TAC ["c", "d"] THEN 6459 SIMP_TAC std_ss [GSYM ABS_BOUNDS] THEN 6460 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``abs(x:real)`` THEN 6461 ASM_SIMP_TAC std_ss [REAL_LE_REFL] THEN 6462 MATCH_MP_TAC(METIS [REAL_LE_MAX] ``x <= B ==> (x:real) <= max B C``) THEN 6463 ASM_SIMP_TAC std_ss [], 6464 ALL_TAC] THEN 6465 FIRST_X_ASSUM(MP_TAC o SPECL [``c:real``, ``d:real``]) THEN 6466 KNOW_TAC ``ball (0,C) SUBSET interval [(c,d)]`` THENL 6467 [REWRITE_TAC[SUBSET_DEF, IN_BALL, DIST_0] THEN 6468 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 6469 MAP_EVERY EXPAND_TAC ["c", "d"] THEN SIMP_TAC std_ss [GSYM ABS_BOUNDS] THEN 6470 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``abs(x:real)`` THEN 6471 ASM_SIMP_TAC std_ss [REAL_LE_REFL] THEN 6472 MATCH_MP_TAC(METIS [REAL_LE_MAX, REAL_LT_IMP_LE] 6473 ``x < C ==> x:real <= max B C``) THEN 6474 ASM_SIMP_TAC std_ss [], 6475 ALL_TAC] THEN 6476 MESON_TAC[integrable_on], 6477 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [integrable_on]) THEN 6478 ASM_SIMP_TAC std_ss [HAS_INTEGRAL_RESTRICT_CLOSED_SUBINTERVALS_EQ]], 6479 ALL_TAC] THEN 6480 DISCH_THEN(X_CHOOSE_TAC ``y:real``) THEN 6481 SUBGOAL_THEN ``i:real = y`` ASSUME_TAC THEN ASM_REWRITE_TAC[] THEN 6482 MATCH_MP_TAC(REAL_ARITH ``~(&0 < abs(y - i)) ==> (i = y:real)``) THEN 6483 DISCH_TAC THEN FIRST_X_ASSUM(MP_TAC o SPEC ``abs(y - i:real)``) THEN 6484 ASM_SIMP_TAC std_ss [NOT_EXISTS_THM] THEN X_GEN_TAC ``C:real`` THEN 6485 CCONTR_TAC THEN FULL_SIMP_TAC std_ss [] THEN POP_ASSUM MP_TAC THEN 6486 SIMP_TAC std_ss [NOT_FORALL_THM, NOT_IMP] THEN 6487 ABBREV_TAC ``c:real = @f. f = -(max B C)`` THEN 6488 ABBREV_TAC ``d:real = @f. f = max B C`` THEN 6489 MAP_EVERY EXISTS_TAC [``c:real``, ``d:real``] THEN CONJ_TAC THENL 6490 [REWRITE_TAC[SUBSET_DEF, IN_BALL, DIST_0] THEN 6491 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 6492 MAP_EVERY EXPAND_TAC ["c", "d"] THEN 6493 SIMP_TAC std_ss [GSYM ABS_BOUNDS] THEN 6494 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``abs(x:real)`` THEN 6495 ASM_SIMP_TAC std_ss [REAL_LE_REFL] THEN 6496 MATCH_MP_TAC(METIS [REAL_LE_MAX, REAL_LT_IMP_LE] 6497 ``x < C ==> x:real <= max B C``) THEN 6498 ASM_SIMP_TAC std_ss [], 6499 ALL_TAC] THEN 6500 SUBGOAL_THEN ``interval[a:real,b] SUBSET interval[c,d]`` ASSUME_TAC THENL 6501 [REWRITE_TAC[SUBSET_DEF] THEN X_GEN_TAC ``x:real`` THEN 6502 DISCH_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 6503 MAP_EVERY EXPAND_TAC ["c", "d"] THEN SIMP_TAC std_ss [GSYM ABS_BOUNDS] THEN 6504 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``abs(x:real)`` THEN 6505 ASM_SIMP_TAC std_ss [REAL_LE_REFL] THEN 6506 MATCH_MP_TAC(METIS [REAL_LE_MAX] ``x <= B ==> x:real <= max B C``) THEN 6507 ASM_SIMP_TAC std_ss [], 6508 ALL_TAC] THEN 6509 ASM_SIMP_TAC std_ss [HAS_INTEGRAL_RESTRICT_CLOSED_SUBINTERVALS_EQ] THEN 6510 ASM_MESON_TAC[REAL_LT_REFL, HAS_INTEGRAL_UNIQUE]); 6511 6512(* ------------------------------------------------------------------------- *) 6513(* Hence a general restriction property. 5952 *) 6514(* ------------------------------------------------------------------------- *) 6515 6516val HAS_INTEGRAL_RESTRICT = store_thm ("HAS_INTEGRAL_RESTRICT", 6517 ``!f:real->real s t i. 6518 s SUBSET t 6519 ==> (((\x. if x IN s then f x else 0) has_integral i) t <=> 6520 (f has_integral i) s)``, 6521 REWRITE_TAC[SUBSET_DEF] THEN REPEAT STRIP_TAC THEN 6522 ONCE_REWRITE_TAC[HAS_INTEGRAL] THEN SIMP_TAC std_ss [] THEN 6523 ONCE_REWRITE_TAC[METIS [] ``(if p then if q then x else y else y) = 6524 (if q then if p then x else y else y)``] THEN 6525 ASM_SIMP_TAC std_ss []); 6526 6527val INTEGRAL_RESTRICT = store_thm ("INTEGRAL_RESTRICT", 6528 ``!f:real->real s t. 6529 s SUBSET t 6530 ==> (integral t (\x. if x IN s then f x else 0) = 6531 integral s f)``, 6532 SIMP_TAC std_ss [integral, HAS_INTEGRAL_RESTRICT]); 6533 6534val INTEGRABLE_RESTRICT = store_thm ("INTEGRABLE_RESTRICT", 6535 ``!f:real->real s t. 6536 s SUBSET t 6537 ==> (((\x. if x IN s then f x else 0) integrable_on t <=> 6538 f integrable_on s))``, 6539 SIMP_TAC std_ss [integrable_on, HAS_INTEGRAL_RESTRICT]); 6540 6541val HAS_INTEGRAL_RESTRICT_UNIV = store_thm ("HAS_INTEGRAL_RESTRICT_UNIV", 6542 ``!f:real->real s i. 6543 ((\x. if x IN s then f x else 0) has_integral i) univ(:real) <=> 6544 (f has_integral i) s``, 6545 SIMP_TAC std_ss [HAS_INTEGRAL_RESTRICT, SUBSET_UNIV]); 6546 6547val INTEGRAL_RESTRICT_UNIV = store_thm ("INTEGRAL_RESTRICT_UNIV", 6548 ``!f:real->real s. 6549 integral univ(:real) (\x. if x IN s then f x else 0) = 6550 integral s f``, 6551 REWRITE_TAC[integral, HAS_INTEGRAL_RESTRICT_UNIV]); 6552 6553val INTEGRABLE_RESTRICT_UNIV = store_thm ("INTEGRABLE_RESTRICT_UNIV", 6554 ``!f s. (\x. if x IN s then f x else 0) integrable_on univ(:real) <=> 6555 f integrable_on s``, 6556 REWRITE_TAC[integrable_on, HAS_INTEGRAL_RESTRICT_UNIV]); 6557 6558val HAS_INTEGRAL_RESTRICT_INTER = store_thm ("HAS_INTEGRAL_RESTRICT_INTER", 6559 ``!f:real->real s t. 6560 ((\x. if x IN s then f x else 0) has_integral i) t <=> 6561 (f has_integral i) (s INTER t)``, 6562 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[GSYM HAS_INTEGRAL_RESTRICT_UNIV] THEN 6563 REWRITE_TAC[IN_INTER] THEN AP_THM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN 6564 REWRITE_TAC[FUN_EQ_THM] THEN METIS_TAC[]); 6565 6566val INTEGRAL_RESTRICT_INTER = store_thm ("INTEGRAL_RESTRICT_INTER", 6567 ``!f:real->real s t. 6568 integral t (\x. if x IN s then f x else 0) = 6569 integral (s INTER t) f``, 6570 REWRITE_TAC[integral, HAS_INTEGRAL_RESTRICT_INTER]); 6571 6572val INTEGRABLE_RESTRICT_INTER = store_thm ("INTEGRABLE_RESTRICT_INTER", 6573 ``!f:real->real s t. 6574 (\x. if x IN s then f x else 0) integrable_on t <=> 6575 f integrable_on (s INTER t)``, 6576 REWRITE_TAC[integrable_on, HAS_INTEGRAL_RESTRICT_INTER]); 6577 6578val HAS_INTEGRAL_ON_SUPERSET = store_thm ("HAS_INTEGRAL_ON_SUPERSET", 6579 ``!f s t i. 6580 (!x. ~(x IN s) ==> (f x = 0)) /\ s SUBSET t /\ (f has_integral i) s 6581 ==> (f has_integral i) t``, 6582 REPEAT GEN_TAC THEN REWRITE_TAC[SUBSET_DEF] THEN 6583 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 6584 ONCE_REWRITE_TAC[GSYM HAS_INTEGRAL_RESTRICT_UNIV] THEN 6585 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_THM_TAC THEN 6586 AP_TERM_TAC THEN ABS_TAC THEN METIS_TAC[]); 6587 6588val INTEGRABLE_ON_SUPERSET = store_thm ("INTEGRABLE_ON_SUPERSET", 6589 ``!f s t. 6590 (!x. ~(x IN s) ==> (f x = 0)) /\ s SUBSET t /\ f integrable_on s 6591 ==> f integrable_on t``, 6592 REWRITE_TAC[integrable_on] THEN MESON_TAC[HAS_INTEGRAL_ON_SUPERSET]); 6593 6594val NEGLIGIBLE_ON_INTERVALS = store_thm ("NEGLIGIBLE_ON_INTERVALS", 6595 ``!s. negligible s <=> !a b:real. negligible(s INTER interval[a,b])``, 6596 GEN_TAC THEN EQ_TAC THEN REPEAT STRIP_TAC THENL 6597 [MATCH_MP_TAC NEGLIGIBLE_SUBSET THEN EXISTS_TAC ``s:real->bool`` THEN 6598 ASM_REWRITE_TAC[] THEN SET_TAC[], 6599 ALL_TAC] THEN 6600 REWRITE_TAC[negligible] THEN 6601 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 6602 FIRST_ASSUM(ASSUME_TAC o SPECL [``a:real``, ``b:real``]) THEN 6603 MATCH_MP_TAC HAS_INTEGRAL_NEGLIGIBLE THEN 6604 EXISTS_TAC ``s INTER interval[a:real,b]`` THEN 6605 ASM_REWRITE_TAC[] THEN SIMP_TAC std_ss [indicator, IN_DIFF, IN_INTER] THEN 6606 METIS_TAC[]); 6607 6608val NEGLIGIBLE_BOUNDED_SUBSETS = store_thm ("NEGLIGIBLE_BOUNDED_SUBSETS", 6609 ``!s:real->bool. 6610 negligible s <=> !t. bounded t /\ t SUBSET s ==> negligible t``, 6611 METIS_TAC[NEGLIGIBLE_ON_INTERVALS, INTER_SUBSET, BOUNDED_SUBSET, 6612 BOUNDED_INTERVAL, NEGLIGIBLE_SUBSET]); 6613 6614val NEGLIGIBLE_ON_COUNTABLE_INTERVALS = store_thm ("NEGLIGIBLE_ON_COUNTABLE_INTERVALS", 6615 ``!s:real->bool. 6616 negligible s <=> 6617 !n. negligible (s INTER interval[-n, n])``, 6618 GEN_TAC THEN GEN_REWR_TAC LAND_CONV [NEGLIGIBLE_ON_INTERVALS] THEN 6619 EQ_TAC THEN SIMP_TAC std_ss [] THEN REPEAT STRIP_TAC THEN 6620 SUBGOAL_THEN 6621 ``!a b:real. ?n. s INTER interval[a,b] = 6622 ((s INTER interval[-n,n]) INTER interval[a,b])`` 6623 (fn th => METIS_TAC[th, NEGLIGIBLE_ON_INTERVALS]) THEN 6624 REPEAT GEN_TAC THEN 6625 MP_TAC(ISPECL [``interval[a:real,b]``, ``0:real``] 6626 BOUNDED_SUBSET_CBALL) THEN 6627 REWRITE_TAC[BOUNDED_INTERVAL] THEN 6628 DISCH_THEN(X_CHOOSE_THEN ``r:real`` STRIP_ASSUME_TAC) THEN 6629 MP_TAC(SPEC ``r:real`` SIMP_REAL_ARCH) THEN 6630 STRIP_TAC THEN EXISTS_TAC ``&n:real`` THEN 6631 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (SET_RULE 6632 ``i SUBSET b ==> b SUBSET n ==> (s INTER i = (s INTER n) INTER i)``)) THEN 6633 REWRITE_TAC[SUBSET_DEF, IN_CBALL_0, IN_INTERVAL, GSYM ABS_BOUNDS] THEN 6634 METIS_TAC[REAL_LE_TRANS]); 6635 6636val HAS_INTEGRAL_SPIKE_SET_EQ = store_thm ("HAS_INTEGRAL_SPIKE_SET_EQ", 6637 ``!f:real->real s t y. 6638 negligible((s DIFF t) UNION (t DIFF s)) 6639 ==> ((f has_integral y) s <=> (f has_integral y) t)``, 6640 REPEAT STRIP_TAC THEN ONCE_REWRITE_TAC[GSYM HAS_INTEGRAL_RESTRICT_UNIV] THEN 6641 MATCH_MP_TAC HAS_INTEGRAL_SPIKE_EQ THEN 6642 EXISTS_TAC ``(s DIFF t) UNION (t DIFF s:real->bool)`` THEN 6643 ASM_SIMP_TAC std_ss [] THEN SET_TAC[]); 6644 6645val HAS_INTEGRAL_SPIKE_SET = store_thm ("HAS_INTEGRAL_SPIKE_SET", 6646 ``!f:real->real s t y. 6647 negligible((s DIFF t) UNION (t DIFF s)) /\ 6648 (f has_integral y) s 6649 ==> (f has_integral y) t``, 6650 MESON_TAC[HAS_INTEGRAL_SPIKE_SET_EQ]); 6651 6652val INTEGRABLE_SPIKE_SET = store_thm ("INTEGRABLE_SPIKE_SET", 6653 ``!f:real->real s t. 6654 negligible(s DIFF t UNION (t DIFF s)) 6655 ==> f integrable_on s ==> f integrable_on t``, 6656 REWRITE_TAC[integrable_on] THEN MESON_TAC[HAS_INTEGRAL_SPIKE_SET_EQ]); 6657 6658val INTEGRABLE_SPIKE_SET_EQ = store_thm ("INTEGRABLE_SPIKE_SET_EQ", 6659 ``!f:real->real s t. 6660 negligible(s DIFF t UNION (t DIFF s)) 6661 ==> (f integrable_on s <=> f integrable_on t)``, 6662 MESON_TAC[INTEGRABLE_SPIKE_SET, UNION_COMM]); 6663 6664val INTEGRAL_SPIKE_SET = store_thm ("INTEGRAL_SPIKE_SET", 6665 ``!f:real->real s t. 6666 negligible(s DIFF t UNION (t DIFF s)) 6667 ==> (integral s f = integral t f)``, 6668 REPEAT STRIP_TAC THEN REWRITE_TAC[integral] THEN 6669 AP_TERM_TAC THEN ABS_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_SPIKE_SET_EQ THEN 6670 ASM_MESON_TAC[]); 6671 6672val HAS_INTEGRAL_INTERIOR = store_thm ("HAS_INTEGRAL_INTERIOR", 6673 ``!f:real->real y s. 6674 negligible(frontier s) 6675 ==> ((f has_integral y) (interior s) <=> (f has_integral y) s)``, 6676 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_SPIKE_SET_EQ THEN 6677 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 6678 NEGLIGIBLE_SUBSET)) THEN 6679 REWRITE_TAC[frontier] THEN 6680 MP_TAC(ISPEC ``s:real->bool`` INTERIOR_SUBSET) THEN 6681 MP_TAC(ISPEC ``s:real->bool`` CLOSURE_SUBSET) THEN 6682 SET_TAC[]); 6683 6684val HAS_INTEGRAL_CLOSURE = store_thm ("HAS_INTEGRAL_CLOSURE", 6685 ``!f:real->real y s. 6686 negligible(frontier s) 6687 ==> ((f has_integral y) (closure s) <=> (f has_integral y) s)``, 6688 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_SPIKE_SET_EQ THEN 6689 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 6690 NEGLIGIBLE_SUBSET)) THEN 6691 REWRITE_TAC[frontier] THEN 6692 MP_TAC(ISPEC ``s:real->bool`` INTERIOR_SUBSET) THEN 6693 MP_TAC(ISPEC ``s:real->bool`` CLOSURE_SUBSET) THEN 6694 SET_TAC[]); 6695 6696val INTEGRABLE_CASES = store_thm ("INTEGRABLE_CASES", 6697 ``!P f g:real->real s. 6698 f integrable_on {x | x IN s /\ P x} /\ 6699 g integrable_on {x | x IN s /\ ~P x} 6700 ==> (\x. if P x then f x else g x) integrable_on s``, 6701 REPEAT GEN_TAC THEN 6702 ONCE_REWRITE_TAC[GSYM INTEGRABLE_RESTRICT_UNIV] THEN 6703 DISCH_THEN(MP_TAC o MATCH_MP INTEGRABLE_ADD) THEN 6704 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] INTEGRABLE_EQ) THEN 6705 SIMP_TAC std_ss [IN_UNIV, GSPECIFICATION] THEN 6706 METIS_TAC[REAL_ADD_LID, REAL_ADD_RID]); 6707 6708(* ------------------------------------------------------------------------- *) 6709(* More lemmas that are useful later. *) 6710(* ------------------------------------------------------------------------- *) 6711 6712val HAS_INTEGRAL_DROP_POS_AE = store_thm ("HAS_INTEGRAL_DROP_POS_AE", 6713 ``!f:real->real s t i. 6714 (f has_integral i) s /\ 6715 negligible t /\ (!x. x IN s DIFF t ==> &0 <= f x) 6716 ==> &0 <= i``, 6717 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_DROP_POS THEN 6718 EXISTS_TAC ``f:real->real`` THEN EXISTS_TAC ``s DIFF t:real->bool`` THEN 6719 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC HAS_INTEGRAL_SPIKE_SET THEN 6720 EXISTS_TAC ``s:real->bool`` THEN ASM_REWRITE_TAC[] THEN 6721 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 6722 NEGLIGIBLE_SUBSET)) THEN 6723 SET_TAC[]); 6724 6725val INTEGRAL_DROP_POS_AE = store_thm ("INTEGRAL_DROP_POS_AE", 6726 ``!f:real->real s t. 6727 f integrable_on s /\ 6728 negligible t /\ (!x. x IN s DIFF t ==> &0 <=(f x)) 6729 ==> &0 <= (integral s f)``, 6730 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_DROP_POS_AE THEN 6731 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]); 6732 6733val HAS_INTEGRAL_SUBSET_COMPONENT_LE = store_thm ("HAS_INTEGRAL_SUBSET_COMPONENT_LE", 6734 ``!f:real->real s t i j. 6735 s SUBSET t /\ (f has_integral i) s /\ (f has_integral j) t /\ 6736 (!x. x IN t ==> &0 <= f(x)) 6737 ==> i <= j``, 6738 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[GSYM HAS_INTEGRAL_RESTRICT_UNIV] THEN 6739 STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_COMPONENT_LE THEN 6740 MAP_EVERY EXISTS_TAC 6741 [``(\x. if x IN s then f x else 0):real->real``, 6742 ``(\x. if x IN t then f x else 0):real->real``, 6743 ``univ(:real)``] THEN 6744 ASM_SIMP_TAC std_ss [] THEN 6745 REPEAT STRIP_TAC THEN 6746 REPEAT(COND_CASES_TAC THEN ASM_REWRITE_TAC[REAL_LE_REFL]) THEN 6747 ASM_SET_TAC[]); 6748 6749val INTEGRAL_SUBSET_COMPONENT_LE = store_thm ("INTEGRAL_SUBSET_COMPONENT_LE", 6750 ``!f:real->real s t. 6751 s SUBSET t /\ f integrable_on s /\ f integrable_on t /\ 6752 (!x. x IN t ==> &0 <= f(x)) 6753 ==> (integral s f) <= (integral t f)``, 6754 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_SUBSET_COMPONENT_LE THEN 6755 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]); 6756 6757val HAS_INTEGRAL_SUBSET_DROP_LE = store_thm ("HAS_INTEGRAL_SUBSET_DROP_LE", 6758 ``!f:real->real s t i j. 6759 s SUBSET t /\ (f has_integral i) s /\ (f has_integral j) t /\ 6760 (!x. x IN t ==> &0 <= (f x)) 6761 ==> i <= j``, 6762 REPEAT STRIP_TAC THEN 6763 MATCH_MP_TAC HAS_INTEGRAL_SUBSET_COMPONENT_LE THEN 6764 REWRITE_TAC[LESS_EQ_REFL] THEN ASM_MESON_TAC[]); 6765 6766val INTEGRAL_SUBSET_DROP_LE = store_thm ("INTEGRAL_SUBSET_DROP_LE", 6767 ``!f:real->real s t. 6768 s SUBSET t /\ f integrable_on s /\ f integrable_on t /\ 6769 (!x. x IN t ==> &0 <= (f(x))) 6770 ==> (integral s f) <= (integral t f)``, 6771 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_SUBSET_DROP_LE THEN 6772 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]); 6773 6774val HAS_INTEGRAL_ALT = store_thm ("HAS_INTEGRAL_ALT", 6775 ``!f:real->real s i. 6776 (f has_integral i) s <=> 6777 (!a b. (\x. if x IN s then f x else 0) 6778 integrable_on interval[a,b]) /\ 6779 (!e. &0 < e 6780 ==> ?B. &0 < B /\ 6781 !a b. ball (0,B) SUBSET interval[a,b] 6782 ==> abs(integral(interval[a,b]) 6783 (\x. if x IN s then f x else 0) - 6784 i) < e)``, 6785 REPEAT GEN_TAC THEN GEN_REWR_TAC LAND_CONV [HAS_INTEGRAL] THEN 6786 SPEC_TAC(``\x. if x IN s then (f:real->real) x else 0``, 6787 ``f:real->real``) THEN 6788 GEN_TAC THEN EQ_TAC THENL 6789 [ALL_TAC, MESON_TAC[INTEGRAL_UNIQUE, integrable_on]] THEN 6790 DISCH_TAC THEN CONJ_TAC THENL 6791 [ALL_TAC, ASM_MESON_TAC[INTEGRAL_UNIQUE]] THEN 6792 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 6793 POP_ASSUM(MP_TAC o C MATCH_MP REAL_LT_01) THEN 6794 DISCH_THEN(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) THEN 6795 MATCH_MP_TAC INTEGRABLE_SUBINTERVAL THEN 6796 EXISTS_TAC ``(@f. f = min ((a:real)) (-B)):real`` THEN 6797 EXISTS_TAC ``(@f. f = max ((b:real)) B):real`` THEN CONJ_TAC THENL 6798 [FIRST_X_ASSUM(MP_TAC o SPECL 6799 [``(@f. f = min ((a:real)) (-B)):real``, 6800 ``(@f. f = max ((b:real)) B):real``]) THEN 6801 KNOW_TAC ``ball ((0 :real),(B :real)) SUBSET 6802 interval 6803 [((@(f :real). f = min (a :real) (-B)), 6804 @(f :real). f = max (b :real) B)]`` THENL 6805 [ALL_TAC, MESON_TAC[integrable_on]], ALL_TAC] THEN 6806 SIMP_TAC std_ss [SUBSET_DEF, IN_INTERVAL, IN_BALL, 6807 REAL_MIN_LE, REAL_LE_MAX] THEN REWRITE_TAC [dist] THEN REAL_ARITH_TAC); 6808 6809val INTEGRABLE_ALT = store_thm ("INTEGRABLE_ALT", 6810 ``!f:real->real s. 6811 f integrable_on s <=> 6812 (!a b. (\x. if x IN s then f x else 0) integrable_on 6813 interval[a,b]) /\ 6814 (!e. &0 < e 6815 ==> ?B. &0 < B /\ 6816 !a b c d. 6817 ball(0,B) SUBSET interval[a,b] /\ 6818 ball(0,B) SUBSET interval[c,d] 6819 ==> abs(integral (interval[a,b]) 6820 (\x. if x IN s then f x else 0) - 6821 integral (interval[c,d]) 6822 (\x. if x IN s then f x else 0)) < e)``, 6823 REPEAT GEN_TAC THEN 6824 GEN_REWR_TAC LAND_CONV [integrable_on] THEN 6825 ONCE_REWRITE_TAC[HAS_INTEGRAL_ALT] THEN 6826 SIMP_TAC std_ss [RIGHT_EXISTS_AND_THM] THEN 6827 MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> (a /\ b <=> a /\ c)`) THEN 6828 DISCH_TAC THEN EQ_TAC THENL 6829 [DISCH_THEN(X_CHOOSE_THEN ``y:real`` STRIP_ASSUME_TAC) THEN 6830 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 6831 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 6832 DISCH_THEN (X_CHOOSE_TAC ``B:real``) THEN EXISTS_TAC ``B:real`` THEN 6833 METIS_TAC[REAL_ARITH ``abs(a - y) < e / (&2:real) /\ abs(b - y) < e / &2 6834 ==> abs(a - b) < e / &2 + e / &2``, REAL_HALF], 6835 ALL_TAC] THEN 6836 DISCH_TAC THEN 6837 SUBGOAL_THEN 6838 ``cauchy (\n. integral (interval[(@f. f = -(&n)),(@f. f = &n)]) 6839 (\x. if x IN s then (f:real->real) x else 0))`` 6840 MP_TAC THENL 6841 [REWRITE_TAC[cauchy] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 6842 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 6843 DISCH_THEN(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) THEN 6844 MP_TAC(SPEC ``B:real`` SIMP_REAL_ARCH) THEN 6845 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 6846 REPEAT STRIP_TAC THEN REWRITE_TAC[dist] THEN BETA_TAC THEN 6847 FIRST_X_ASSUM MATCH_MP_TAC THEN 6848 REWRITE_TAC[SUBSET_DEF, IN_BALL, DIST_0] THEN 6849 CONJ_TAC, 6850 REWRITE_TAC[GSYM CONVERGENT_EQ_CAUCHY] THEN 6851 DISCH_THEN (X_CHOOSE_TAC ``i:real``) THEN EXISTS_TAC ``i:real`` THEN 6852 POP_ASSUM MP_TAC THEN REWRITE_TAC[LIM_SEQUENTIALLY] THEN DISCH_TAC THEN 6853 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 6854 UNDISCH_TAC ``!(e :real). (0 :real) < e ==> 6855 ?(N :num). !(n :num). N <= n ==> 6856 (dist ((\(n :num). 6857 integral (interval 6858 [((@(f :real). f = -((&n) :real)), 6859 @(f :real). f = ((&n) :real))]) 6860 (\(x :real). 6861 if x IN (s :real -> bool) then 6862 (f :real -> real) x 6863 else (0 :real))) n,(i :real)) :real) < e`` THEN 6864 DISCH_TAC THEN 6865 FIRST_X_ASSUM (MP_TAC o SPEC ``e / &2:real``) THEN 6866 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 6867 DISCH_THEN(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) THEN 6868 DISCH_THEN(X_CHOOSE_THEN ``N:num`` ASSUME_TAC) THEN 6869 MP_TAC(SPEC ``max (&N) B:real`` SIMP_REAL_ARCH) THEN 6870 REWRITE_TAC[REAL_MAX_LE, REAL_OF_NUM_LE] THEN 6871 DISCH_THEN(X_CHOOSE_THEN ``n:num`` STRIP_ASSUME_TAC) THEN 6872 EXISTS_TAC ``&n:real`` THEN CONJ_TAC THENL 6873 [METIS_TAC [REAL_LTE_TRANS], ALL_TAC] THEN 6874 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN STRIP_TAC THEN 6875 FIRST_X_ASSUM(MP_TAC o SPEC ``n:num``) THEN ASM_SIMP_TAC std_ss [] THEN 6876 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 6877 REWRITE_TAC [dist] THEN 6878 MATCH_MP_TAC(REAL_ARITH 6879 ``abs(i1 - i2) < e / &2 ==> abs(i1 - i) < e / &2 ==> 6880 abs(i2 - i) < e / &2 + e / &2:real``) THEN 6881 FIRST_X_ASSUM MATCH_MP_TAC THEN CONJ_TAC THEN 6882 MATCH_MP_TAC SUBSET_TRANS THEN EXISTS_TAC ``ball(0:real,&n)`` THEN 6883 ASM_SIMP_TAC std_ss [SUBSET_BALL] THEN 6884 REWRITE_TAC[SUBSET_DEF, IN_BALL, DIST_0]] THEN 6885 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 6886 SIMP_TAC std_ss [IN_INTERVAL] THEN REPEAT GEN_TAC THEN 6887 REWRITE_TAC[GSYM ABS_BOUNDS] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 6888 EXISTS_TAC ``abs(x:real)`` THEN ASM_SIMP_TAC std_ss [REAL_LE_REFL] THEN 6889 REPEAT(POP_ASSUM MP_TAC) THEN REWRITE_TAC[GSYM REAL_OF_NUM_GE, real_ge] THEN 6890 METIS_TAC [REAL_LE_TRANS, REAL_LE_LT]); 6891 6892val INTEGRABLE_ALT_SUBSET = store_thm ("INTEGRABLE_ALT_SUBSET", 6893 ``!f:real->real s. 6894 f integrable_on s <=> 6895 (!a b. (\x. if x IN s then f x else 0) integrable_on 6896 interval[a,b]) /\ 6897 (!e. &0 < e 6898 ==> ?B. &0 < B /\ 6899 !a b c d. 6900 ball(0,B) SUBSET interval[a,b] /\ 6901 interval[a,b] SUBSET interval[c,d] 6902 ==> abs(integral (interval[a,b]) 6903 (\x. if x IN s then f x else 0) - 6904 integral (interval[c,d]) 6905 (\x. if x IN s then f x else 0)) < e)``, 6906 REPEAT GEN_TAC THEN GEN_REWR_TAC LAND_CONV [INTEGRABLE_ALT] THEN 6907 ABBREV_TAC ``g:real->real = \x. if x IN s then f x else 0`` THEN 6908 POP_ASSUM(K ALL_TAC) THEN 6909 MATCH_MP_TAC(TAUT `(a ==> (b <=> c)) ==> (a /\ b <=> a /\ c)`) THEN 6910 DISCH_TAC THEN EQ_TAC THENL [MESON_TAC[SUBSET_TRANS], ALL_TAC] THEN 6911 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 6912 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 6913 STRIP_TAC THEN EXISTS_TAC ``B:real`` THEN 6914 ASM_REWRITE_TAC[] THEN 6915 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``, ``c:real``, ``d:real``] THEN 6916 STRIP_TAC THEN 6917 FIRST_X_ASSUM(MP_TAC o SPECL 6918 [``(@f. f = max ((a:real)) ((c:real))):real``, 6919 ``(@f. f = min ((b:real)) ((d:real))):real``]) THEN 6920 ASM_SIMP_TAC std_ss [GSYM INTER_INTERVAL, SUBSET_INTER] THEN 6921 DISCH_THEN(fn th => 6922 MP_TAC(ISPECL [``a:real``, ``b:real``] th) THEN 6923 MP_TAC(ISPECL [``c:real``, ``d:real``] th)) THEN 6924 ASM_SIMP_TAC std_ss [INTER_SUBSET] THEN 6925 GEN_REWR_TAC (RAND_CONV o RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN REAL_ARITH_TAC); 6926 6927val INTEGRABLE_ON_SUBINTERVAL = store_thm ("INTEGRABLE_ON_SUBINTERVAL", 6928 ``!f:real->real s a b. 6929 f integrable_on s /\ interval[a,b] SUBSET s 6930 ==> f integrable_on interval[a,b]``, 6931 REPEAT GEN_TAC THEN 6932 GEN_REWR_TAC (LAND_CONV o LAND_CONV) [INTEGRABLE_ALT] THEN 6933 DISCH_THEN(CONJUNCTS_THEN2 (MP_TAC o CONJUNCT1) ASSUME_TAC) THEN 6934 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 6935 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] INTEGRABLE_EQ) THEN 6936 ASM_SET_TAC[]); 6937 6938Theorem INTEGRAL_SPLIT : 6939 !f:real->real a b t. 6940 f integrable_on interval[a,b] 6941 ==> (integral (interval[a,b]) f = 6942 integral(interval [a,(@f. f = min (b) t)]) f + 6943 integral(interval [(@f. f = max (a) t),b]) f) 6944Proof 6945 rpt STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE 6946 >> MATCH_MP_TAC HAS_INTEGRAL_SPLIT THEN EXISTS_TAC ``t:real`` 6947 >> ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, GSYM HAS_INTEGRAL_INTEGRAL] 6948 >> CONJ_TAC THEN MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL 6949 >> EXISTS_TAC ``interval[a:real,b]`` 6950 >> ASM_SIMP_TAC std_ss [SUBSET_INTERVAL, min_def, max_def] 6951 >> TRY COND_CASES_TAC 6952 >> rpt STRIP_TAC >> ASM_REAL_ARITH_TAC 6953QED 6954 6955Theorem INTEGRAL_SPLIT_SIGNED : 6956 !f:real->real a b t. 6957 a <= t /\ a <= b /\ 6958 f integrable_on interval[a,(@f. f = max (b) t)] 6959 ==> (integral (interval[a,b]) f = 6960 integral(interval 6961 [a,(@f. f = t)]) f + 6962 (if b < t then -&1 else &1) * 6963 integral(interval [(@f. f = min (b) t), (@f. f = max (b) t)]) f) 6964Proof 6965 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [] THENL 6966 [ (* goal 1 (of 2) *) 6967 MP_TAC(ISPECL 6968 [``f:real->real``, ``a:real``, 6969 ``(@f. f = t):real``, ``(b:real)``] INTEGRAL_SPLIT) THEN 6970 ASM_SIMP_TAC std_ss [] THEN KNOW_TAC ``f integrable_on interval [(a,t)]`` THENL 6971 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP 6972 (REWRITE_RULE[IMP_CONJ] INTEGRABLE_ON_SUBINTERVAL)) THEN 6973 ASM_SIMP_TAC std_ss [SUBSET_INTERVAL] THEN 6974 REPEAT STRIP_TAC THEN TRY COND_CASES_TAC THEN 6975 ASM_SIMP_TAC std_ss [max_def, REAL_LE_REFL] THEN 6976(* HOL's REAL_ASM_ARITH_TAC failed to solve: 6977 6978 t <= if b <= t then t else b 6979 ------------------------------------ 6980 0. a <= t 6981 1. a <= b 6982 2. b < t 6983 *) 6984 `b <= t` by PROVE_TAC [REAL_LT_IMP_LE] >> fs [REAL_LE_REFL], 6985 6986 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 6987 DISCH_THEN SUBST1_TAC THEN MATCH_MP_TAC(REAL_ARITH 6988 ``(x = y) /\ (w = z) 6989 ==> (x:real = (y + z) + -(&1) * w)``) THEN 6990 CONJ_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN 6991 SIMP_TAC std_ss [CONS_11, PAIR_EQ] THEN TRY CONJ_TAC THEN 6992 ASM_SIMP_TAC std_ss [min_def, max_def] THEN 6993 COND_CASES_TAC >> ASM_REAL_ARITH_TAC], 6994 (* goal 2 (of 2) *) 6995 MP_TAC(ISPECL 6996 [``f:real->real``, ``a:real``, 6997 ``b:real``, ``t:real``] INTEGRAL_SPLIT) THEN 6998 ASM_SIMP_TAC std_ss [] THEN KNOW_TAC ``f integrable_on interval [(a,b)]`` THENL 6999 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP 7000 (REWRITE_RULE[IMP_CONJ] INTEGRABLE_ON_SUBINTERVAL)) THEN 7001 ASM_SIMP_TAC std_ss [SUBSET_INTERVAL] THEN 7002 REPEAT STRIP_TAC THEN TRY COND_CASES_TAC THEN 7003 ASM_REWRITE_TAC[min_def, max_def, REAL_LE_REFL] THEN 7004 COND_CASES_TAC >> ASM_REAL_ARITH_TAC, 7005 7006 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 7007 DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[REAL_MUL_LID] THEN 7008 BINOP_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN 7009 SIMP_TAC std_ss [CONS_11, PAIR_EQ] THEN TRY CONJ_TAC THEN 7010 ASM_SIMP_TAC std_ss [min_def, max_def] THEN 7011 COND_CASES_TAC >> ASM_REAL_ARITH_TAC ] ] 7012QED 7013 7014val lemma1 = prove ( 7015 ``!f:(num->bool)->real n. 7016 sum {s | s SUBSET ((1:num)..SUC n)} f = 7017 sum {s | s SUBSET ((1:num)..n)} f + 7018 sum {s | s SUBSET ((1:num)..n)} (\s. f(SUC n INSERT s))``, 7019 REPEAT STRIP_TAC THEN 7020 REWRITE_TAC[NUMSEG_CLAUSES, ARITH_PROVE ``1 <= SUC n``, POWERSET_CLAUSES] THEN 7021 W(MP_TAC o PART_MATCH (lhs o rand) SUM_UNION o lhs o snd) THEN 7022 KNOW_TAC ``FINITE {s | s SUBSET ((1 :num) .. (n :num))} /\ 7023 FINITE 7024 (IMAGE (\(s :num -> bool). SUC n INSERT s) 7025 {s | s SUBSET ((1 :num) .. n)}) /\ 7026 DISJOINT {s | s SUBSET ((1 :num) .. n)} 7027 (IMAGE (\(s :num -> bool). SUC n INSERT s) 7028 {s | s SUBSET ((1 :num) .. n)}) `` THENL 7029 [ASM_SIMP_TAC std_ss [IMAGE_FINITE, FINITE_POWERSET, FINITE_NUMSEG] THEN 7030 REWRITE_TAC[SET_RULE 7031 ``DISJOINT s (IMAGE f t) <=> !x. x IN t ==> ~(f x IN s)``] THEN 7032 GEN_TAC THEN DISCH_TAC THEN SIMP_TAC std_ss [GSPECIFICATION, SUBSET_DEF] THEN 7033 EXISTS_TAC ``SUC n`` THEN 7034 REWRITE_TAC[IN_INSERT, IN_NUMSEG] THEN ARITH_TAC, 7035 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 7036 DISCH_THEN SUBST1_TAC THEN AP_TERM_TAC THEN 7037 REWRITE_TAC [METIS [o_DEF] `` (\s. f (SUC n INSERT s)) = f o (\s. SUC n INSERT s)``] 7038 THEN MATCH_MP_TAC (SUM_IMAGE) THEN 7039 SIMP_TAC std_ss [FINITE_POWERSET, FINITE_NUMSEG] THEN 7040 MAP_EVERY X_GEN_TAC [``s:num->bool``, ``t:num->bool``] THEN 7041 SIMP_TAC std_ss [GSPECIFICATION] THEN MATCH_MP_TAC(SET_RULE 7042 ``~(a IN i) 7043 ==> s SUBSET i /\ t SUBSET i /\ (a INSERT s = a INSERT t) 7044 ==> (s = t)``) THEN 7045 REWRITE_TAC[IN_NUMSEG] THEN ARITH_TAC]); 7046 7047val lemma2 = prove ( 7048 ``!f:real->real m a:real c:real d:real. 7049 f integrable_on univ(:real) /\ m <= (1:num) /\ 7050 ((a = c) \/ (d = c)) /\ 7051 ((a = c) ==> (a = d)) /\ ((a <= c) /\ (a <= d)) 7052 ==> (integral(interval[a,d]) f = 7053 sum {s | s SUBSET ((1:num)..(m:num))} 7054 (\s. -(&1) pow CARD {i | i IN s /\ d < c} * 7055 integral 7056 (interval[(@f. f = if (1:num) IN s then min c d else a:real), 7057 (@f. f = if (1:num) IN s then max c d else c:real)]) f))``, 7058 GEN_TAC THEN INDUCT_TAC THENL 7059 [SIMP_TAC arith_ss [NUMSEG_CLAUSES, SUBSET_EMPTY, GSPEC_EQ, GSPEC_EQ2] THEN 7060 SIMP_TAC std_ss [SUM_SING, NOT_IN_EMPTY, GSPEC_F, CARD_EMPTY, CARD_INSERT] THEN 7061 REWRITE_TAC[pow, REAL_MUL_LID] THEN REPEAT GEN_TAC THEN 7062 REWRITE_TAC [IMP_CONJ] THEN REPEAT DISCH_TAC THEN 7063 ASM_CASES_TAC ``((a:real) = (c:real))`` 7064 THENL 7065 [MATCH_MP_TAC(MESON[] ``(i = 0) /\ (j = 0) ==> (i:real = j)``) THEN 7066 CONJ_TAC THEN MATCH_MP_TAC INTEGRAL_NULL THEN 7067 REWRITE_TAC [CONTENT_EQ_0] THEN ASM_MESON_TAC[], 7068 SUBGOAL_THEN ``d:real = c:real`` (fn th => REWRITE_TAC[th]) THEN 7069 ASM_MESON_TAC[]], 7070 ALL_TAC] THEN 7071 REPEAT GEN_TAC THEN REWRITE_TAC [IMP_CONJ] THEN 7072 REPEAT DISCH_TAC THEN SIMP_TAC std_ss [lemma1] THEN 7073 SUBGOAL_THEN 7074 ``!s. s SUBSET ((1:num)..m) 7075 ==> (-(&1:real) pow CARD {i | i IN SUC m INSERT s /\ d < c} = 7076 (if (d:real) < (c:real) then -&1 else &1) * 7077 -(&1:real) pow CARD {i | i IN s /\ d < c})`` 7078 (fn th => SIMP_TAC std_ss [th, GSPECIFICATION]) THENL 7079 [X_GEN_TAC ``s:num->bool`` THEN DISCH_TAC THEN 7080 SUBGOAL_THEN ``FINITE(s:num->bool)`` ASSUME_TAC THENL 7081 [ASM_MESON_TAC[FINITE_NUMSEG, FINITE_SUBSET], ALL_TAC] THEN 7082 COND_CASES_TAC THENL 7083 [ASM_SIMP_TAC std_ss [CARD_INSERT, FINITE_RESTRICT, SET_RULE 7084 ``({x | x IN a INSERT s} = a INSERT {x | x IN s})``, 7085 SET_RULE ``{x | x IN s} = s``] THEN 7086 RULE_ASSUM_TAC (SIMP_RULE arith_ss [ARITH_PROVE ``SUC m <= 1 <=> (m = 0)``]) THEN 7087 UNDISCH_TAC ``s SUBSET ((1:num) .. m)`` THEN 7088 ASM_REWRITE_TAC [NUMSEG_CLAUSES] THEN DISCH_TAC THEN 7089 RULE_ASSUM_TAC (SIMP_RULE arith_ss [SUBSET_DEF, NOT_IN_EMPTY]) THEN 7090 FIRST_ASSUM (ASSUME_TAC o SPEC ``1:num``) THEN ASM_SIMP_TAC arith_ss [pow], 7091 ASM_SIMP_TAC std_ss [REAL_MUL_LID, SET_RULE 7092 ``{x | x IN a INSERT s /\ F} = {x | x IN s /\ F}``]], 7093 ALL_TAC] THEN 7094 MP_TAC(ISPECL 7095 [``f:real->real``, ``a:real``, ``d:real``, ``(c:real)``] 7096 INTEGRAL_SPLIT_SIGNED) THEN SIMP_TAC std_ss [] THEN 7097 KNOW_TAC ``a <= c /\ a <= d:real /\ f integrable_on interval [(a,max d c)]`` THENL 7098 [ASM_MESON_TAC[ARITH_PROVE ``1 <= SUC n``, INTEGRABLE_ON_SUBINTERVAL, 7099 SUBSET_UNIV], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 7100 POP_ASSUM K_TAC THEN DISCH_THEN SUBST1_TAC] THEN 7101 RULE_ASSUM_TAC (SIMP_RULE arith_ss [ARITH_PROVE ``SUC m <= 1 <=> (m = 0)``]) THEN 7102 ASM_SIMP_TAC arith_ss [NUMSEG_CLAUSES, SUBSET_DEF, NOT_IN_EMPTY] THEN 7103 SIMP_TAC std_ss [SET_RULE ``!s. (1:num) IN 1 INSERT s``] THEN 7104 KNOW_TAC ``!s. {(s:num->bool) | !x. x NOTIN s} = {{}}`` THENL 7105 [GEN_TAC THEN SIMP_TAC std_ss [EXTENSION, GSPECIFICATION, IN_SING, NOT_IN_EMPTY] THEN 7106 GEN_TAC THEN EQ_TAC THEN STRIP_TAC THENL [METIS_TAC [], ALL_TAC] THEN 7107 EXISTS_TAC ``x:num->bool`` THEN METIS_TAC [], DISCH_TAC] THEN 7108 ASM_SIMP_TAC std_ss [SUM_SING, IN_SING, NOT_IN_EMPTY] THEN BINOP_TAC THENL 7109 [SIMP_TAC real_ss [GSPEC_F, CARD_EMPTY, pow], ALL_TAC] THEN 7110 ASM_CASES_TAC ``d < c:real`` THENL [UNDISCH_TAC ``(a = c) ==> (c = d:real)`` THEN 7111 UNDISCH_TAC ``(a = c) \/ (d = c:real)`` THEN POP_ASSUM MP_TAC THEN 7112 REAL_ARITH_TAC, ALL_TAC] THEN 7113 ASM_SIMP_TAC std_ss [] THEN KNOW_TAC ``(c = d:real)`` THENL 7114 [UNDISCH_TAC ``(a = c) ==> (c = d:real)`` THEN 7115 UNDISCH_TAC ``(a = c) \/ (d = c:real)`` THEN POP_ASSUM MP_TAC THEN 7116 REAL_ARITH_TAC, SIMP_TAC real_ss [REAL_LE_LT, min_def, max_def]] THEN 7117 DISCH_TAC THEN SIMP_TAC real_ss [GSPEC_F, CARD_EMPTY, pow]); 7118 7119val HAS_INTEGRAL_REFLECT_GEN = store_thm ("HAS_INTEGRAL_REFLECT_GEN", 7120 ``!f:real->real i s. 7121 ((\x. f(-x)) has_integral i) s <=> (f has_integral i) (IMAGE (\x. -x) s)``, 7122 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[HAS_INTEGRAL_ALT] THEN 7123 SIMP_TAC std_ss [] THEN 7124 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) 7125 [GSYM INTEGRABLE_REFLECT, GSYM INTEGRAL_REFLECT] THEN 7126 SIMP_TAC std_ss [IN_IMAGE, REAL_NEG_NEG] THEN 7127 REWRITE_TAC[UNWIND_THM1, REAL_ARITH ``(x:real = -y) <=> (-x = y)``] THEN 7128 KNOW_TAC ``!x:real. ?x'. -x = x'`` THENL 7129 [GEN_TAC THEN EXISTS_TAC ``-x:real`` THEN SIMP_TAC std_ss [], 7130 DISCH_TAC] THEN ASM_SIMP_TAC std_ss [] THEN 7131 ONCE_REWRITE_TAC [METIS [] 7132 ``((\x. if -x IN s then f x else 0) integrable_on interval [(-b,-a)]) = 7133 (\a b. (\x. if -x IN s then f x else 0) integrable_on interval [(-b,-a)]) a b``] THEN 7134 ONCE_REWRITE_TAC [METIS [] 7135 ``( ball (0,B) SUBSET interval [(a,b)] ==> 7136 abs 7137 (integral (interval [(-b,-a)]) 7138 (\x. if -x IN s then f x else 0) - i) < e) = 7139 (\a b. ball (0,B) SUBSET interval [(a,b)] ==> 7140 abs 7141 (integral (interval [(-b,-a)]) 7142 (\x. if -x IN s then f x else 0) - i) < e) a b``] THEN 7143 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) [METIS [REAL_NEG_NEG] 7144 ``(!x:real y:real. P x y) <=> (!x y. P (-y) (-x))``] THEN 7145 SIMP_TAC std_ss [REAL_NEG_NEG] THEN 7146 SIMP_TAC std_ss [SUBSET_DEF, IN_BALL_0, GSYM REFLECT_INTERVAL, IN_IMAGE] THEN 7147 SIMP_TAC std_ss [UNWIND_THM1, REAL_ARITH ``(x:real = -y) <=> (-x = y)``] THEN 7148 ONCE_REWRITE_TAC[GSYM ABS_NEG] THEN 7149 ONCE_REWRITE_TAC [METIS [] 7150 ``(abs (-x') < B ==> -x' IN interval [(x,y)]) = 7151 (\x'. abs (-x') < B ==> -x' IN interval [(x,y)]) x'``] THEN 7152 SIMP_TAC std_ss [METIS [REAL_NEG_NEG] ``(!x:real. P (-x)) <=> (!x. P x)``] THEN 7153 SIMP_TAC std_ss [ABS_NEG]); 7154 7155val INTEGRABLE_REFLECT_GEN = store_thm ("INTEGRABLE_REFLECT_GEN", 7156 ``!f:real->real s. 7157 (\x. f(-x)) integrable_on s <=> f integrable_on (IMAGE (\x. -x) s)``, 7158 REWRITE_TAC[integrable_on, HAS_INTEGRAL_REFLECT_GEN]); 7159 7160val INTEGRAL_REFLECT_GEN = store_thm ("INTEGRAL_REFLECT_GEN", 7161 ``!f:real->real s. 7162 integral s (\x. f(-x)) = integral (IMAGE (\x. -x) s) f``, 7163 REWRITE_TAC[integral, HAS_INTEGRAL_REFLECT_GEN]); 7164 7165(* ------------------------------------------------------------------------- *) 7166(* A straddling criterion for integrability. *) 7167(* ------------------------------------------------------------------------- *) 7168 7169val INTEGRABLE_STRADDLE_INTERVAL = store_thm ("INTEGRABLE_STRADDLE_INTERVAL", 7170 ``!f:real->real a b. 7171 (!e. &0 < e 7172 ==> ?g h i j. (g has_integral i) (interval[a,b]) /\ 7173 (h has_integral j) (interval[a,b]) /\ 7174 abs(i - j) < e /\ 7175 !x. x IN interval[a,b] 7176 ==> (g x) <= (f x) /\ 7177 (f x) <= (h x)) 7178 ==> f integrable_on interval[a,b]``, 7179 REPEAT STRIP_TAC THEN REWRITE_TAC[INTEGRABLE_CAUCHY] THEN 7180 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 7181 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &3:real``) THEN 7182 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT, LEFT_IMP_EXISTS_THM] THEN 7183 MAP_EVERY X_GEN_TAC 7184 [``g:real->real``, ``h:real->real``, ``i:real``, ``j:real``] THEN 7185 REWRITE_TAC[has_integral] THEN REWRITE_TAC[IMP_CONJ] THEN 7186 DISCH_THEN(MP_TAC o SPEC ``e / &3:real``) THEN 7187 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 7188 DISCH_THEN(X_CHOOSE_THEN ``d1:real->real->bool`` STRIP_ASSUME_TAC) THEN 7189 DISCH_THEN(MP_TAC o SPEC ``e / &3:real``) THEN 7190 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 7191 DISCH_THEN(X_CHOOSE_THEN ``d2:real->real->bool`` STRIP_ASSUME_TAC) THEN 7192 DISCH_TAC THEN DISCH_TAC THEN 7193 EXISTS_TAC ``(\x. d1 x INTER d2 x):real->real->bool`` THEN 7194 ASM_SIMP_TAC std_ss [GAUGE_INTER, FINE_INTER] THEN 7195 MAP_EVERY X_GEN_TAC 7196 [``p1:(real#(real->bool))->bool``, 7197 ``p2:(real#(real->bool))->bool``] THEN 7198 REPEAT STRIP_TAC THEN 7199 REPEAT(FIRST_X_ASSUM(fn th => 7200 MP_TAC(SPEC ``p1:(real#(real->bool))->bool`` th) THEN 7201 MP_TAC(SPEC ``p2:(real#(real->bool))->bool`` th))) THEN 7202 UNDISCH_TAC ``(p2 :real # (real -> bool) -> bool) tagged_division_of 7203 interval [((a :real),(b :real))]`` THEN DISCH_TAC THEN 7204 FIRST_ASSUM (fn th => ASSUME_TAC(MATCH_MP TAGGED_DIVISION_OF_FINITE th)) THEN 7205 UNDISCH_TAC ``(p1 :real # (real -> bool) -> bool) tagged_division_of 7206 interval [((a :real),(b :real))]`` THEN DISCH_TAC THEN 7207 FIRST_ASSUM (fn th => ASSUME_TAC(MATCH_MP TAGGED_DIVISION_OF_FINITE th)) THEN 7208 ASM_SIMP_TAC std_ss [LAMBDA_PROD] THEN 7209 KNOW_TAC ``!f1 f2 g1 g2 h1 h2 i j. 7210 (g1 - h2 <= f1 - f2) /\ (f1 - f2 <= h1 - g2) /\ 7211 abs(i - j) < e / &3 7212 ==> abs(g2 - i) < e / &3 7213 ==> abs(g1 - i) < e / &3 7214 ==> abs(h2 - j) < e / &3 7215 ==> abs(h1 - j) < e / &3 7216 ==> abs(f1 - f2) < e:real`` THENL 7217 [REPEAT GEN_TAC THEN SIMP_TAC std_ss [REAL_LT_RDIV_EQ, REAL_ARITH ``0 < &3:real``] THEN 7218 REAL_ARITH_TAC, DISCH_TAC] THEN 7219 FIRST_X_ASSUM (MATCH_MP_TAC) THEN 7220 ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THEN 7221 MATCH_MP_TAC(REAL_ARITH ``x <= x' /\ y' <= y ==> x - y <= x' - y':real``) THEN 7222 CONJ_TAC THEN MATCH_MP_TAC SUM_LE THEN 7223 SIMP_TAC std_ss [FORALL_PROD] THEN REPEAT STRIP_TAC THEN 7224 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC REAL_LE_LMUL_IMP THEN 7225 METIS_TAC[TAGGED_DIVISION_OF, CONTENT_POS_LE, SUBSET_DEF]); 7226 7227val lemma = prove ( 7228 ``&0:real <= x /\ x <= y ==> abs x <= abs y``, 7229 REAL_ARITH_TAC); 7230 7231Theorem INTEGRABLE_STRADDLE : 7232 !f:real->real s. 7233 (!e. &0 < e 7234 ==> ?g h i j. (g has_integral i) s /\ 7235 (h has_integral j) s /\ 7236 abs(i - j) < e /\ 7237 !x. x IN s 7238 ==> (g x) <= (f x) /\ 7239 (f x) <= (h x)) 7240 ==> f integrable_on s 7241Proof 7242 REPEAT STRIP_TAC THEN 7243 SUBGOAL_THEN 7244 ``!a b. (\x. if x IN s then (f:real->real) x else 0) 7245 integrable_on interval[a,b]`` 7246 ASSUME_TAC THENL (* 2 subgoals *) 7247 [ (* goal 1 (of 2) *) 7248 RULE_ASSUM_TAC(REWRITE_RULE[HAS_INTEGRAL_ALT]) THEN 7249 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 7250 MATCH_MP_TAC INTEGRABLE_STRADDLE_INTERVAL THEN 7251 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 7252 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &4:real``) THEN 7253 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 7254 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 7255 MAP_EVERY X_GEN_TAC 7256 [``g:real->real``, ``h:real->real``, ``i:real``, ``j:real``] THEN 7257 REWRITE_TAC[GSYM CONJ_ASSOC] THEN 7258 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7259 DISCH_THEN(CONJUNCTS_THEN2 (MP_TAC o SPEC ``e / &4:real``) MP_TAC) THEN 7260 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7261 DISCH_THEN(CONJUNCTS_THEN2 (MP_TAC o SPEC ``e / &4:real``) STRIP_ASSUME_TAC) THEN 7262 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 7263 DISCH_THEN(X_CHOOSE_THEN ``B2:real`` 7264 (ASSUME_TAC)) THEN 7265 DISCH_THEN(X_CHOOSE_THEN ``B1:real`` 7266 (ASSUME_TAC)) THEN 7267 MAP_EVERY EXISTS_TAC 7268 [``\x. if x IN s then (g:real->real) x else 0``, 7269 ``\x. if x IN s then (h:real->real) x else 0``, 7270 ``integral(interval[a:real,b]) 7271 (\x. if x IN s then (g:real->real) x else 0:real)``, 7272 ``integral(interval[a:real,b]) 7273 (\x. if x IN s then (h:real->real) x else 0:real)``] THEN 7274 ASM_SIMP_TAC std_ss [INTEGRABLE_INTEGRAL] THEN 7275 CONJ_TAC THENL [ALL_TAC, METIS_TAC[REAL_LE_REFL]] THEN 7276 ABBREV_TAC ``c:real = @f. f = min ((a:real)) (-(max B1 B2))`` THEN 7277 ABBREV_TAC ``d:real = @f. f = max ((b:real)) (max B1 B2)`` THEN 7278 UNDISCH_TAC `` 0 < B2 /\ 7279 !a b. 7280 ball (0,B2) SUBSET interval [(a,b)] ==> 7281 abs 7282 (integral (interval [(a,b)]) (\x. if x IN s then h x else 0) - 7283 j) < e / 4:real`` THEN STRIP_TAC THEN 7284 POP_ASSUM (MP_TAC o SPECL [``c:real``, ``d:real``]) THEN 7285 UNDISCH_TAC ``0 < B1 /\ 7286 !a b. 7287 ball (0,B1) SUBSET interval [(a,b)] ==> 7288 abs 7289 (integral (interval [(a,b)]) (\x. if x IN s then g x else 0) - 7290 i) < e / 4:real`` THEN STRIP_TAC THEN 7291 POP_ASSUM (MP_TAC o SPECL [``c:real``, ``d:real``]) THEN 7292 MATCH_MP_TAC(TAUT 7293 `(a /\ c) /\ (b /\ d ==> e) ==> (a ==> b) ==> (c ==> d) ==> e`) THEN 7294 CONJ_TAC THENL 7295 [ CONJ_TAC THEN MAP_EVERY EXPAND_TAC ["c", "d"] THEN 7296 SIMP_TAC std_ss [SUBSET_DEF, IN_BALL, IN_INTERVAL] THEN 7297 GEN_TAC THEN REWRITE_TAC[DIST_0] THEN DISCH_TAC THEN (* 2 goals *) 7298 (* TODO: a common lemma between min,max,abs *) 7299 (Know `!x B:real. abs(x) <= B ==> min a (-B) <= x /\ x <= max b B` 7300 >- (rpt GEN_TAC \\ 7301 DISCH_THEN (STRIP_ASSUME_TAC o REWRITE_RULE [ABS_BOUNDS]) \\ 7302 PROVE_TAC [REAL_LE_MAX, REAL_MIN_LE]) \\ 7303 DISCH_THEN MATCH_MP_TAC) THEN 7304 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``abs(x:real)`` THEN 7305 ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE, REAL_LE_MAX, REAL_LE_REFL], 7306 ALL_TAC ] THEN 7307 7308 KNOW_TAC ``!ah ag ch cg. 7309 abs(i - j) < e / &4:real /\ 7310 abs(ah - ag) <= abs(ch - cg) 7311 ==> abs(cg - i) < e / &4 /\ 7312 abs(ch - j) < e / &4 7313 ==> abs(ag - ah) < e`` THENL 7314 [REPEAT GEN_TAC THEN 7315 SIMP_TAC std_ss [REAL_LT_RDIV_EQ, REAL_ARITH ``0 < 4:real``] THEN 7316 REAL_ARITH_TAC, DISCH_TAC] THEN 7317 FIRST_X_ASSUM (MATCH_MP_TAC) THEN 7318 ASM_SIMP_TAC std_ss [] THEN ASM_SIMP_TAC std_ss [GSYM INTEGRAL_SUB] THEN 7319 MATCH_MP_TAC lemma THEN CONJ_TAC THENL 7320 [ MATCH_MP_TAC(HAS_INTEGRAL_DROP_POS) THEN 7321 MAP_EVERY EXISTS_TAC 7322 [``(\x. (if x IN s then h x else 0) - (if x IN s then g x else 0)) 7323 :real->real``, 7324 ``interval[a:real,b]``] THEN 7325 ASM_SIMP_TAC std_ss [INTEGRABLE_INTEGRAL, HAS_INTEGRAL_SUB] THEN 7326 ASM_SIMP_TAC std_ss [INTEGRABLE_SUB, INTEGRABLE_INTEGRAL] THEN 7327 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 7328 ASM_SIMP_TAC std_ss [REAL_SUB_LE, REAL_POS] THEN 7329 ASM_MESON_TAC[REAL_LE_TRANS], 7330 ALL_TAC] THEN 7331 MATCH_MP_TAC (HAS_INTEGRAL_SUBSET_DROP_LE) THEN 7332 MAP_EVERY EXISTS_TAC 7333 [``(\x. (if x IN s then h x else 0) - (if x IN s then g x else 0)) 7334 :real->real``, 7335 ``interval[a:real,b]``, ``interval[c:real,d]``] THEN 7336 ASM_SIMP_TAC std_ss [INTEGRABLE_SUB, INTEGRABLE_INTEGRAL] THEN CONJ_TAC THENL 7337 [ REWRITE_TAC[SUBSET_INTERVAL] THEN DISCH_TAC THEN 7338 MAP_EVERY EXPAND_TAC ["c", "d"] THEN 7339 SIMP_TAC std_ss [] \\ 7340 PROVE_TAC [REAL_MIN_LE, REAL_LE_MAX, REAL_LE_REFL], 7341 ALL_TAC ] THEN 7342 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 7343 ASM_SIMP_TAC std_ss [REAL_SUB_LE, REAL_POS] THEN 7344 ASM_MESON_TAC[REAL_LE_TRANS], 7345 ALL_TAC] THEN 7346 7347 ONCE_REWRITE_TAC[INTEGRABLE_ALT] THEN ASM_REWRITE_TAC[] THEN 7348 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 7349 UNDISCH_TAC`` !(e :real). (0 :real) < e ==> 7350 ?(g :real -> real) (h :real -> real) (i :real) (j :real). 7351 (g has_integral i) (s :real -> bool) /\ 7352 (h has_integral j) s /\ abs (i - j) < e /\ 7353 !(x :real). 7354 x IN s ==> g x <= (f :real -> real) x /\ f x <= h x`` THEN DISCH_TAC THEN 7355 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &3:real``) THEN 7356 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 7357 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM, HAS_INTEGRAL_ALT] THEN 7358 MAP_EVERY X_GEN_TAC 7359 [``g:real->real``, ``h:real->real``, ``i:real``, ``j:real``] THEN 7360 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7361 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC STRIP_ASSUME_TAC) THEN 7362 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o SPEC ``e / &3:real``)) THEN 7363 FIRST_X_ASSUM(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o SPEC ``e / &3:real``)) THEN 7364 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 7365 DISCH_THEN(X_CHOOSE_THEN ``B1:real`` (ASSUME_TAC)) THEN 7366 DISCH_THEN(X_CHOOSE_THEN ``B2:real`` (ASSUME_TAC)) THEN 7367 EXISTS_TAC ``max B1 B2:real`` THEN 7368 ASM_SIMP_TAC std_ss [REAL_LT_MAX, BALL_MAX_UNION, UNION_SUBSET] THEN 7369 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``, ``c:real``, ``d:real``] THEN 7370 STRIP_TAC THEN REWRITE_TAC[] THEN 7371 KNOW_TAC ``e = e / &3 + e / &3 + e / &3:real`` THENL 7372 [REWRITE_TAC [GSYM REAL_ADD_RDISTRIB, real_div] THEN REWRITE_TAC [GSYM real_div] THEN 7373 SIMP_TAC std_ss [REAL_EQ_RDIV_EQ, REAL_ARITH ``0 < 3:real``] THEN REAL_ARITH_TAC, 7374 DISCH_TAC THEN ONCE_ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 7375 MATCH_MP_TAC(REAL_ARITH 7376 ``!ga gc ha hc i j. 7377 ga <= fa /\ fa <= ha /\ 7378 gc <= fc /\ fc <= hc /\ 7379 abs(ga - i) < e / &3 /\ 7380 abs(gc - i) < e / &3 /\ 7381 abs(ha - j) < e / &3 /\ 7382 abs(hc - j) < e / &3 /\ 7383 abs(i - j) < e / &3 7384 ==> abs(fa - fc) < e / &3 + e / &3 + e / &3:real``) THEN 7385 MAP_EVERY EXISTS_TAC 7386 [``(integral(interval[a:real,b]) (\x. if x IN s then g x else 0))``, 7387 ``(integral(interval[c:real,d]) (\x. if x IN s then g x else 0))``, 7388 ``(integral(interval[a:real,b]) (\x. if x IN s then h x else 0))``, 7389 ``(integral(interval[c:real,d]) (\x. if x IN s then h x else 0))``, 7390 ``i:real``, ``j:real``] THEN 7391 ASM_SIMP_TAC std_ss [] THEN 7392 REPEAT CONJ_TAC THEN MATCH_MP_TAC INTEGRAL_DROP_LE THEN 7393 ASM_REWRITE_TAC[] THEN REPEAT STRIP_TAC THEN BETA_TAC THEN 7394 COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [REAL_LE_REFL] 7395QED 7396 7397val HAS_INTEGRAL_STRADDLE_NULL = store_thm ("HAS_INTEGRAL_STRADDLE_NULL", 7398 ``!f g:real->real s. 7399 (!x. x IN s ==> &0 <= (f x) /\ (f x) <= (g x)) /\ 7400 (g has_integral (0)) s 7401 ==> (f has_integral (0)) s``, 7402 REPEAT STRIP_TAC THEN REWRITE_TAC[HAS_INTEGRAL_INTEGRABLE_INTEGRAL] THEN 7403 MATCH_MP_TAC(TAUT `a /\ (a ==> b) ==> a /\ b`) THEN CONJ_TAC THENL 7404 [MATCH_MP_TAC INTEGRABLE_STRADDLE THEN 7405 GEN_TAC THEN DISCH_TAC THEN 7406 MAP_EVERY EXISTS_TAC 7407 [``(\x. 0):real->real``, ``g:real->real``, 7408 ``0:real``, ``0:real``] THEN 7409 ASM_SIMP_TAC std_ss [HAS_INTEGRAL_0, REAL_SUB_REFL, ABS_0], 7410 DISCH_TAC THEN 7411 REWRITE_TAC[GSYM REAL_LE_ANTISYM] THEN CONJ_TAC THENL 7412 [MATCH_MP_TAC(ISPECL [``f:real->real``, ``g:real->real``] 7413 HAS_INTEGRAL_DROP_LE), 7414 MATCH_MP_TAC(ISPECL [``(\x. 0):real->real``, ``f:real->real``] 7415 HAS_INTEGRAL_DROP_LE)] THEN 7416 EXISTS_TAC ``s:real->bool`` THEN 7417 ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRAL, HAS_INTEGRAL_0]]); 7418 7419(* ------------------------------------------------------------------------- *) 7420(* Adding integrals over several sets. *) 7421(* ------------------------------------------------------------------------- *) 7422 7423val HAS_INTEGRAL_UNION = store_thm ("HAS_INTEGRAL_UNION", 7424 ``!f:real->real i j s t. 7425 (f has_integral i) s /\ (f has_integral j) t /\ negligible(s INTER t) 7426 ==> (f has_integral (i + j)) (s UNION t)``, 7427 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[GSYM HAS_INTEGRAL_RESTRICT_UNIV] THEN 7428 REWRITE_TAC[CONJ_ASSOC] THEN DISCH_THEN(CONJUNCTS_THEN ASSUME_TAC) THEN 7429 MATCH_MP_TAC HAS_INTEGRAL_SPIKE THEN 7430 EXISTS_TAC ``(\x. if x IN (s INTER t) then (&2:real) * f(x) 7431 else if x IN (s UNION t) then f(x) 7432 else 0:real):real->real`` THEN 7433 EXISTS_TAC ``s INTER t:real->bool`` THEN 7434 ASM_SIMP_TAC std_ss [IN_DIFF, IN_UNION, IN_INTER, IN_UNIV] THEN 7435 CONJ_TAC THENL [METIS_TAC[], ALL_TAC] THEN 7436 FIRST_X_ASSUM(MP_TAC o MATCH_MP HAS_INTEGRAL_ADD) THEN 7437 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN 7438 REWRITE_TAC[FUN_EQ_THM] THEN GEN_TAC THEN 7439 MAP_EVERY ASM_CASES_TAC [``(x:real) IN s``, ``(x:real) IN t``] THEN 7440 ASM_SIMP_TAC std_ss[] THEN REAL_ARITH_TAC); 7441 7442val INTEGRAL_UNION = store_thm ("INTEGRAL_UNION", 7443 ``!f:real->real s t. 7444 f integrable_on s /\ f integrable_on t /\ negligible(s INTER t) 7445 ==> (integral (s UNION t) f = integral s f + integral t f)``, 7446 REPEAT STRIP_TAC THEN 7447 MATCH_MP_TAC INTEGRAL_UNIQUE THEN 7448 MATCH_MP_TAC HAS_INTEGRAL_UNION THEN 7449 ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRAL]); 7450 7451val HAS_INTEGRAL_BIGUNION = store_thm ("HAS_INTEGRAL_BIGUNION", 7452 ``!f:real->real i t. 7453 FINITE t /\ 7454 (!s. s IN t ==> (f has_integral (i s)) s) /\ 7455 (!s s'. s IN t /\ s' IN t /\ ~(s = s') ==> negligible(s INTER s')) 7456 ==> (f has_integral (sum t i)) (BIGUNION t)``, 7457 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[GSYM HAS_INTEGRAL_RESTRICT_UNIV] THEN 7458 REWRITE_TAC[CONJ_ASSOC] THEN DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 7459 DISCH_TAC THEN POP_ASSUM (MP_TAC o ONCE_REWRITE_RULE [METIS [] 7460 ``!s:real->bool. (\x. if x IN s then (f:real->real) x else 0:real) = 7461 (\s. (\x. if x IN s then f x else 0:real)) s``]) THEN DISCH_TAC THEN 7462 FIRST_ASSUM(MP_TAC o MATCH_MP HAS_INTEGRAL_SUM) THEN SIMP_TAC std_ss [] THEN 7463 MATCH_MP_TAC(REWRITE_RULE[TAUT `a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] 7464 HAS_INTEGRAL_SPIKE) THEN 7465 EXISTS_TAC ``BIGUNION (IMAGE (\(a,b). a INTER b :real->bool) 7466 {(a,b) | a IN t /\ b IN {y | y IN t /\ ~(a = y)}})`` THEN 7467 CONJ_TAC THENL 7468 [MATCH_MP_TAC NEGLIGIBLE_BIGUNION THEN CONJ_TAC THENL 7469 [MATCH_MP_TAC IMAGE_FINITE THEN 7470 ONCE_REWRITE_TAC [METIS [] 7471 `` {(a,b) | a IN t /\ b IN {y | y IN t /\ a <> y}} = 7472 {(\a b. (a,b)) a b | a IN t /\ b IN (\a. {y | y IN t /\ a <> y}) a}``] THEN 7473 MATCH_MP_TAC FINITE_PRODUCT_DEPENDENT THEN 7474 ASM_SIMP_TAC std_ss [FINITE_RESTRICT], 7475 SIMP_TAC std_ss [FORALL_IN_IMAGE, FORALL_PROD, IN_ELIM_PAIR_THM] THEN 7476 ASM_SIMP_TAC std_ss [GSPECIFICATION]], 7477 X_GEN_TAC ``x:real`` THEN REWRITE_TAC[IN_UNIV, IN_DIFF] THEN 7478 ASM_CASES_TAC ``(x:real) IN BIGUNION t`` THEN ASM_SIMP_TAC std_ss [] THENL 7479 [ALL_TAC, 7480 RULE_ASSUM_TAC(REWRITE_RULE[SET_RULE 7481 ``~(x IN BIGUNION t) <=> !s. s IN t ==> ~(x IN s)``]) THEN 7482 DISCH_TAC THEN ONCE_REWRITE_TAC [METIS [SUM_0] 7483 ``0 = sum (t :(real -> bool) -> bool) (\(a :real -> bool). 0)``] THEN 7484 MATCH_MP_TAC SUM_EQ THEN GEN_TAC THEN DISCH_TAC THEN 7485 ASM_SIMP_TAC std_ss [SUM_0]] THEN 7486 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [IN_BIGUNION]) THEN 7487 DISCH_THEN(X_CHOOSE_THEN ``a:real->bool`` STRIP_ASSUME_TAC) THEN 7488 REWRITE_TAC [IN_BIGUNION] THEN ONCE_REWRITE_TAC [CONJ_SYM] THEN 7489 ONCE_REWRITE_TAC [METIS [SPECIFICATION] 7490 ``x IN (s:real->bool) <=> (\s. x IN s) s``] THEN 7491 REWRITE_TAC [EXISTS_IN_IMAGE] THEN BETA_TAC THEN 7492 ONCE_REWRITE_TAC [METIS [] 7493 ``(x' IN {(a,b) | a IN t /\ b IN {y | y IN t /\ a <> y}} /\ 7494 x IN (\(a,b). a INTER b) x') <=> 7495 (\x'. x' IN {(a,b) | a IN t /\ b IN {y | y IN t /\ a <> y}} /\ 7496 x IN (\(a,b). a INTER b) x') x'``] THEN 7497 REWRITE_TAC [EXISTS_PROD] THEN BETA_TAC THEN 7498 REWRITE_TAC [LAMBDA_PAIR] THEN BETA_TAC THEN REWRITE_TAC [FST, SND] THEN 7499 SIMP_TAC std_ss [IN_ELIM_PAIR_THM, NOT_EXISTS_THM] THEN 7500 ONCE_REWRITE_TAC [METIS [] ``a NOTIN b <=> ~(a IN b)``, GSYM DE_MORGAN_THM] THEN 7501 ONCE_REWRITE_TAC [METIS [] ``a NOTIN b <=> ~(a IN b)``, GSYM DE_MORGAN_THM] THEN 7502 DISCH_THEN(MP_TAC o SPEC ``a:real->bool``) THEN 7503 ASM_SIMP_TAC std_ss [GSPECIFICATION, IN_INTER] THEN 7504 ONCE_REWRITE_TAC [METIS [] ``a NOTIN b <=> ~(a IN b)``, GSYM DE_MORGAN_THM, 7505 METIS [] ``(a = b) <=> ~(a <> b)``] THEN 7506 ONCE_REWRITE_TAC [METIS [] ``a NOTIN b <=> ~(a IN b)``, GSYM DE_MORGAN_THM, 7507 METIS [] ``(a = b) <=> ~(a <> b)``] THEN 7508 ONCE_REWRITE_TAC [METIS [] ``a NOTIN b <=> ~(a IN b)``, GSYM DE_MORGAN_THM, 7509 METIS [] ``(a = b) <=> ~(a <> b)``] THEN 7510 ASM_SIMP_TAC std_ss [METIS[] 7511 ``x IN a /\ a IN t 7512 ==> ((!b. ~((b IN t /\ ~(a = b)) /\ x IN b)) <=> 7513 (!b. b IN t ==> (x IN b <=> (b = a))))``] THEN DISCH_TAC THEN 7514 KNOW_TAC ``sum (t :(real -> bool) -> bool) 7515 (\(a :real -> bool). if x IN a then f x else (0 :real)) = 7516 sum (t :(real -> bool) -> bool) 7517 (\(b :real -> bool). if (b :real -> bool) = a then f x else (0 :real))`` THENL 7518 [MATCH_MP_TAC SUM_EQ THEN METIS_TAC [], DISCH_TAC THEN ASM_REWRITE_TAC []] THEN 7519 ASM_SIMP_TAC std_ss [SUM_DELTA]]); 7520 7521val HAS_INTEGRAL_DIFF = store_thm ("HAS_INTEGRAL_DIFF", 7522 ``!f:real->real i j s t. 7523 (f has_integral i) s /\ 7524 (f has_integral j) t /\ 7525 negligible (t DIFF s) 7526 ==> (f has_integral (i - j)) (s DIFF t)``, 7527 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[GSYM HAS_INTEGRAL_RESTRICT_UNIV] THEN 7528 REWRITE_TAC[CONJ_ASSOC] THEN DISCH_THEN(CONJUNCTS_THEN ASSUME_TAC) THEN 7529 MATCH_MP_TAC HAS_INTEGRAL_SPIKE THEN 7530 EXISTS_TAC ``(\x. if x IN (t DIFF s) then -(f x) 7531 else if x IN (s DIFF t) then f x 7532 else 0):real->real`` THEN 7533 EXISTS_TAC ``t DIFF s:real->bool`` THEN 7534 ASM_REWRITE_TAC[IN_DIFF, IN_UNION, IN_INTER, IN_UNIV] THEN 7535 CONJ_TAC THENL [METIS_TAC[], ALL_TAC] THEN 7536 FIRST_X_ASSUM(MP_TAC o MATCH_MP HAS_INTEGRAL_SUB) THEN 7537 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN 7538 REWRITE_TAC[FUN_EQ_THM] THEN GEN_TAC THEN 7539 MAP_EVERY ASM_CASES_TAC [``(x:real) IN s``, ``(x:real) IN t``] THEN 7540 ASM_SIMP_TAC std_ss [] THEN REAL_ARITH_TAC); 7541 7542val INTEGRAL_DIFF = store_thm ("INTEGRAL_DIFF", 7543 ``!f:real->real s t. 7544 f integrable_on s /\ f integrable_on t /\ negligible(t DIFF s) 7545 ==> (integral (s DIFF t) f = integral s f - integral t f)``, 7546 REPEAT STRIP_TAC THEN 7547 MATCH_MP_TAC INTEGRAL_UNIQUE THEN 7548 MATCH_MP_TAC HAS_INTEGRAL_DIFF THEN 7549 ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRAL]); 7550 7551(* ------------------------------------------------------------------------------ *) 7552(* In particular adding integrals over a division, maybe not of an interval. 7044 *) 7553(* ------------------------------------------------------------------------------ *) 7554 7555val HAS_INTEGRAL_COMBINE_DIVISION = store_thm ("HAS_INTEGRAL_COMBINE_DIVISION", 7556 ``!f:real->real s d i. 7557 d division_of s /\ 7558 (!k. k IN d ==> (f has_integral (i k)) k) 7559 ==> (f has_integral (sum d i)) s``, 7560 REPEAT STRIP_TAC THEN 7561 UNDISCH_TAC ``d division_of s`` THEN DISCH_TAC THEN 7562 FIRST_ASSUM(SUBST1_TAC o SYM o last o CONJUNCTS o 7563 REWRITE_RULE [division_of]) THEN 7564 MATCH_MP_TAC HAS_INTEGRAL_BIGUNION THEN ASM_REWRITE_TAC[] THEN 7565 CONJ_TAC THENL [ASM_MESON_TAC[DIVISION_OF_FINITE], ALL_TAC] THEN 7566 MAP_EVERY X_GEN_TAC [``k1:real->bool``, ``k2:real->bool``] THEN 7567 STRIP_TAC THEN 7568 SUBGOAL_THEN ``?u v:real x y:real. 7569 (k1 = interval[u,v]) /\ (k2 = interval[x,y])`` 7570 (REPEAT_TCL CHOOSE_THEN (CONJUNCTS_THEN SUBST_ALL_TAC)) 7571 THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 7572 UNDISCH_TAC ``d division_of s`` THEN GEN_REWR_TAC LAND_CONV [division_of] THEN 7573 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7574 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7575 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 7576 DISCH_THEN(MP_TAC o SPECL 7577 [``interval[u:real,v]``, ``interval[x:real,y]``]) THEN 7578 ASM_REWRITE_TAC[INTERIOR_CLOSED_INTERVAL] THEN DISCH_TAC THEN 7579 MATCH_MP_TAC NEGLIGIBLE_SUBSET THEN 7580 EXISTS_TAC ``(interval[u,v:real] DIFF interval(u,v)) UNION 7581 (interval[x,y] DIFF interval(x,y))`` THEN 7582 SIMP_TAC std_ss [NEGLIGIBLE_FRONTIER_INTERVAL, NEGLIGIBLE_UNION] THEN 7583 ASM_SET_TAC[]); 7584 7585val INTEGRAL_COMBINE_DIVISION_BOTTOMUP = store_thm ("INTEGRAL_COMBINE_DIVISION_BOTTOMUP", 7586 ``!f:real->real d s. 7587 d division_of s /\ (!k. k IN d ==> f integrable_on k) 7588 ==> (integral s f = sum d (\i. integral i f))``, 7589 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 7590 MATCH_MP_TAC HAS_INTEGRAL_COMBINE_DIVISION THEN 7591 ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRAL]); 7592 7593val HAS_INTEGRAL_COMBINE_DIVISION_TOPDOWN = store_thm ("HAS_INTEGRAL_COMBINE_DIVISION_TOPDOWN", 7594 ``!f:real->real s d k. 7595 f integrable_on s /\ d division_of k /\ k SUBSET s 7596 ==> (f has_integral (sum d (\i. integral i f))) k``, 7597 REPEAT STRIP_TAC THEN 7598 MATCH_MP_TAC HAS_INTEGRAL_COMBINE_DIVISION THEN 7599 ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRAL] THEN 7600 FIRST_ASSUM(fn th => REWRITE_TAC[MATCH_MP FORALL_IN_DIVISION th]) THEN 7601 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 7602 EXISTS_TAC ``s:real->bool`` THEN ASM_SIMP_TAC std_ss [] THEN 7603 METIS_TAC[division_of, SUBSET_TRANS]); 7604 7605val INTEGRAL_COMBINE_DIVISION_TOPDOWN = store_thm ("INTEGRAL_COMBINE_DIVISION_TOPDOWN", 7606 ``!f:real->real d s. 7607 f integrable_on s /\ d division_of s 7608 ==> (integral s f = sum d (\i. integral i f))``, 7609 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 7610 MATCH_MP_TAC HAS_INTEGRAL_COMBINE_DIVISION_TOPDOWN THEN 7611 EXISTS_TAC ``s:real->bool`` THEN ASM_SIMP_TAC std_ss [SUBSET_REFL]); 7612 7613val INTEGRABLE_COMBINE_DIVISION = store_thm ("INTEGRABLE_COMBINE_DIVISION", 7614 ``!f d s. 7615 d division_of s /\ (!i. i IN d ==> f integrable_on i) 7616 ==> f integrable_on s``, 7617 REWRITE_TAC[integrable_on] THEN MESON_TAC[HAS_INTEGRAL_COMBINE_DIVISION]); 7618 7619val INTEGRABLE_ON_SUBDIVISION = store_thm ("INTEGRABLE_ON_SUBDIVISION", 7620 ``!f:real->real s d i. 7621 d division_of i /\ 7622 f integrable_on s /\ i SUBSET s 7623 ==> f integrable_on i``, 7624 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRABLE_COMBINE_DIVISION THEN 7625 EXISTS_TAC ``d:(real->bool)->bool`` THEN ASM_REWRITE_TAC[] THEN 7626 FIRST_ASSUM(fn th => REWRITE_TAC[MATCH_MP FORALL_IN_DIVISION th]) THEN 7627 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 7628 ASM_MESON_TAC[division_of, BIGUNION_SUBSET]); 7629 7630(* ------------------------------------------------------------------------- *) 7631(* Also tagged divisions. *) 7632(* ------------------------------------------------------------------------- *) 7633 7634val HAS_INTEGRAL_COMBINE_TAGGED_DIVISION = store_thm ("HAS_INTEGRAL_COMBINE_TAGGED_DIVISION", 7635 ``!f:real->real s p i. 7636 p tagged_division_of s /\ 7637 (!x k. (x,k) IN p ==> (f has_integral (i k)) k) 7638 ==> (f has_integral (sum p (\(x,k). i k))) s``, 7639 REPEAT STRIP_TAC THEN 7640 SUBGOAL_THEN 7641 ``!x:real k:real->bool. 7642 (x,k) IN p ==> ((f:real->real) has_integral integral k f) k`` 7643 ASSUME_TAC THENL 7644 [ASM_MESON_TAC[HAS_INTEGRAL_INTEGRAL, integrable_on], ALL_TAC] THEN 7645 SUBGOAL_THEN 7646 ``((f:real->real) has_integral 7647 (sum (IMAGE SND (p:real#(real->bool)->bool)) 7648 (\k. integral k f))) s`` 7649 MP_TAC THENL 7650 [MATCH_MP_TAC HAS_INTEGRAL_COMBINE_DIVISION THEN 7651 ASM_SIMP_TAC std_ss [FORALL_IN_IMAGE, FORALL_PROD] THEN 7652 ASM_SIMP_TAC std_ss [DIVISION_OF_TAGGED_DIVISION] THEN METIS_TAC [], 7653 ALL_TAC] THEN 7654 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN 7655 AP_TERM_TAC THEN CONV_TAC SYM_CONV THEN 7656 MATCH_MP_TAC EQ_TRANS THEN 7657 EXISTS_TAC ``sum p (\(x:real,k:real->bool). integral k f:real)`` THEN 7658 CONJ_TAC THENL 7659 [MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [FORALL_PROD] THEN 7660 ASM_MESON_TAC[HAS_INTEGRAL_UNIQUE], 7661 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) 7662 [METIS [] ``integral (k :real -> bool) f = (\k. integral k f) k``] THEN 7663 MATCH_MP_TAC SUM_OVER_TAGGED_DIVISION_LEMMA THEN 7664 EXISTS_TAC ``s:real->bool`` THEN ASM_SIMP_TAC std_ss [INTEGRAL_NULL]]); 7665 7666val INTEGRAL_COMBINE_TAGGED_DIVISION_BOTTOMUP = store_thm ("INTEGRAL_COMBINE_TAGGED_DIVISION_BOTTOMUP", 7667 ``!f:real->real p a b. 7668 p tagged_division_of interval[a,b] /\ 7669 (!x k. (x,k) IN p ==> f integrable_on k) 7670 ==> (integral (interval[a,b]) f = sum p (\(x,k). integral k f))``, 7671 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 7672 ONCE_REWRITE_TAC 7673 [METIS [] ``integral (k :real -> bool) f = (\k. integral k f) k``] THEN 7674 MATCH_MP_TAC HAS_INTEGRAL_COMBINE_TAGGED_DIVISION THEN 7675 ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRAL] THEN METIS_TAC []); 7676 7677val HAS_INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN = store_thm ("HAS_INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN", 7678 ``!f:real->real a b p. 7679 f integrable_on interval[a,b] /\ p tagged_division_of interval[a,b] 7680 ==> (f has_integral (sum p (\(x,k). integral k f))) (interval[a,b])``, 7681 REPEAT STRIP_TAC THEN 7682 ONCE_REWRITE_TAC 7683 [METIS [] ``integral (k :real -> bool) f = (\k. integral k f) k``] THEN 7684 MATCH_MP_TAC HAS_INTEGRAL_COMBINE_TAGGED_DIVISION THEN 7685 ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRAL] THEN 7686 ASM_MESON_TAC[INTEGRABLE_SUBINTERVAL, TAGGED_DIVISION_OF]); 7687 7688val INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN = store_thm ("INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN", 7689 ``!f:real->real a b p. 7690 f integrable_on interval[a,b] /\ p tagged_division_of interval[a,b] 7691 ==> (integral (interval[a,b]) f = sum p (\(x,k). integral k f))``, 7692 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 7693 MATCH_MP_TAC HAS_INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN THEN 7694 ASM_SIMP_TAC std_ss []); 7695 7696(* ------------------------------------------------------------------------- *) 7697(* Henstock's lemma. 7180 *) 7698(* ------------------------------------------------------------------------- *) 7699 7700val lemma = prove ( 7701 ``(!k. &0 < k ==> x <= e + k) ==> x <= e:real``, 7702 DISCH_THEN(MP_TAC o SPEC ``(x - e) / &2:real``) THEN 7703 ONCE_REWRITE_TAC [REAL_ADD_SYM] THEN REWRITE_TAC [GSYM REAL_LE_SUB_RADD] THEN 7704 SIMP_TAC std_ss [REAL_LE_RDIV_EQ, REAL_LT_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 7705 REAL_ARITH_TAC); 7706 7707val HENSTOCK_LEMMA_PART1 = store_thm ("HENSTOCK_LEMMA_PART1", 7708 ``!f:real->real a b d e. 7709 f integrable_on interval[a,b] /\ 7710 &0 < e /\ gauge d /\ 7711 (!p. p tagged_division_of interval[a,b] /\ d FINE p 7712 ==> abs (sum p (\(x,k). content k * f x) - 7713 integral(interval[a,b]) f) < e) 7714 ==> !p. p tagged_partial_division_of interval[a,b] /\ d FINE p 7715 ==> abs(sum p (\(x,k). content k * f x - 7716 integral k f)) <= e``, 7717 REPEAT GEN_TAC THEN STRIP_TAC THEN GEN_TAC THEN STRIP_TAC THEN 7718 MATCH_MP_TAC lemma THEN X_GEN_TAC ``k:real`` THEN DISCH_TAC THEN 7719 MP_TAC(ISPECL 7720 [``IMAGE SND (p:(real#(real->bool))->bool)``, ``a:real``, ``b:real``] 7721 PARTIAL_DIVISION_EXTEND_INTERVAL) THEN 7722 KNOW_TAC ``IMAGE (SND :real # (real -> bool) -> real -> bool) 7723 (p :real # (real -> bool) -> bool) division_of 7724 BIGUNION (IMAGE (SND :real # (real -> bool) -> real -> bool) p) /\ 7725 BIGUNION (IMAGE (SND :real # (real -> bool) -> real -> bool) p) SUBSET 7726 interval [((a :real),(b :real))]`` THENL 7727 [CONJ_TAC THENL 7728 [ASM_MESON_TAC[PARTIAL_DIVISION_OF_TAGGED_DIVISION], ALL_TAC] THEN 7729 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_BIGUNION] THEN 7730 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_IMAGE] THEN 7731 SIMP_TAC std_ss [FORALL_PROD] THEN 7732 ASM_MESON_TAC[tagged_partial_division_of, SUBSET_DEF], 7733 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 7734 SUBGOAL_THEN ``FINITE(p:(real#(real->bool))->bool)`` ASSUME_TAC THENL 7735 [ASM_MESON_TAC[tagged_partial_division_of], ALL_TAC] THEN 7736 DISCH_THEN(X_CHOOSE_THEN ``q:(real->bool)->bool`` STRIP_ASSUME_TAC) THEN 7737 FIRST_X_ASSUM(MP_TAC o MATCH_MP(SET_RULE 7738 ``s SUBSET t ==> (t = s UNION (t DIFF s))``)) THEN 7739 ABBREV_TAC ``r = q DIFF IMAGE SND (p:(real#(real->bool))->bool)`` THEN 7740 SUBGOAL_THEN ``IMAGE SND (p:(real#(real->bool))->bool) INTER r = {}`` 7741 ASSUME_TAC THENL [EXPAND_TAC "r" THEN SET_TAC[], ALL_TAC] THEN 7742 DISCH_THEN SUBST_ALL_TAC THEN 7743 SUBGOAL_THEN ``FINITE(r:(real->bool)->bool)`` ASSUME_TAC THENL 7744 [ASM_MESON_TAC[division_of, FINITE_UNION], ALL_TAC] THEN 7745 SUBGOAL_THEN 7746 ``!i. i IN r 7747 ==> ?p. p tagged_division_of i /\ d FINE p /\ 7748 abs(sum p (\(x,j). content j * f x) - 7749 integral i (f:real->real)) 7750 < k / (&(CARD(r:(real->bool)->bool)) + &1)`` 7751 MP_TAC THENL 7752 [X_GEN_TAC ``i:real->bool`` THEN DISCH_TAC THEN 7753 SUBGOAL_THEN ``(i:real->bool) SUBSET interval[a,b]`` ASSUME_TAC THENL 7754 [ASM_MESON_TAC[division_of, IN_UNION], ALL_TAC] THEN 7755 SUBGOAL_THEN ``?u v:real. i = interval[u,v]`` 7756 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 7757 THENL [ASM_MESON_TAC[division_of, IN_UNION], ALL_TAC] THEN 7758 SUBGOAL_THEN ``(f:real->real) integrable_on interval[u,v]`` MP_TAC THENL 7759 [ASM_MESON_TAC[INTEGRABLE_SUBINTERVAL], ALL_TAC] THEN 7760 DISCH_THEN(MP_TAC o MATCH_MP INTEGRABLE_INTEGRAL) THEN 7761 REWRITE_TAC[has_integral] THEN 7762 DISCH_THEN(MP_TAC o SPEC ``k / (&(CARD(r:(real->bool)->bool)) + &1:real)``) THEN 7763 ASM_SIMP_TAC std_ss [REAL_LT_DIV, 7764 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 7765 DISCH_THEN(X_CHOOSE_THEN ``dd:real->real->bool`` MP_TAC) THEN 7766 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7767 MP_TAC(ISPECL [``d:real->real->bool``, ``dd:real->real->bool``] 7768 GAUGE_INTER) THEN 7769 ASM_REWRITE_TAC[] THEN 7770 DISCH_THEN(MP_TAC o MATCH_MP FINE_DIVISION_EXISTS) THEN 7771 DISCH_THEN(MP_TAC o SPECL [``u:real``, ``v:real``]) THEN 7772 REWRITE_TAC[FINE_INTER] THEN MESON_TAC[], 7773 ALL_TAC] THEN 7774 SIMP_TAC std_ss [RIGHT_IMP_EXISTS_THM, SKOLEM_THM] THEN 7775 REWRITE_TAC[TAUT `(a ==> b /\ c) <=> (a ==> b) /\ (a ==> c)`] THEN 7776 SIMP_TAC std_ss [FORALL_AND_THM] THEN 7777 DISCH_THEN(X_CHOOSE_THEN ``q:(real->bool)->(real#(real->bool))->bool`` 7778 STRIP_ASSUME_TAC) THEN 7779 FIRST_X_ASSUM(MP_TAC o SPEC 7780 ``p UNION BIGUNION {q (i:real->bool) | i IN r} 7781 :(real#(real->bool))->bool``) THEN 7782 KNOW_TAC ``(p :real # (real -> bool) -> bool) UNION 7783 BIGUNION 7784 {(q :(real -> bool) -> real # (real -> bool) -> bool) i | 7785 i IN (r :(real -> bool) -> bool)} tagged_division_of 7786 interval [((a :real),(b :real))] /\ 7787 (d :real -> real -> bool) FINE p UNION BIGUNION {q i | i IN r}`` THENL 7788 [CONJ_TAC THENL 7789 [ALL_TAC, 7790 MATCH_MP_TAC FINE_UNION THEN ASM_REWRITE_TAC[] THEN 7791 MATCH_MP_TAC FINE_BIGUNION THEN ONCE_REWRITE_TAC[GSYM IMAGE_DEF] THEN 7792 ASM_SIMP_TAC std_ss [FORALL_IN_IMAGE]] THEN 7793 UNDISCH_TAC ``IMAGE (SND :real # (real -> bool) -> real -> bool) 7794 (p :real # (real -> bool) -> bool) UNION 7795 (r :(real -> bool) -> bool) division_of 7796 interval [((a :real),(b :real))]`` THEN DISCH_TAC THEN 7797 FIRST_ASSUM(SUBST1_TAC o SYM o last o CONJUNCTS o 7798 REWRITE_RULE [division_of]) THEN 7799 REWRITE_TAC[BIGUNION_UNION] THEN 7800 MATCH_MP_TAC TAGGED_DIVISION_UNION THEN CONJ_TAC THENL 7801 [ASM_MESON_TAC[TAGGED_PARTIAL_DIVISION_OF_UNION_SELF], ALL_TAC] THEN 7802 CONJ_TAC THENL 7803 [ONCE_REWRITE_TAC[GSYM IMAGE_DEF] THEN 7804 MATCH_MP_TAC TAGGED_DIVISION_BIGUNION THEN 7805 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 7806 SIMP_TAC std_ss [FINITE_UNION, IN_UNION] THEN ASM_MESON_TAC[], 7807 ALL_TAC] THEN 7808 MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 7809 REWRITE_TAC[OPEN_INTERIOR] THEN 7810 REPEAT(CONJ_TAC THENL 7811 [ASM_MESON_TAC[division_of, FINITE_UNION, IN_UNION], ALL_TAC]) THEN 7812 X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 7813 ONCE_REWRITE_TAC[INTER_COMM] THEN 7814 MATCH_MP_TAC INTER_INTERIOR_BIGUNION_INTERVALS THEN 7815 SIMP_TAC std_ss [FORALL_IN_IMAGE, FORALL_PROD, OPEN_INTERIOR] THEN 7816 REPEAT(CONJ_TAC THENL 7817 [ASM_MESON_TAC[tagged_partial_division_of, IMAGE_FINITE], ALL_TAC]) THEN 7818 REPEAT STRIP_TAC THEN 7819 UNDISCH_TAC ``IMAGE (SND :real # (real -> bool) -> real -> bool) 7820 (p :real # (real -> bool) -> bool) UNION 7821 (r :(real -> bool) -> bool) division_of 7822 interval [((a :real),(b :real))]`` THEN DISCH_TAC THEN 7823 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 7824 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7825 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7826 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 7827 DISCH_THEN (MATCH_MP_TAC) THEN 7828 UNDISCH_TAC `` IMAGE (SND :real # (real -> bool) -> real -> bool) 7829 (p :real # (real -> bool) -> bool) INTER 7830 (r :(real -> bool) -> bool) = 7831 ({} :(real -> bool) -> bool)`` THEN DISCH_TAC THEN 7832 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [EXTENSION]) THEN 7833 REWRITE_TAC [NOT_IN_EMPTY, GSYM NOT_EXISTS_THM] THEN 7834 REWRITE_TAC [METIS [NOT_EXISTS_THM] ``(!x. x NOTIN s) = ~(?x. x IN s)``] THEN 7835 ASM_SIMP_TAC std_ss [EXISTS_PROD, IN_IMAGE, IN_INTER, IN_UNION] THEN 7836 ASM_MESON_TAC[], 7837 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 7838 SUBGOAL_THEN 7839 ``sum (p UNION BIGUNION {q i | i IN r}) (\(x,k). content k * f x) = 7840 sum p (\(x:real,k:real->bool). content k * f x:real) + 7841 sum (BIGUNION {q i | (i:real->bool) IN r}) (\(x,k). content k * f x)`` 7842 SUBST1_TAC THENL 7843 [MATCH_MP_TAC SUM_UNION_NONZERO THEN ASM_SIMP_TAC std_ss [] THEN 7844 ONCE_REWRITE_TAC[GSYM IMAGE_DEF] THEN 7845 ASM_SIMP_TAC std_ss [FINITE_BIGUNION_EQ, IMAGE_FINITE, FORALL_IN_IMAGE] THEN 7846 CONJ_TAC THENL [METIS_TAC [TAGGED_DIVISION_OF_FINITE], ALL_TAC] THEN 7847 REWRITE_TAC[IN_INTER] THEN ONCE_REWRITE_TAC[CONJ_SYM] THEN 7848 SIMP_TAC std_ss [IMP_CONJ, FORALL_IN_BIGUNION, FORALL_IN_IMAGE] THEN 7849 SIMP_TAC std_ss [FORALL_PROD, FORALL_IN_IMAGE, RIGHT_FORALL_IMP_THM] THEN 7850 X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 7851 MAP_EVERY X_GEN_TAC [``x:real``, ``l:real->bool``] THEN 7852 DISCH_TAC THEN 7853 SUBGOAL_THEN ``(l:real->bool) SUBSET k`` ASSUME_TAC THENL 7854 [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN DISCH_TAC THEN 7855 UNDISCH_TAC ``IMAGE (SND :real # (real -> bool) -> real -> bool) 7856 (p :real # (real -> bool) -> bool) UNION 7857 (r :(real -> bool) -> bool) division_of 7858 interval [((a :real),(b :real))]`` THEN DISCH_TAC THEN 7859 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 7860 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7861 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7862 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 7863 DISCH_THEN(MP_TAC o SPECL [``k:real->bool``, ``l:real->bool``]) THEN 7864 KNOW_TAC ``(k :real -> bool) IN 7865 IMAGE (SND :real # (real -> bool) -> real -> bool) 7866 (p :real # (real -> bool) -> bool) UNION 7867 (r :(real -> bool) -> bool) /\ 7868 (l :real -> bool) IN 7869 IMAGE (SND :real # (real -> bool) -> real -> bool) p UNION r /\ 7870 k <> l`` THENL 7871 [ASM_SIMP_TAC std_ss [IN_UNION, IN_IMAGE, EXISTS_PROD] THEN 7872 CONJ_TAC THENL [ASM_MESON_TAC[], ALL_TAC] THEN 7873 DISCH_THEN(SUBST_ALL_TAC o SYM) THEN 7874 UNDISCH_TAC `` IMAGE (SND :real # (real -> bool) -> real -> bool) 7875 (p :real # (real -> bool) -> bool) INTER 7876 (r :(real -> bool) -> bool) = 7877 ({} :(real -> bool) -> bool)`` THEN DISCH_TAC THEN 7878 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [EXTENSION]) THEN 7879 REWRITE_TAC[NOT_IN_EMPTY, GSYM NOT_EXISTS_THM] THEN 7880 REWRITE_TAC [METIS [NOT_EXISTS_THM] ``(~!x. x NOTIN s) = (?x. x IN s)``] THEN 7881 ASM_SIMP_TAC std_ss [EXISTS_PROD, IN_IMAGE, IN_INTER, IN_UNION] THEN 7882 ASM_MESON_TAC[], 7883 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 7884 ASM_SIMP_TAC std_ss [SUBSET_INTERIOR, 7885 SET_RULE ``s SUBSET t ==> (t INTER s = s)``] THEN 7886 SUBGOAL_THEN ``?u v:real. l = interval[u,v]`` 7887 (fn th => REPEAT_TCL CHOOSE_THEN SUBST1_TAC th THEN 7888 SIMP_TAC std_ss [REAL_MUL_LZERO, GSYM CONTENT_EQ_0_INTERIOR]) THEN 7889 ASM_MESON_TAC[tagged_partial_division_of], 7890 ALL_TAC] THEN 7891 W(MP_TAC o PART_MATCH (lhand o rand) SUM_BIGUNION_NONZERO o 7892 rand o lhand o rand o lhand o lhand o snd) THEN 7893 KNOW_TAC ``FINITE 7894 {(q :(real -> bool) -> real # (real -> bool) -> bool) i | 7895 i IN (r :(real -> bool) -> bool)} /\ 7896 (!(t :real # (real -> bool) -> bool). 7897 t IN {q i | i IN r} ==> FINITE t) /\ 7898 (!(t1 :real # (real -> bool) -> bool) 7899 (t2 :real # (real -> bool) -> bool) (x :real # (real -> bool)). 7900 t1 IN {q i | i IN r} /\ t2 IN {q i | i IN r} /\ t1 <> t2 /\ 7901 x IN t1 /\ x IN t2 ==> 7902 ((\((x :real),(k :real -> bool)). content k * (f :real -> real) x) 7903 x = (0 : real)))`` THENL 7904 [ONCE_REWRITE_TAC[GSYM IMAGE_DEF] THEN ASM_SIMP_TAC std_ss [IMAGE_FINITE] THEN 7905 SIMP_TAC std_ss [IMP_CONJ, FORALL_IN_IMAGE, RIGHT_FORALL_IMP_THM] THEN 7906 CONJ_TAC THENL [ASM_MESON_TAC[TAGGED_DIVISION_OF, IN_UNION], ALL_TAC] THEN 7907 X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 7908 X_GEN_TAC ``l:real->bool`` THEN DISCH_TAC THEN 7909 DISCH_TAC THEN SIMP_TAC std_ss [FORALL_PROD] THEN 7910 MAP_EVERY X_GEN_TAC [``x:real``, ``m:real->bool``] THEN 7911 DISCH_TAC THEN DISCH_TAC THEN 7912 REWRITE_TAC[REAL_ENTIRE] THEN DISJ1_TAC THEN 7913 SUBGOAL_THEN ``?u v:real. m = interval[u,v]`` 7914 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 7915 THENL [ASM_MESON_TAC[TAGGED_DIVISION_OF, IN_UNION], ALL_TAC] THEN 7916 REWRITE_TAC[CONTENT_EQ_0_INTERIOR] THEN 7917 MATCH_MP_TAC(SET_RULE ``!t. s SUBSET t /\ (t = {}) ==> (s = {})``) THEN 7918 EXISTS_TAC ``interior(k INTER l:real->bool)`` THEN CONJ_TAC THENL 7919 [MATCH_MP_TAC SUBSET_INTERIOR THEN REWRITE_TAC[SUBSET_INTER] THEN 7920 ASM_MESON_TAC[TAGGED_DIVISION_OF], 7921 ALL_TAC] THEN 7922 UNDISCH_TAC `` IMAGE (SND :real # (real -> bool) -> real -> bool) 7923 (p :real # (real -> bool) -> bool) UNION 7924 (r :(real -> bool) -> bool) division_of 7925 interval [((a :real),(b :real))]`` THEN DISCH_TAC THEN 7926 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 7927 REWRITE_TAC[INTERIOR_INTER] THEN 7928 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7929 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 7930 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 7931 DISCH_THEN(MATCH_MP_TAC o SPECL [``k:real->bool``, ``l:real->bool``]) THEN 7932 SIMP_TAC std_ss [IN_IMAGE, EXISTS_PROD, IN_UNION] THEN ASM_MESON_TAC[], 7933 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 7934 DISCH_THEN SUBST1_TAC THEN ONCE_REWRITE_TAC[GSYM IMAGE_DEF] THEN 7935 W(MP_TAC o PART_MATCH (lhand o rand) SUM_IMAGE_NONZERO o 7936 rand o lhand o rand o lhand o lhand o snd) THEN 7937 ASM_SIMP_TAC std_ss [o_DEF] THEN 7938 KNOW_TAC ``(!(x :real -> bool) (y :real -> bool). 7939 x IN (r :(real -> bool) -> bool) /\ y IN r /\ x <> y /\ 7940 ((q :(real -> bool) -> real # (real -> bool) -> bool) x = q y) ==> 7941 (sum (q y) 7942 (\((x :real),(k :real -> bool)). 7943 content k * (f :real -> real) x) = (0 : real)))`` THENL 7944 [MAP_EVERY X_GEN_TAC [``k:real->bool``, ``l:real->bool``] THEN 7945 STRIP_TAC THEN MATCH_MP_TAC SUM_EQ_0 THEN 7946 SIMP_TAC std_ss [FORALL_PROD] THEN 7947 MAP_EVERY X_GEN_TAC [``x:real``, ``m:real->bool``] THEN DISCH_TAC THEN 7948 MP_TAC(ASSUME ``!i:real->bool. i IN r ==> q i tagged_division_of i``) THEN 7949 DISCH_TAC THEN FIRST_ASSUM (MP_TAC o SPEC ``l:real->bool``) THEN 7950 FIRST_ASSUM (MP_TAC o SPEC ``k:real->bool``) THEN POP_ASSUM K_TAC THEN 7951 REWRITE_TAC[tagged_division_of] THEN ASM_REWRITE_TAC [] THEN METIS_TAC[], 7952 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 7953 DISCH_THEN SUBST1_TAC THEN 7954 SUBGOAL_THEN 7955 ``sum p (\(x,k). content k * (f:real->real) x - integral k f) = 7956 sum p (\(x,k). content k * f x) - sum p (\(x,k). integral k f)`` 7957 SUBST1_TAC THENL [ASM_SIMP_TAC std_ss [GSYM SUM_SUB, LAMBDA_PROD], ALL_TAC] THEN 7958 MATCH_MP_TAC(REAL_ARITH 7959 ``!ir:real. (ip + ir = i) /\ 7960 abs(cr - ir) < k 7961 ==> abs((cp + cr) - i) < e ==> abs(cp - ip) <= e + k``) THEN 7962 EXISTS_TAC ``sum r (\k. integral k (f:real->real))`` THEN CONJ_TAC THENL 7963 [MATCH_MP_TAC EQ_TRANS THEN 7964 EXISTS_TAC ``sum (IMAGE SND (p:(real#(real->bool))->bool) UNION r) 7965 (\k. integral k (f:real->real))`` THEN 7966 CONJ_TAC THENL 7967 [ALL_TAC, METIS_TAC[INTEGRAL_COMBINE_DIVISION_TOPDOWN]] THEN 7968 MATCH_MP_TAC EQ_TRANS THEN 7969 EXISTS_TAC ``sum (IMAGE SND (p:(real#(real->bool))->bool)) 7970 (\k. integral k (f:real->real)) + 7971 sum r (\k. integral k f)`` THEN 7972 CONJ_TAC THENL 7973 [ALL_TAC, 7974 CONV_TAC SYM_CONV THEN MATCH_MP_TAC SUM_UNION_NONZERO THEN 7975 ASM_SIMP_TAC std_ss [IMAGE_FINITE, NOT_IN_EMPTY]] THEN 7976 AP_THM_TAC THEN AP_TERM_TAC THEN 7977 SUBGOAL_THEN ``(\(x:real,k). integral k (f:real->real)) = 7978 (\k. integral k f) o SND`` 7979 SUBST1_TAC THENL 7980 [SIMP_TAC std_ss [o_THM, FUN_EQ_THM, FORALL_PROD], ALL_TAC] THEN 7981 CONV_TAC SYM_CONV THEN REWRITE_TAC [REAL_EQ_RADD] THEN 7982 MATCH_MP_TAC SUM_IMAGE_NONZERO THEN 7983 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 7984 MAP_EVERY X_GEN_TAC 7985 [``x:real``, ``l:real->bool``, ``y:real``] THEN 7986 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 7987 DISCH_TAC THEN 7988 UNDISCH_TAC ``p tagged_partial_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 7989 FIRST_X_ASSUM(MP_TAC o 7990 REWRITE_RULE [tagged_partial_division_of]) THEN 7991 DISCH_THEN(CONJUNCTS_THEN MP_TAC o CONJUNCT2) THEN 7992 DISCH_THEN(MP_TAC o SPECL 7993 [``x:real``, ``l:real->bool``, ``y:real``, ``l:real->bool``]) THEN 7994 ASM_REWRITE_TAC[INTER_IDEMPOT] THEN DISCH_TAC THEN 7995 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``l:real->bool``]) THEN 7996 ASM_REWRITE_TAC[] THEN 7997 DISCH_THEN(REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC o last o CONJUNCTS) THEN 7998 MATCH_MP_TAC INTEGRAL_UNIQUE THEN MATCH_MP_TAC HAS_INTEGRAL_NULL THEN 7999 ASM_SIMP_TAC std_ss [CONTENT_EQ_0_INTERIOR], 8000 ALL_TAC] THEN 8001 ASM_SIMP_TAC std_ss [GSYM SUM_SUB] THEN MATCH_MP_TAC REAL_LET_TRANS THEN 8002 EXISTS_TAC ``sum (r:(real->bool)->bool) (\x. k / (&(CARD r) + &1))`` THEN 8003 CONJ_TAC THENL 8004 [MATCH_MP_TAC SUM_ABS_LE THEN ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE], 8005 ASM_SIMP_TAC std_ss [SUM_CONST] THEN 8006 REWRITE_TAC[real_div, REAL_MUL_ASSOC] THEN 8007 SIMP_TAC std_ss [GSYM real_div, REAL_LT_LDIV_EQ, 8008 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] 8009 ``&0 < &n + &1:real``] THEN 8010 REWRITE_TAC[REAL_ARITH ``a * k < k * b <=> &0 < k * (b - a:real)``] THEN 8011 MATCH_MP_TAC REAL_LT_MUL THEN ASM_REWRITE_TAC[] THEN REAL_ARITH_TAC]); 8012 8013val ABS_LE_L1 = store_thm ("ABS_LE_L1", 8014 ``!x:real. abs x <= sum((1:num)..(1:num)) (\i. abs(x))``, 8015 REWRITE_TAC [NUMSEG_SING, SUM_SING, REAL_LE_REFL]); 8016 8017val SUM_ABS_ALLSUBSETS_BOUND = store_thm ("SUM_ABS_ALLSUBSETS_BOUND", 8018 ``!f:'a->real p e. 8019 FINITE p /\ 8020 (!q. q SUBSET p ==> abs(sum q f) <= e) 8021 ==> sum p (\x. abs(f x)) <= &2 * &(1:num):real * e``, 8022 REPEAT STRIP_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN 8023 EXISTS_TAC 8024 ``sum p (\x:'a. sum ((1:num)..(1:num)) ((\x i. abs((f x:real))) x))`` THEN 8025 CONJ_TAC THENL 8026 [MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [ABS_LE_L1], ALL_TAC] THEN 8027 W(MP_TAC o PART_MATCH (lhand o rand) SUM_SWAP o lhand o snd) THEN 8028 ASM_REWRITE_TAC[FINITE_NUMSEG] THEN DISCH_THEN SUBST1_TAC THEN 8029 ONCE_REWRITE_TAC[REAL_ARITH ``&2 * &n * e = &n * &2 * e:real``] THEN 8030 BETA_TAC THEN 8031 GEN_REWR_TAC (RAND_CONV o ONCE_DEPTH_CONV) 8032 [METIS [GSYM CARD_NUMSEG_1] ``1:real = &CARD ((1:num)..(1:num))``] THEN 8033 REWRITE_TAC [GSYM REAL_MUL_ASSOC] THEN 8034 MATCH_MP_TAC SUM_BOUND THEN REWRITE_TAC[FINITE_NUMSEG, IN_NUMSEG] THEN 8035 X_GEN_TAC ``k:num`` THEN STRIP_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN 8036 EXISTS_TAC ``sum {x:'a | x IN p /\ &0 <= (f x:real)} (\x. abs((f x))) + 8037 sum {x | x IN p /\ (f x) < &0} (\x. abs((f x)))`` THEN 8038 CONJ_TAC THENL 8039 [MATCH_MP_TAC(REAL_ARITH ``(a = b) ==> b <= a:real``) THEN 8040 MATCH_MP_TAC SUM_UNION_EQ THEN 8041 ASM_SIMP_TAC std_ss [EXTENSION, NOT_IN_EMPTY, IN_INTER, 8042 IN_UNION, GSPECIFICATION] THEN 8043 CONJ_TAC THEN X_GEN_TAC ``x:'a`` THEN ASM_CASES_TAC ``(x:'a) IN p`` THEN 8044 ASM_SIMP_TAC std_ss [] THEN REAL_ARITH_TAC, 8045 ALL_TAC] THEN 8046 MATCH_MP_TAC(REAL_ARITH ``x <= e /\ y <= e ==> x + y <= &2 * e:real``) THEN 8047 GEN_REWR_TAC (RAND_CONV o ONCE_DEPTH_CONV) [GSYM ABS_NEG] THEN 8048 CONJ_TAC THEN MATCH_MP_TAC(REAL_ARITH 8049 ``!g. (sum s g = sum s f) /\ sum s g <= e ==> sum s f <= e:real``) 8050 THENL 8051 [EXISTS_TAC ``\x. ((f:'a->real) x)``, 8052 EXISTS_TAC ``\x. -(((f:'a->real) x))``] THEN 8053 (CONJ_TAC THENL 8054 [MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [GSPECIFICATION] THEN REAL_ARITH_TAC, 8055 ALL_TAC]) THEN 8056 ASM_SIMP_TAC std_ss [SUM_NEG, FINITE_RESTRICT] THEN 8057 MATCH_MP_TAC(REAL_ARITH ``abs(x) <= e ==> x <= e:real``) THEN 8058 SIMP_TAC std_ss [ABS_NEG, ETA_AX] THEN 8059 FIRST_X_ASSUM MATCH_MP_TAC THEN SET_TAC[]); 8060 8061val HENSTOCK_LEMMA_PART2 = store_thm ("HENSTOCK_LEMMA_PART2", 8062 ``!f:real->real a b d e. 8063 f integrable_on interval[a,b] /\ 8064 &0 < e /\ gauge d /\ 8065 (!p. p tagged_division_of interval[a,b] /\ d FINE p 8066 ==> abs (sum p (\(x,k). content k * f x) - 8067 integral(interval[a,b]) f) < e) 8068 ==> !p. p tagged_partial_division_of interval[a,b] /\ d FINE p 8069 ==> sum p (\(x,k). abs(content k * f x - 8070 integral k f)) 8071 <= &2 * &(1:num):real * e``, 8072 REPEAT STRIP_TAC THEN SIMP_TAC std_ss [LAMBDA_PAIR] THEN 8073 ONCE_REWRITE_TAC [METIS [] 8074 ``(content (SND p) * f (FST p) - integral (SND p) f) = 8075 (\p. (content (SND p) * f (FST p) - integral (SND p) f)) p``] THEN 8076 MATCH_MP_TAC SUM_ABS_ALLSUBSETS_BOUND THEN 8077 SIMP_TAC std_ss [LAMBDA_PROD] THEN 8078 CONJ_TAC THENL [ASM_MESON_TAC[tagged_partial_division_of], ALL_TAC] THEN 8079 X_GEN_TAC ``q:(real#(real->bool))->bool`` THEN DISCH_TAC THEN 8080 MATCH_MP_TAC(SIMP_RULE std_ss [RIGHT_IMP_FORALL_THM, AND_IMP_INTRO] 8081 HENSTOCK_LEMMA_PART1) THEN 8082 MAP_EVERY EXISTS_TAC 8083 [``a:real``, ``b:real``, ``d:real->real->bool``] THEN 8084 ASM_SIMP_TAC std_ss [] THEN 8085 ASM_MESON_TAC[FINE_SUBSET, TAGGED_PARTIAL_DIVISION_SUBSET]); 8086 8087val HENSTOCK_LEMMA = store_thm ("HENSTOCK_LEMMA", 8088 ``!f:real->real a b. 8089 f integrable_on interval[a,b] 8090 ==> !e. &0 < e 8091 ==> ?d. gauge d /\ 8092 !p. p tagged_partial_division_of interval[a,b] /\ 8093 d FINE p 8094 ==> sum p (\(x,k). abs(content k * f x - 8095 integral k f)) < e``, 8096 MP_TAC HENSTOCK_LEMMA_PART2 THEN 8097 DISCH_TAC THEN REPEAT GEN_TAC THEN 8098 POP_ASSUM (MP_TAC o Q.SPECL [`(f :real -> real)`, `(a :real)`, `(b :real)`]) THEN 8099 DISCH_THEN(fn th => STRIP_TAC THEN X_GEN_TAC ``e:real`` THEN 8100 STRIP_TAC THEN MP_TAC th) THEN 8101 FIRST_ASSUM(MP_TAC o MATCH_MP INTEGRABLE_INTEGRAL) THEN 8102 GEN_REWR_TAC LAND_CONV [has_integral] THEN 8103 DISCH_THEN(MP_TAC o SPEC ``e / (&2 * (&(1:num) + &1:real))``) THEN 8104 ASM_SIMP_TAC std_ss [REAL_LT_DIV, REAL_ARITH ``&0 < &2 * (&1 + &1:real)``] THEN 8105 DISCH_THEN(X_CHOOSE_THEN ``d:real->real->bool`` STRIP_ASSUME_TAC) THEN 8106 DISCH_THEN(MP_TAC o SPECL 8107 [``d:real->real->bool``, ``e / (&2 * (&(1:num) + &1:real))``]) THEN 8108 ASM_SIMP_TAC std_ss [REAL_LT_DIV, REAL_ARITH ``&0 < &2 * (&1 + &1:real)``] THEN 8109 DISCH_THEN(fn th => EXISTS_TAC ``d:real->real->bool`` THEN MP_TAC th) THEN 8110 ASM_SIMP_TAC std_ss [] THEN DISCH_TAC THEN GEN_TAC THEN 8111 POP_ASSUM (MP_TAC o Q.SPEC `(p :real # (real -> bool) -> bool)`) THEN 8112 MATCH_MP_TAC MONO_IMP THEN SIMP_TAC std_ss [] THEN 8113 MATCH_MP_TAC(REAL_ARITH ``d < e ==> x <= d ==> x < e:real``) THEN 8114 SIMP_TAC std_ss [real_div, REAL_INV_MUL, REAL_INV_INV, REAL_MUL_ASSOC] THEN 8115 SIMP_TAC std_ss [GSYM real_div, REAL_LT_LDIV_EQ, 8116 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 8117 SIMP_TAC std_ss [REAL_LT_LDIV_EQ, REAL_ARITH ``0:real < (2 * (1 + 1))``] THEN 8118 UNDISCH_TAC ``&0 < e:real`` THEN REAL_ARITH_TAC); 8119 8120(* ------------------------------------------------------------------------- *) 8121(* Monotone convergence (bounded interval first). *) 8122(* ------------------------------------------------------------------------- *) 8123 8124val lemma = prove ( 8125 ``{(x,y) | P x y} = {p | P (FST p) (SND p)}``, 8126 SIMP_TAC std_ss [EXTENSION, FORALL_PROD, IN_ELIM_PAIR_THM, GSPECIFICATION]); 8127 8128val MONOTONE_CONVERGENCE_INTERVAL = store_thm ("MONOTONE_CONVERGENCE_INTERVAL", 8129 ``!f:num->real->real g a b. 8130 (!k. (f k) integrable_on interval[a,b]) /\ 8131 (!k x. x IN interval[a,b] ==> (f k x) <= (f (SUC k) x)) /\ 8132 (!x. x IN interval[a,b] ==> ((\k. f k x) --> g x) sequentially) /\ 8133 bounded {integral (interval[a,b]) (f k) | k IN univ(:num)} 8134 ==> g integrable_on interval[a,b] /\ 8135 ((\k. integral (interval[a,b]) (f k)) 8136 --> integral (interval[a,b]) g) sequentially``, 8137 REPEAT GEN_TAC THEN STRIP_TAC THEN 8138 ASM_CASES_TAC ``content(interval[a:real,b]) = &0`` THENL 8139 [ASM_SIMP_TAC std_ss [INTEGRAL_NULL, INTEGRABLE_ON_NULL, LIM_CONST], 8140 RULE_ASSUM_TAC(REWRITE_RULE[GSYM CONTENT_LT_NZ])] THEN 8141 SUBGOAL_THEN 8142 ``!x:real k:num. x IN interval[a,b] ==> (f k x) <= (g x):real`` 8143 ASSUME_TAC THENL 8144 [REPEAT STRIP_TAC THEN 8145 MATCH_MP_TAC(ISPEC ``sequentially`` LIM_DROP_LBOUND) THEN 8146 EXISTS_TAC ``\k. (f:num->real->real) k x`` THEN 8147 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_SEQUENTIALLY, EVENTUALLY_SEQUENTIALLY] THEN 8148 EXISTS_TAC ``k:num`` THEN SPEC_TAC(``k:num``,``k:num``) THEN 8149 ONCE_REWRITE_TAC [METIS [] 8150 ``!k x'. ((f:num->real->real) k x <= f x' x) = 8151 (\k x'. f k x <= f x' x) k x'``] THEN 8152 MATCH_MP_TAC TRANSITIVE_STEPWISE_LE THEN SIMP_TAC std_ss [REAL_LE_TRANS] THEN 8153 ASM_SIMP_TAC std_ss [REAL_LE_REFL] THEN METIS_TAC [REAL_LE_TRANS], 8154 ALL_TAC] THEN 8155 SUBGOAL_THEN 8156 ``?i. ((\k. integral (interval[a,b]) (f k:real->real)) --> i) 8157 sequentially`` 8158 CHOOSE_TAC THENL 8159 [MATCH_MP_TAC BOUNDED_INCREASING_CONVERGENT THEN ASM_SIMP_TAC std_ss [] THEN 8160 GEN_TAC THEN MATCH_MP_TAC INTEGRAL_DROP_LE THEN ASM_REWRITE_TAC[], 8161 ALL_TAC] THEN 8162 SUBGOAL_THEN 8163 ``!k. (integral(interval[a,b]) ((f:num->real->real) k)) <= i`` 8164 ASSUME_TAC THENL 8165 [GEN_TAC THEN MATCH_MP_TAC(ISPEC ``sequentially`` LIM_DROP_LBOUND) THEN 8166 EXISTS_TAC ``\k. integral(interval[a,b]) ((f:num->real->real) k)`` THEN 8167 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_SEQUENTIALLY, EVENTUALLY_SEQUENTIALLY] THEN 8168 EXISTS_TAC ``k:num`` THEN SPEC_TAC(``k:num``,``k:num``) THEN 8169 ONCE_REWRITE_TAC [METIS [] 8170 ``(integral (interval [(a,b)]) (f k) <= integral (interval [(a,b)]) (f x)) = 8171 (\k x. integral (interval [(a,b)]) (f k) <= 8172 integral (interval [(a,b)]) (f x)) k x``] THEN 8173 MATCH_MP_TAC TRANSITIVE_STEPWISE_LE THEN 8174 ASM_SIMP_TAC std_ss [REAL_LE_REFL, REAL_LE_TRANS] THEN 8175 CONJ_TAC THENL [METIS_TAC [REAL_LE_TRANS], ALL_TAC] THEN 8176 GEN_TAC THEN MATCH_MP_TAC INTEGRAL_DROP_LE THEN ASM_REWRITE_TAC[], 8177 ALL_TAC] THEN 8178 SUBGOAL_THEN 8179 ``((g:real->real) has_integral i) (interval[a,b])`` 8180 ASSUME_TAC THENL 8181 [REWRITE_TAC[has_integral] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 8182 UNDISCH_TAC ``!k:num. f k integrable_on interval [(a,b)]`` THEN DISCH_TAC THEN 8183 FIRST_ASSUM(MP_TAC o REWRITE_RULE [HAS_INTEGRAL_INTEGRAL]) THEN 8184 REWRITE_TAC[has_integral] THEN 8185 DISCH_THEN(MP_TAC o GEN ``k:num`` o 8186 SPECL [``k:num``, ``e / (&2:real) pow (k + 2)``]) THEN 8187 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_POW_LT, REAL_LT] THEN 8188 DISCH_TAC THEN POP_ASSUM (MP_TAC o SIMP_RULE std_ss [SKOLEM_THM]) THEN 8189 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM, FORALL_AND_THM] THEN 8190 X_GEN_TAC ``b:num->real->real->bool`` THEN STRIP_TAC THEN 8191 SUBGOAL_THEN 8192 ``?r. !k. r:num <= k 8193 ==> &0 <= i - (integral(interval[a:real,b]) (f k)) /\ 8194 i - (integral(interval[a,b]) (f k)) < e / &4`` 8195 STRIP_ASSUME_TAC THENL 8196 [UNDISCH_TAC `` ((\k. integral (interval [(a,b)]) (f k)) --> i) sequentially`` THEN 8197 DISCH_TAC THEN 8198 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [LIM_SEQUENTIALLY]) THEN 8199 DISCH_THEN(MP_TAC o SPEC ``e / &4:real``) THEN 8200 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT] THEN 8201 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 8202 X_GEN_TAC ``n:num`` THEN POP_ASSUM (MP_TAC o Q.SPEC `n:num`) THEN 8203 MATCH_MP_TAC MONO_IMP THEN REWRITE_TAC[dist] THEN 8204 MATCH_MP_TAC(REAL_ARITH 8205 ``x <= y ==> abs(x - y) < e ==> &0 <= y - x /\ y - x < e:real``) THEN 8206 ASM_REWRITE_TAC[], 8207 ALL_TAC] THEN 8208 SUBGOAL_THEN 8209 ``!x. x IN interval[a:real,b] 8210 ==> ?n. r:num <= n /\ 8211 !k. n <= k ==> &0 <= (g x) - (f k x) /\ 8212 (g x) - (f k x) < 8213 e / (&4 * content(interval[a,b]))`` 8214 MP_TAC THENL 8215 [X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 8216 UNDISCH_TAC ``!x. x IN interval [(a,b)] ==> 8217 ((\k. f k x) --> g x) sequentially`` THEN 8218 DISCH_TAC THEN 8219 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE[LIM_SEQUENTIALLY]) THEN 8220 DISCH_THEN(MP_TAC o SPEC ``x:real``) THEN ASM_SIMP_TAC std_ss [REAL_SUB_LE] THEN 8221 DISCH_THEN(MP_TAC o SPEC ``e / (&4 * content(interval[a:real,b]))``) THEN 8222 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_LT_MUL, REAL_LT] THEN 8223 REWRITE_TAC[dist] THEN 8224 ASM_SIMP_TAC std_ss [REAL_ARITH ``f <= g ==> (abs(f - g) = g - f:real)``] THEN 8225 DISCH_THEN(X_CHOOSE_TAC ``N:num``) THEN 8226 EXISTS_TAC ``N + r:num`` THEN CONJ_TAC THENL [ARITH_TAC, ALL_TAC] THEN 8227 ASM_MESON_TAC[ARITH_PROVE ``N + r:num <= k ==> N <= k``], 8228 ALL_TAC] THEN 8229 DISCH_TAC THEN POP_ASSUM (MP_TAC o SIMP_RULE std_ss [RIGHT_IMP_EXISTS_THM]) THEN 8230 SIMP_TAC std_ss [SKOLEM_THM] THEN 8231 SIMP_TAC std_ss [FORALL_AND_THM, TAUT 8232 `a ==> b /\ c <=> (a ==> b) /\ (a ==> c)`] THEN 8233 SIMP_TAC std_ss [RIGHT_IMP_FORALL_THM, AND_IMP_INTRO] THEN 8234 DISCH_THEN(X_CHOOSE_THEN ``m:real->num`` STRIP_ASSUME_TAC) THEN 8235 ABBREV_TAC ``d:real->real->bool = \x. b(m x:num) x`` THEN 8236 EXISTS_TAC ``d:real->real->bool`` THEN CONJ_TAC THENL 8237 [EXPAND_TAC "d" THEN REWRITE_TAC[gauge_def] THEN 8238 UNDISCH_TAC ``!k:num. gauge (b k)`` THEN DISCH_TAC THEN 8239 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [gauge_def]) THEN 8240 SIMP_TAC std_ss [], 8241 ALL_TAC] THEN 8242 X_GEN_TAC ``p:(real#(real->bool))->bool`` THEN STRIP_TAC THEN 8243 GEN_REWR_TAC (RAND_CONV) [GSYM REAL_HALF] THEN 8244 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 8245 REWRITE_TAC [METIS [real_div, GSYM REAL_INV_MUL, REAL_ARITH ``0 <> 2:real``, 8246 REAL_ARITH ``2 * 2 = 4:real``, GSYM REAL_MUL_ASSOC] 8247 ``e / 2 / 2 = e / 4:real``] THEN 8248 MATCH_MP_TAC(REAL_ARITH 8249 ``!b c. abs(a - b) <= e / &4 /\ 8250 abs(b - c) < e / &2 /\ 8251 abs(c - d) < e / &4 8252 ==> abs(a - d) < e:real / 2 + (e / 4 + e / 4)``) THEN 8253 EXISTS_TAC ``sum p (\(x:real,k:real->bool). 8254 content k * (f:num->real->real) (m x) x)`` THEN 8255 EXISTS_TAC ``sum p (\(x:real,k:real->bool). 8256 integral k ((f:num->real->real) (m x)))`` THEN 8257 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 8258 SUBGOAL_THEN ``?s:num. !t:real#(real->bool). t IN p ==> m(FST t) <= s`` 8259 MP_TAC THENL [ASM_SIMP_TAC std_ss [UPPER_BOUND_FINITE_SET], ALL_TAC] THEN 8260 SIMP_TAC std_ss [FORALL_PROD] THEN DISCH_THEN(X_CHOOSE_TAC ``s:num``) THEN 8261 REPEAT CONJ_TAC THENL 8262 [ASM_SIMP_TAC std_ss [GSYM SUM_SUB] THEN SIMP_TAC std_ss [LAMBDA_PROD] THEN 8263 SIMP_TAC std_ss [GSYM REAL_SUB_LDISTRIB] THEN 8264 W(MP_TAC o PART_MATCH (lhand o rand) SUM_ABS o lhand o snd) THEN 8265 ASM_SIMP_TAC std_ss [] THEN 8266 MATCH_MP_TAC(REAL_ARITH ``y <= e ==> x <= y ==> x <= e:real``) THEN 8267 SIMP_TAC std_ss [LAMBDA_PROD] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 8268 EXISTS_TAC 8269 ``sum p (\(x:real,k:real->bool). 8270 content k * e / (&4 * content (interval[a:real,b])))`` THEN 8271 CONJ_TAC THENL 8272 [MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 8273 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN 8274 DISCH_TAC THEN SIMP_TAC std_ss [ABS_MUL, GSYM REAL_SUB_LDISTRIB] THEN 8275 REWRITE_TAC [real_div, GSYM REAL_MUL_ASSOC] THEN 8276 REWRITE_TAC [GSYM real_div] THEN 8277 MATCH_MP_TAC REAL_LE_MUL2 THEN 8278 SIMP_TAC std_ss [REAL_ABS_POS, ABS_POS] THEN 8279 REWRITE_TAC[REAL_ARITH ``abs(x) <= x <=> &0 <= x:real``] THEN CONJ_TAC THENL 8280 [ASM_MESON_TAC[CONTENT_POS_LE, TAGGED_DIVISION_OF], ALL_TAC] THEN 8281 MATCH_MP_TAC(REAL_ARITH 8282 ``&0 <= g - f /\ g - f < e ==> abs(g - f) <= e:real``) THEN 8283 CONJ_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 8284 REWRITE_TAC[LESS_EQ_REFL] THEN ASM_MESON_TAC[TAGGED_DIVISION_OF, SUBSET_DEF], 8285 ALL_TAC] THEN 8286 SIMP_TAC std_ss [LAMBDA_PAIR] THEN 8287 ONCE_REWRITE_TAC [METIS [] ``content (SND p) = (\p. content (SND p)) p``] THEN 8288 REWRITE_TAC [real_div, GSYM REAL_MUL_ASSOC] THEN 8289 REWRITE_TAC [GSYM real_div] THEN 8290 REWRITE_TAC [SUM_RMUL] THEN SIMP_TAC std_ss [LAMBDA_PROD] THEN 8291 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 8292 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP 8293 ADDITIVE_CONTENT_TAGGED_DIVISION th]) THEN 8294 MATCH_MP_TAC REAL_EQ_IMP_LE THEN 8295 UNDISCH_TAC ``&0 < content(interval[a:real,b])`` THEN 8296 REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN 8297 SIMP_TAC std_ss [REAL_LT_IMP_NE, REAL_INV_MUL, REAL_ARITH ``4 <> 0:real``] THEN 8298 REWRITE_TAC [REAL_MUL_ASSOC] THEN 8299 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c * d = (a * d) * b * c:real``] THEN 8300 SIMP_TAC std_ss [REAL_LT_IMP_NE, REAL_MUL_RINV, REAL_MUL_LID], 8301 ASM_SIMP_TAC std_ss [GSYM SUM_SUB] THEN SIMP_TAC std_ss [LAMBDA_PAIR] THEN 8302 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC 8303 ``abs(sum ((0:num)..s) 8304 (\j. sum {(x:real,k:real->bool) | (x,k) IN p /\ (m(x) = j)} 8305 (\(x,k). content k * f (m x) x :real - 8306 integral k (f (m x)))))`` THEN 8307 CONJ_TAC THENL 8308 [MATCH_MP_TAC REAL_EQ_IMP_LE THEN SIMP_TAC std_ss [lemma] THEN 8309 AP_TERM_TAC THEN SIMP_TAC std_ss [LAMBDA_PAIR] THEN 8310 REWRITE_TAC [SET_RULE ``{p' | p' IN p /\ (m (FST p') = j)} = 8311 {p' | p' IN p /\ ((\p'. m (FST p')) p' = j)}``] THEN 8312 MATCH_MP_TAC(GSYM SUM_GROUP) THEN 8313 ASM_SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_IMAGE, IN_NUMSEG, LE_0] THEN 8314 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN METIS_TAC [], 8315 ALL_TAC] THEN 8316 MATCH_MP_TAC REAL_LET_TRANS THEN 8317 EXISTS_TAC ``sum ((0:num)..s) (\i. e / &2 pow (i + 2))`` THEN CONJ_TAC THENL 8318 [ALL_TAC, 8319 SIMP_TAC std_ss [real_div, GSYM REAL_POW_INV, SUM_LMUL] THEN 8320 SIMP_TAC std_ss [REAL_POW_ADD, SUM_RMUL] THEN REWRITE_TAC[SUM_GP] THEN 8321 KNOW_TAC ``inv 2 <> 1:real`` THENL 8322 [SIMP_TAC std_ss [REAL_INV_1OVER, REAL_EQ_LDIV_EQ, 8323 REAL_ARITH ``0 < 2:real``] THEN 8324 REAL_ARITH_TAC, DISCH_TAC] THEN 8325 ASM_SIMP_TAC std_ss [pow, REAL_LT_LMUL] THEN 8326 SIMP_TAC std_ss [METIS [REAL_HALF_DOUBLE, 8327 REAL_EQ_SUB_RADD, REAL_INV_1OVER] 8328 ``1 - inv 2 = inv 2:real``] THEN 8329 REWRITE_TAC [real_div, REAL_INV_INV, POW_2] THEN 8330 ONCE_REWRITE_TAC [REAL_ARITH 8331 ``a * b * (c * d) = a * (b * c) * d:real``] THEN 8332 REWRITE_TAC [METIS [REAL_MUL_RINV, REAL_ARITH ``2 <> 0:real``] 8333 ``2 * inv 2 = 1:real``] THEN 8334 GEN_REWR_TAC RAND_CONV [GSYM REAL_MUL_LID] THEN 8335 SIMP_TAC std_ss [REAL_LT_RMUL, REAL_INV_POS, 8336 REAL_ARITH ``0 < 2:real``] THEN 8337 REWRITE_TAC [REAL_MUL_RID, real_sub] THEN 8338 GEN_REWR_TAC RAND_CONV [GSYM REAL_ADD_RID] THEN 8339 REWRITE_TAC [REAL_LT_LADD] THEN REWRITE_TAC [GSYM pow] THEN 8340 ONCE_REWRITE_TAC [GSYM REAL_LT_NEG] THEN 8341 REWRITE_TAC [REAL_NEG_0, REAL_NEG_NEG] THEN 8342 MATCH_MP_TAC POW_POS_LT THEN 8343 SIMP_TAC std_ss [REAL_INV_1OVER, REAL_LT_RDIV_EQ, 8344 REAL_ARITH ``0 < 2:real``] THEN 8345 REAL_ARITH_TAC] THEN 8346 MATCH_MP_TAC SUM_ABS_LE THEN REWRITE_TAC[FINITE_NUMSEG] THEN 8347 X_GEN_TAC ``t:num`` THEN REWRITE_TAC[IN_NUMSEG, LE_0] THEN DISCH_TAC THEN 8348 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 8349 ``abs(sum {x:real,k:real->bool | (x,k) IN p /\ (m x:num = t)} 8350 (\(x,k). content k * f t x - integral k (f t)):real)`` THEN 8351 CONJ_TAC THENL 8352 [MATCH_MP_TAC REAL_EQ_IMP_LE THEN AP_TERM_TAC THEN BETA_TAC THEN 8353 MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [FORALL_PROD, IN_ELIM_PAIR_THM], 8354 ALL_TAC] THEN 8355 MATCH_MP_TAC(SIMP_RULE std_ss [RIGHT_IMP_FORALL_THM, AND_IMP_INTRO] 8356 HENSTOCK_LEMMA_PART1) THEN 8357 MAP_EVERY EXISTS_TAC 8358 [``a:real``, ``b:real``, ``(b(t:num)):real->real->bool``] THEN 8359 ASM_SIMP_TAC std_ss [] THEN 8360 ASM_SIMP_TAC arith_ss [REAL_LT_DIV, REAL_POW_LT, REAL_LT] THEN 8361 CONJ_TAC THENL 8362 [MATCH_MP_TAC TAGGED_PARTIAL_DIVISION_SUBSET THEN 8363 EXISTS_TAC ``p:(real#(real->bool))->bool`` THEN 8364 SIMP_TAC std_ss [SUBSET_DEF, FORALL_PROD, IN_ELIM_PAIR_THM] THEN 8365 ASM_MESON_TAC[tagged_division_of], 8366 ALL_TAC] THEN 8367 UNDISCH_TAC 8368 ``(d :real -> real -> bool) FINE (p :real # (real -> bool) -> bool)`` THEN 8369 DISCH_TAC THEN 8370 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 8371 EXPAND_TAC "d" THEN SIMP_TAC std_ss [FINE, IN_ELIM_PAIR_THM] THEN MESON_TAC[], 8372 MP_TAC(ISPECL [``(f:num->real->real) s``, ``a:real``, ``b:real``, 8373 ``p:(real#(real->bool))->bool``] 8374 INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN) THEN 8375 MP_TAC(ISPECL [``(f:num->real->real) r``, ``a:real``, ``b:real``, 8376 ``p:(real#(real->bool))->bool``] 8377 INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN) THEN 8378 ASM_SIMP_TAC std_ss [] THEN 8379 SIMP_TAC std_ss [o_DEF, LAMBDA_PROD] THEN MATCH_MP_TAC(REAL_ARITH 8380 ``sr <= sx /\ sx <= ss /\ ks <= i /\ &0 <= i - kr /\ i - kr < e 8381 ==> (kr = sr) ==> (ks = ss) ==> abs(sx - i) < e:real``) THEN 8382 ASM_SIMP_TAC std_ss [LESS_EQ_REFL] THEN CONJ_TAC THEN MATCH_MP_TAC SUM_LE THEN 8383 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 8384 MAP_EVERY X_GEN_TAC [``x:real``, ``i:real->bool``] THEN DISCH_TAC THEN 8385 (SUBGOAL_THEN ``i SUBSET interval[a:real,b]`` ASSUME_TAC THENL 8386 [METIS_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 8387 SUBGOAL_THEN ``?u v:real. i = interval[u,v]`` 8388 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 8389 THENL [METIS_TAC[TAGGED_DIVISION_OF], ALL_TAC]) THEN 8390 MATCH_MP_TAC INTEGRAL_DROP_LE THEN 8391 REPEAT(CONJ_TAC THENL 8392 [ASM_MESON_TAC[INTEGRABLE_SUBINTERVAL], ALL_TAC]) THEN 8393 X_GEN_TAC ``y:real`` THEN DISCH_TAC THEN 8394 MP_TAC(ISPEC 8395 ``\m n:num. (f m (y:real)) <= (f n y):real`` 8396 TRANSITIVE_STEPWISE_LE) THEN 8397 SIMP_TAC std_ss [REAL_LE_TRANS, REAL_LE_REFL] THEN 8398 (KNOW_TAC ``(!(x :num) (y' :num) (z :num). 8399 (f :num -> real -> real) x (y :real) <= f y' y /\ 8400 f y' y <= f z y ==> f x y <= f z y)`` THENL 8401 [SRW_TAC [][] THEN METIS_TAC [REAL_LE_TRANS, REAL_LE_REFL], 8402 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC]) THEN 8403 (KNOW_TAC 8404 ``!(n :num). (f :num -> real -> real) n (y :real) <= f (SUC n) y`` THENL 8405 [METIS_TAC[SUBSET_DEF], DISCH_TAC THEN ASM_REWRITE_TAC []]) THEN 8406 DISCH_THEN MATCH_MP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 8407 ASM_MESON_TAC[TAGGED_DIVISION_OF, SUBSET_DEF]], 8408 ALL_TAC] THEN 8409 CONJ_TAC THENL [ASM_MESON_TAC[integrable_on], ALL_TAC] THEN 8410 FIRST_ASSUM(SUBST1_TAC o MATCH_MP INTEGRAL_UNIQUE) THEN 8411 ASM_SIMP_TAC std_ss []); 8412 8413Theorem MONOTONE_CONVERGENCE_INCREASING : 8414 !f:num->real->real g s. 8415 (!k. (f k) integrable_on s) /\ 8416 (!k x. x IN s ==> (f k x) <= (f (SUC k) x)) /\ 8417 (!x. x IN s ==> ((\k. f k x) --> g x) sequentially) /\ 8418 bounded {integral s (f k) | k IN univ(:num)} 8419 ==> g integrable_on s /\ 8420 ((\k. integral s (f k)) --> integral s g) sequentially 8421Proof 8422 SUBGOAL_THEN 8423 ``!f:num->real->real g s. 8424 (!k x. x IN s ==> &0 <= (f k x)) /\ 8425 (!k. (f k) integrable_on s) /\ 8426 (!k x. x IN s ==> (f k x) <= (f (SUC k) x)) /\ 8427 (!x. x IN s ==> ((\k. f k x) --> (g x):real) sequentially) /\ 8428 bounded {integral s (f k) | k IN univ(:num)} 8429 ==> g integrable_on s /\ 8430 ((\k. integral s (f k)) --> integral s g) sequentially`` 8431 ASSUME_TAC THENL 8432 [ ALL_TAC, 8433 REPEAT GEN_TAC THEN STRIP_TAC THEN 8434 FIRST_X_ASSUM(MP_TAC o ISPECL 8435 [``\n x:real. f(SUC n) x - f (0:num) x:real``, 8436 ``\x. (g:real->real) x - f (0:num) x``, ``s:real->bool``]) THEN 8437 SIMP_TAC std_ss [] THEN 8438 KNOW_TAC ``(!(k :num) (x :real). 8439 x IN (s :real -> bool) ==> 8440 (0 :real) <= (f :num -> real -> real) (SUC k) x - f (0 :num) x) /\ 8441 (!(k :num). 8442 (\(x :real). f (SUC k) x - f (0 :num) x) integrable_on s) /\ 8443 (!(k :num) (x :real). 8444 x IN s ==> 8445 f (SUC k) x - f (0 :num) x <= f (SUC (SUC k)) x - f (0 :num) x) /\ 8446 (!(x :real). 8447 x IN s ==> 8448 (((\(k :num). f (SUC k) x - f (0 :num) x) --> 8449 ((g :real -> real) x - f (0 :num) x)) sequentially :bool)) /\ 8450 (bounded 8451 {integral s (\(x :real). f (SUC k) x - f (0 :num) x) | 8452 k IN univ((:num) :num itself)} :bool)`` THEN REPEAT CONJ_TAC THENL 8453 [(* goal 1 (of 6) *) 8454 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_SUB_LE] THEN 8455 MP_TAC(ISPEC 8456 ``\m n:num. (f m (x:real)) <= (f n x):real`` 8457 TRANSITIVE_STEPWISE_LE) THEN 8458 SIMP_TAC std_ss [REAL_LE_TRANS, REAL_LE_REFL] THEN 8459 METIS_TAC[REAL_LE_TRANS, LE_0], 8460 (* goal 2 (of 6) *) 8461 GEN_TAC THEN MATCH_MP_TAC INTEGRABLE_SUB THEN ASM_SIMP_TAC std_ss [ETA_AX], 8462 (* goal 3 (of 6) *) 8463 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_SUB_LE] THEN 8464 ASM_SIMP_TAC std_ss [REAL_ARITH ``x - a <= y - a <=> x <= y:real``], 8465 (* goal 4 (of 6) *) 8466 REPEAT STRIP_TAC THEN 8467 ONCE_REWRITE_TAC [METIS [] ``!k. (f (SUC k) x - (f:num->real->real) 0 x) = 8468 ((\k. f (SUC k) x) k - (\k. f 0 x) k)``] THEN 8469 MATCH_MP_TAC LIM_SUB THEN SIMP_TAC std_ss [LIM_CONST] THEN 8470 REWRITE_TAC[ADD1] THEN 8471 ONCE_REWRITE_TAC [METIS [] 8472 ``(\k. f (k + 1) x) = (\k. (\a. f (a) x) (k + 1:num))``] THEN 8473 MATCH_MP_TAC(ISPECL[``f:num->real``, ``l:real``, ``1:num``] SEQ_OFFSET) THEN 8474 ASM_SIMP_TAC std_ss [], 8475 (* goal 5 (of 6) *) 8476 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [bounded_def]) THEN 8477 SIMP_TAC std_ss [bounded_def] THEN 8478 ONCE_REWRITE_TAC [METIS [] 8479 ``(\x:real. f (SUC k) x - (f 0 x):real) = 8480 (\x. (\x. f (SUC k) x) x - (\x. f 0 x) x)``] THEN 8481 UNDISCH_TAC ``!k. (f:num->real->real) k integrable_on s`` THEN DISCH_TAC THEN 8482 FIRST_ASSUM (MP_TAC o ONCE_REWRITE_RULE [METIS [] 8483 ``!k. (f:num->real->real) k = (\x. f k x)``]) THEN DISCH_TAC THEN 8484 ASM_SIMP_TAC std_ss [INTEGRAL_SUB, ETA_AX, METIS [] 8485 ``!k. (\x. f k x) = f k``] THEN 8486 ONCE_REWRITE_TAC [METIS [] 8487 ``(integral s (f (SUC k)) - integral s ((f:num->real->real) 0)) = 8488 (\k. integral s (f (SUC k)) - integral s (f 0)) k``] THEN 8489 ONCE_REWRITE_TAC [METIS [] 8490 ``integral s (f k) = (\k. integral s (f k)) k``] THEN 8491 ONCE_REWRITE_TAC [GSYM IMAGE_DEF] THEN BETA_TAC THEN 8492 SIMP_TAC std_ss [FORALL_IN_IMAGE, IN_UNIV] THEN 8493 DISCH_THEN(X_CHOOSE_THEN ``B:real`` 8494 (fn th => EXISTS_TAC ``(B:real) + abs(integral s (f (0:num):real->real))`` THEN 8495 X_GEN_TAC ``k:num`` THEN MP_TAC(SPEC ``SUC k`` th))) THEN 8496 REAL_ARITH_TAC, 8497 (* goal 6 (of 6) *) 8498 ASM_SIMP_TAC std_ss [] THEN DISCH_TAC THEN POP_ASSUM K_TAC THEN 8499 ONCE_REWRITE_TAC [METIS [] 8500 ``(\x:real. f (SUC k) x - (f 0 x):real) = 8501 (\x. (\x. f (SUC k) x) x - (\x. f 0 x) x)``] THEN 8502 UNDISCH_TAC ``!k. (f:num->real->real) k integrable_on s`` THEN DISCH_TAC THEN 8503 FIRST_ASSUM (MP_TAC o ONCE_REWRITE_RULE [METIS [] 8504 ``!k. (f:num->real->real) k = (\x. f k x)``]) THEN DISCH_TAC THEN 8505 ASM_SIMP_TAC std_ss [INTEGRAL_SUB, ETA_AX, METIS [] 8506 ``!k. (\x. f k x) = f k``] THEN ASM_SIMP_TAC std_ss [IMP_CONJ] THEN 8507 SUBGOAL_THEN ``(f (0:num):real->real) integrable_on s`` MP_TAC THENL 8508 [ASM_SIMP_TAC std_ss [], ONCE_REWRITE_TAC[AND_IMP_INTRO]] THEN 8509 DISCH_THEN(MP_TAC o MATCH_MP INTEGRABLE_ADD) THEN 8510 SIMP_TAC std_ss [ETA_AX, REAL_ARITH ``f + (g - f):real = g``] THEN 8511 DISCH_TAC THEN 8512 ONCE_REWRITE_TAC [METIS [] 8513 ``(\x:real. g x - (f 0 x):real) = 8514 (\x. g x - (\x. (f:num->real->real) 0 x) x)``] THEN 8515 ASM_SIMP_TAC std_ss [INTEGRAL_SUB, ETA_AX] THEN 8516 MP_TAC(ISPECL [``sequentially``, ``integral s (f (0:num):real->real)``] 8517 LIM_CONST) THEN 8518 REWRITE_TAC[AND_IMP_INTRO] THEN DISCH_THEN(MP_TAC o MATCH_MP LIM_ADD) THEN 8519 SIMP_TAC std_ss [ETA_AX, REAL_ARITH ``f + (g - f):real = g``, METIS [] 8520 ``(\x. f 0 x) = (f:num->real->real) 0``] THEN 8521 REWRITE_TAC[ADD1] THEN 8522 ONCE_REWRITE_TAC [METIS [] ``(\x. integral s ((f:num->real->real) (x + 1))) = 8523 (\x. (\a. integral s (f (a))) (x + 1))``] THEN 8524 SIMP_TAC std_ss [ISPECL[``f:num->real``, ``l:real``, ``1:num``] SEQ_OFFSET_REV] 8525 ] ] 8526 THEN REPEAT GEN_TAC THEN STRIP_TAC THEN 8527 SUBGOAL_THEN 8528 ``!x:real k:num. x IN s ==> (f k x) <= (g x):real`` 8529 ASSUME_TAC THENL 8530 [REPEAT STRIP_TAC THEN 8531 MATCH_MP_TAC(ISPEC ``sequentially`` LIM_DROP_LBOUND) THEN 8532 EXISTS_TAC ``\k. (f:num->real->real) k x`` THEN 8533 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_SEQUENTIALLY, EVENTUALLY_SEQUENTIALLY] THEN 8534 EXISTS_TAC ``k:num`` THEN SPEC_TAC(``k:num``,``k:num``) THEN 8535 ONCE_REWRITE_TAC [METIS [] ``f k x <= (f:num->real->real) x' x <=> 8536 (\k x'. f k x <= f x' x) k x'``] THEN 8537 MATCH_MP_TAC TRANSITIVE_STEPWISE_LE THEN 8538 SIMP_TAC std_ss [REAL_LE_TRANS, REAL_LE_REFL] THEN 8539 CONJ_TAC THENL [METIS_TAC [REAL_LE_TRANS], ALL_TAC] THEN 8540 ASM_SIMP_TAC std_ss [REAL_LE_REFL], 8541 ALL_TAC] THEN 8542 SUBGOAL_THEN 8543 ``?i. ((\k:num. integral s (f k:real->real)) --> i) 8544 sequentially`` 8545 CHOOSE_TAC THENL 8546 [MATCH_MP_TAC BOUNDED_INCREASING_CONVERGENT THEN ASM_SIMP_TAC std_ss [] THEN 8547 GEN_TAC THEN MATCH_MP_TAC INTEGRAL_DROP_LE THEN ASM_SIMP_TAC std_ss [], 8548 ALL_TAC] THEN 8549 SUBGOAL_THEN 8550 ``!k. (integral s ((f:num->real->real) k)) <= i`` 8551 ASSUME_TAC THENL 8552 [GEN_TAC THEN MATCH_MP_TAC(ISPEC ``sequentially`` LIM_DROP_LBOUND) THEN 8553 EXISTS_TAC ``\k. integral(s) ((f:num->real->real) k)`` THEN 8554 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_SEQUENTIALLY, EVENTUALLY_SEQUENTIALLY] THEN 8555 EXISTS_TAC ``k:num`` THEN SPEC_TAC(``k:num``,``k:num``) THEN 8556 ONCE_REWRITE_TAC [METIS [] 8557 ``(integral s (f k) <= integral s ((f:num->real->real) x)) <=> 8558 (\k x. integral s (f k) <= integral s (f x)) k x``] THEN 8559 MATCH_MP_TAC TRANSITIVE_STEPWISE_LE THEN 8560 ASM_SIMP_TAC std_ss [REAL_LE_REFL, REAL_LE_TRANS] THEN CONJ_TAC THENL 8561 [METIS_TAC [REAL_LE_TRANS], ALL_TAC] THEN 8562 GEN_TAC THEN MATCH_MP_TAC INTEGRAL_DROP_LE THEN ASM_SIMP_TAC std_ss [], 8563 ALL_TAC] THEN 8564 SUBGOAL_THEN ``((g:real->real) has_integral i) s`` ASSUME_TAC THENL 8565 [ALL_TAC, 8566 CONJ_TAC THENL [ASM_MESON_TAC[integrable_on], ALL_TAC] THEN 8567 FIRST_ASSUM(SUBST1_TAC o MATCH_MP INTEGRAL_UNIQUE) THEN 8568 ASM_REWRITE_TAC[]] THEN 8569 REWRITE_TAC[HAS_INTEGRAL_ALT] THEN 8570 MP_TAC(ISPECL 8571 [``\k x. if x IN s then (f:num->real->real) k x else 0``, 8572 ``\x. if x IN s then (g:real->real) x else 0``] MONOTONE_CONVERGENCE_INTERVAL) THEN 8573 DISCH_TAC THEN 8574 KNOW_TAC ``(!(a :real) (b :real). 8575 (!(k :num). 8576 (\(k :num) (x :real). 8577 if x IN (s :real -> bool) then (f :num -> real -> real) k x 8578 else (0 :real)) k integrable_on interval [(a,b)]) /\ 8579 (!(k :num) (x :real). 8580 x IN interval [(a,b)] ==> 8581 (\(k :num) (x :real). if x IN s then f k x else (0 :real)) k x <= 8582 (\(k :num) (x :real). if x IN s then f k x else (0 :real)) (SUC k) 8583 x) /\ 8584 (!(x :real). 8585 x IN interval [(a,b)] ==> 8586 (((\(k :num). 8587 (\(k :num) (x :real). if x IN s then f k x else (0 :real)) k 8588 x) --> 8589 (\(x :real). if x IN s then (g :real -> real) x else (0 :real)) 8590 x) sequentially :bool)) /\ 8591 (bounded 8592 {integral (interval [(a,b)]) 8593 ((\(k :num) (x :real). if x IN s then f k x else (0 :real)) 8594 k) | 8595 k IN univ((:num) :num itself)} :bool)) ==> 8596 (!(a :real) (b :real). 8597 (\(x :real). if x IN s then g x else (0 :real)) integrable_on 8598 interval [(a,b)] /\ 8599 (((\(k :num). 8600 integral (interval [(a,b)]) 8601 ((\(k :num) (x :real). if x IN s then f k x else (0 :real)) 8602 k)) --> 8603 integral (interval [(a,b)]) 8604 (\(x :real). if x IN s then g x else (0 :real))) sequentially : 8605 bool))`` THENL [METIS_TAC [], POP_ASSUM K_TAC] THEN 8606 KNOW_TAC ``(!(a :real) (b :real). 8607 (!(k :num). 8608 (\(k :num) (x :real). 8609 if x IN (s :real -> bool) then (f :num -> real -> real) k x 8610 else (0 :real)) k integrable_on interval [(a,b)]) /\ 8611 (!(k :num) (x :real). 8612 x IN interval [(a,b)] ==> 8613 (\(k :num) (x :real). if x IN s then f k x else (0 :real)) k x <= 8614 (\(k :num) (x :real). if x IN s then f k x else (0 :real)) (SUC k) 8615 x) /\ 8616 (!(x :real). 8617 x IN interval [(a,b)] ==> 8618 (((\(k :num). 8619 (\(k :num) (x :real). if x IN s then f k x else (0 :real)) k 8620 x) --> 8621 (\(x :real). if x IN s then (g :real -> real) x else (0 :real)) 8622 x) sequentially :bool)) /\ 8623 (bounded 8624 {integral (interval [(a,b)]) 8625 ((\(k :num) (x :real). if x IN s then f k x else (0 :real)) 8626 k) | 8627 k IN univ((:num) :num itself)} :bool))`` THENL 8628 [REPEAT GEN_TAC THEN SIMP_TAC std_ss [] THEN 8629 MATCH_MP_TAC(TAUT `a /\ (a ==> b) ==> a /\ b`) THEN CONJ_TAC THENL 8630 [UNDISCH_TAC ``!k. (f:num->real->real) k integrable_on s`` THEN DISCH_TAC THEN 8631 FIRST_ASSUM(MP_TAC o ONCE_REWRITE_RULE [INTEGRABLE_ALT]) THEN 8632 SIMP_TAC std_ss [], 8633 DISCH_TAC] THEN 8634 CONJ_TAC THENL 8635 [REPEAT STRIP_TAC THEN COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [REAL_LE_REFL], 8636 ALL_TAC] THEN 8637 CONJ_TAC THENL 8638 [REPEAT STRIP_TAC THEN COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [LIM_CONST], 8639 ALL_TAC] THEN 8640 UNDISCH_TAC 8641 ``bounded {integral s ((f:num->real->real) k) | k IN univ(:num)}`` THEN 8642 DISCH_TAC THEN 8643 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [bounded_def]) THEN 8644 ONCE_REWRITE_TAC [METIS [] ``integral s (f k) = (\k. integral s (f k)) k``] THEN 8645 ONCE_REWRITE_TAC [METIS [] 8646 ``integral (interval [(a,b)]) (\x. if x IN s then f k x else 0) = 8647 (\k. integral (interval [(a,b)]) (\x. if x IN s then f k x else 0))k``] THEN 8648 ONCE_REWRITE_TAC[GSYM IMAGE_DEF] THEN BETA_TAC THEN 8649 SIMP_TAC std_ss [bounded_def, FORALL_IN_IMAGE, IN_UNIV] THEN 8650 DISCH_THEN (X_CHOOSE_TAC ``x:real``) THEN EXISTS_TAC ``x:real`` THEN 8651 X_GEN_TAC ``k:num`` THEN POP_ASSUM (MP_TAC o Q.SPEC `k:num`) THEN 8652 MATCH_MP_TAC(REAL_ARITH 8653 ``&0 <= y /\ y <= x ==> abs(x) <= a ==> abs(y) <= a:real``) THEN 8654 CONJ_TAC THENL 8655 [MATCH_MP_TAC INTEGRAL_DROP_POS THEN ASM_SIMP_TAC std_ss [] THEN 8656 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 8657 ASM_SIMP_TAC std_ss [REAL_LE_REFL], 8658 ALL_TAC] THEN 8659 GEN_REWR_TAC (RAND_CONV) [GSYM INTEGRAL_RESTRICT_UNIV] THEN 8660 MATCH_MP_TAC INTEGRAL_SUBSET_DROP_LE THEN 8661 ASM_SIMP_TAC std_ss [SUBSET_UNIV, IN_UNIV] THEN 8662 ASM_SIMP_TAC std_ss [INTEGRABLE_RESTRICT_UNIV, ETA_AX, METIS [] 8663 ``(\x. f k x) = (f:num->real->real) k``] THEN 8664 GEN_TAC THEN COND_CASES_TAC THEN 8665 ASM_SIMP_TAC std_ss [REAL_LE_REFL, REAL_LE_REFL], 8666 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 8667 SIMP_TAC std_ss [FORALL_AND_THM] THEN STRIP_TAC THEN ASM_SIMP_TAC std_ss [] THEN 8668 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 8669 UNDISCH_TAC ``((\k. integral s ((f:num->real->real) k)) --> i) sequentially`` THEN 8670 DISCH_TAC THEN 8671 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [LIM_SEQUENTIALLY]) THEN 8672 DISCH_THEN(MP_TAC o SPEC ``e / &4:real``) THEN 8673 ASM_SIMP_TAC arith_ss [dist, REAL_LT_DIV, REAL_LT] THEN 8674 DISCH_THEN(X_CHOOSE_THEN ``N:num`` STRIP_ASSUME_TAC) THEN 8675 UNDISCH_TAC ``!k. (f:num->real->real) k integrable_on s`` THEN DISCH_TAC THEN 8676 FIRST_ASSUM(MP_TAC o REWRITE_RULE [HAS_INTEGRAL_INTEGRAL]) THEN 8677 GEN_REWR_TAC (LAND_CONV o BINDER_CONV) [HAS_INTEGRAL_ALT] THEN 8678 SIMP_TAC std_ss [FORALL_AND_THM] THEN 8679 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 8680 DISCH_THEN(MP_TAC o SPECL [``N:num``, ``e / &4:real``]) THEN 8681 ASM_SIMP_TAC arith_ss [dist, REAL_LT_DIV, REAL_LT] THEN 8682 STRIP_TAC THEN EXISTS_TAC ``B:real`` THEN ASM_SIMP_TAC std_ss [] THEN 8683 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN DISCH_TAC THEN 8684 FIRST_X_ASSUM(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 8685 ASM_REWRITE_TAC[] THEN 8686 FIRST_ASSUM(MP_TAC o C MATCH_MP (ARITH_PROVE ``N:num <= N``)) THEN 8687 REWRITE_TAC[AND_IMP_INTRO] THEN 8688 DISCH_THEN(MP_TAC o MATCH_MP (REAL_ARITH 8689 ``abs(x - y) < e / &4 /\ abs(z - x) < e / &4 8690 ==> abs(z - y) < e / &4 + e / &4:real``)) THEN 8691 UNDISCH_TAC `` !a b. 8692 ((\k. 8693 integral (interval [(a,b)]) 8694 (\x. if x IN s then (f:num->real->real) k x else 0)) --> 8695 integral (interval [(a,b)]) (\x. if x IN s then g x else 0)) 8696 sequentially`` THEN DISCH_TAC THEN 8697 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [LIM_SEQUENTIALLY]) THEN 8698 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``, ``e / &4 + e / &4:real``]) THEN 8699 KNOW_TAC ``e / &4 + e / &4:real = e / &2:real`` THENL 8700 [REWRITE_TAC [REAL_DOUBLE, real_div, REAL_MUL_ASSOC] THEN 8701 REWRITE_TAC [GSYM real_div] THEN 8702 SIMP_TAC std_ss [REAL_EQ_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 8703 ONCE_REWRITE_TAC [real_div] THEN 8704 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c * d =((a * d) * c) * b:real``] THEN 8705 REWRITE_TAC [REAL_ARITH ``2 * 2 = 4:real``] THEN 8706 SIMP_TAC std_ss [REAL_MUL_RINV, REAL_ARITH ``4 <> 0:real``] THEN REAL_ARITH_TAC, 8707 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 8708 ASM_SIMP_TAC std_ss [dist, REAL_HALF] THEN 8709 DISCH_THEN(X_CHOOSE_THEN ``M:num`` (MP_TAC o SPEC ``M + N:num``)) THEN 8710 REWRITE_TAC[LE_ADD] THEN 8711 GEN_REWR_TAC (RAND_CONV o RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 8712 MATCH_MP_TAC(REAL_ARITH 8713 ``f1 <= f2 /\ f2 <= i 8714 ==> abs(f2 - g) < e / &2 ==> abs(f1 - i) < e / &2 ==> 8715 abs(g - i) < e / &2 + e / &2:real``) THEN 8716 CONJ_TAC THENL 8717 [MATCH_MP_TAC INTEGRAL_DROP_LE THEN ASM_SIMP_TAC std_ss [] THEN 8718 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 8719 COND_CASES_TAC THEN ASM_REWRITE_TAC[REAL_LE_REFL] THEN 8720 MP_TAC(ISPEC 8721 ``\m n:num. (f m (x:real)) <= (f n x):real`` 8722 TRANSITIVE_STEPWISE_LE) THEN 8723 SIMP_TAC std_ss [REAL_LE_REFL, REAL_LE_TRANS] THEN 8724 KNOW_TAC ``(!(x' :num) (y :num) (z :num). 8725 (f :num -> real -> real) x' (x :real) <= f y x /\ f y x <= f z x ==> 8726 f x' x <= f z x) /\ (!(n :num). f n x <= f (SUC n) x)`` THENL 8727 [METIS_TAC [REAL_LE_TRANS], DISCH_TAC THEN 8728 ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 8729 DISCH_THEN MATCH_MP_TAC THEN ARITH_TAC, 8730 ALL_TAC] THEN 8731 MATCH_MP_TAC REAL_LE_TRANS THEN 8732 EXISTS_TAC ``(integral s ((f:num->real->real) (M + N)))`` THEN 8733 ASM_SIMP_TAC std_ss [] THEN 8734 GEN_REWR_TAC (RAND_CONV) [GSYM INTEGRAL_RESTRICT_UNIV] THEN 8735 MATCH_MP_TAC INTEGRAL_SUBSET_DROP_LE THEN 8736 ASM_SIMP_TAC std_ss [SUBSET_UNIV, IN_UNIV] THEN 8737 ASM_SIMP_TAC std_ss [INTEGRABLE_RESTRICT_UNIV, ETA_AX, METIS [] 8738 ``(\x. f (M + N) x) = (f:num->real->real) (M + N)``] THEN 8739 GEN_TAC THEN COND_CASES_TAC THEN 8740 ASM_SIMP_TAC std_ss [REAL_LE_REFL] 8741QED 8742 8743val MONOTONE_CONVERGENCE_DECREASING = store_thm ("MONOTONE_CONVERGENCE_DECREASING", 8744 ``!f:num->real->real g s. 8745 (!k. (f k) integrable_on s) /\ 8746 (!k x. x IN s ==> (f (SUC k) x) <= (f k x)) /\ 8747 (!x. x IN s ==> ((\k. f k x) --> g x) sequentially) /\ 8748 bounded {integral s (f k) | k IN univ(:num)} 8749 ==> g integrable_on s /\ 8750 ((\k. integral s (f k)) --> integral s g) sequentially``, 8751 REPEAT GEN_TAC THEN DISCH_TAC THEN 8752 MP_TAC(ISPECL 8753 [``(\k x. -(f k x)):num->real->real``, 8754 ``(\x. -(g x)):real->real``, ``s:real->bool``] 8755 MONOTONE_CONVERGENCE_INCREASING) THEN 8756 FIRST_ASSUM MP_TAC THEN 8757 MATCH_MP_TAC(TAUT `(a ==> b) /\ (c ==> d) ==> a ==> (b ==> c) ==> d`) THEN 8758 SIMP_TAC std_ss [] THEN CONJ_TAC THENL 8759 [REPEAT(MATCH_MP_TAC MONO_AND THEN CONJ_TAC) THENL 8760 [DISCH_TAC THEN GEN_TAC THEN POP_ASSUM (MP_TAC o Q.SPEC `k:num`) THEN 8761 DISCH_THEN(MP_TAC o MATCH_MP INTEGRABLE_NEG) THEN SIMP_TAC std_ss [], 8762 SIMP_TAC std_ss [REAL_LE_NEG2], 8763 REPEAT STRIP_TAC THEN 8764 ONCE_REWRITE_TAC [METIS [] 8765 ``(\k. -f k x) = (\k. -((\k. (f:num->real->real) k x) k))``] THEN 8766 MATCH_MP_TAC LIM_NEG THEN ASM_SIMP_TAC std_ss [], 8767 ALL_TAC] THEN 8768 DISCH_TAC THEN MATCH_MP_TAC BOUNDED_SUBSET THEN 8769 EXISTS_TAC ``IMAGE (\x. -x) 8770 {integral s (f k:real->real) | k IN univ(:num)}`` THEN 8771 CONJ_TAC THENL 8772 [MATCH_MP_TAC BOUNDED_LINEAR_IMAGE THEN 8773 ASM_SIMP_TAC std_ss [LINEAR_COMPOSE_NEG, LINEAR_ID], 8774 ONCE_REWRITE_TAC [METIS [] ``integral s (f k) = (\k. integral s (f k)) k``] THEN 8775 ONCE_REWRITE_TAC [METIS [] ``integral s (\x. -f k x) = 8776 (\k. integral s (\x. -f k x)) k``] THEN 8777 ONCE_REWRITE_TAC[GSYM IMAGE_DEF] THEN REWRITE_TAC[GSYM IMAGE_COMPOSE] THEN 8778 REWRITE_TAC[SUBSET_DEF, IN_IMAGE] THEN 8779 GEN_TAC THEN STRIP_TAC THEN EXISTS_TAC ``x':num`` THEN 8780 REPEAT STRIP_TAC THEN ASM_SIMP_TAC std_ss [o_THM] THEN 8781 ONCE_ASM_REWRITE_TAC [] THEN BETA_TAC THEN 8782 MATCH_MP_TAC INTEGRAL_NEG THEN ASM_REWRITE_TAC[]], 8783 ALL_TAC] THEN 8784 DISCH_THEN(CONJUNCTS_THEN2 8785 (MP_TAC o MATCH_MP INTEGRABLE_NEG) (MP_TAC o MATCH_MP LIM_NEG)) THEN 8786 SIMP_TAC std_ss [REAL_NEG_NEG, ETA_AX] THEN 8787 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 8788 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN 8789 BINOP_TAC THEN REWRITE_TAC[FUN_EQ_THM] THEN TRY GEN_TAC THEN BETA_TAC THEN 8790 MATCH_MP_TAC(REAL_ARITH ``(x:real = -y) ==> (-x = y)``) THEN 8791 MATCH_MP_TAC INTEGRAL_NEG THEN ASM_REWRITE_TAC[]); 8792 8793val MONOTONE_CONVERGENCE_INCREASING_AE = store_thm ("MONOTONE_CONVERGENCE_INCREASING_AE", 8794 ``!f:num->real->real g s t. 8795 (!k. (f k) integrable_on s) /\ 8796 negligible t /\ 8797 (!k x. x IN s DIFF t ==> (f k x) <= (f (SUC k) x)) /\ 8798 (!x. x IN s DIFF t ==> ((\k. f k x) --> g x) sequentially) /\ 8799 bounded {integral s (f k) | k IN univ(:num)} 8800 ==> g integrable_on s /\ 8801 ((\k. integral s (f k)) --> integral s g) sequentially``, 8802 REPEAT GEN_TAC THEN STRIP_TAC THEN 8803 MP_TAC(ISPECL 8804 [``\n x. if x IN t then 0 8805 else (f:num->real->real) n x``, 8806 ``\x. if x IN t then 0 8807 else (g:real->real) x``, ``s:real->bool``] 8808 MONOTONE_CONVERGENCE_INCREASING) THEN 8809 ASM_SIMP_TAC std_ss [] THEN 8810 KNOW_TAC ``(!(k :num). 8811 (\(x :real). 8812 if x IN (t :real -> bool) then (0 :real) 8813 else (f :num -> real -> real) k x) integrable_on 8814 (s :real -> bool)) /\ 8815 (!(k :num) (x :real). 8816 x IN s ==> 8817 (if x IN t then (0 :real) else f k x) <= 8818 if x IN t then (0 :real) else f (SUC k) x) /\ 8819 (!(x :real). 8820 x IN s ==> 8821 (((\(k :num). if x IN t then (0 :real) else f k x) --> 8822 if x IN t then (0 :real) else (g :real -> real) x) sequentially : 8823 bool)) /\ 8824 (bounded 8825 {integral s (\(x :real). if x IN t then (0 :real) else f k x) | 8826 k IN univ((:num) :num itself)} :bool)`` THENL 8827 [REPEAT CONJ_TAC THENL 8828 [X_GEN_TAC ``k:num`` THEN 8829 MATCH_MP_TAC(REWRITE_RULE[AND_IMP_INTRO] INTEGRABLE_SPIKE) THEN 8830 EXISTS_TAC ``(f:num->real->real) k`` THEN 8831 EXISTS_TAC ``t:real->bool`` THEN 8832 ASM_SIMP_TAC std_ss [IN_DIFF], 8833 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 8834 ASM_REWRITE_TAC[REAL_LE_REFL] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 8835 ASM_SET_TAC[], 8836 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 8837 ASM_CASES_TAC ``(x:real) IN t`` THEN ASM_REWRITE_TAC[LIM_CONST] THEN 8838 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[IN_DIFF], 8839 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 8840 BOUNDED_SUBSET)) THEN 8841 ONCE_REWRITE_TAC [METIS [] 8842 ``integral s (f k) = (\k. integral s (f k)) k``] THEN 8843 ONCE_REWRITE_TAC [METIS [] ``integral (s :real -> bool) 8844 (\(x :real). if x IN (t :real -> bool) then (0 :real) 8845 else (f :num -> real -> real) k x) = 8846 (\k. integral (s :real -> bool) 8847 (\(x :real). if x IN (t :real -> bool) then (0 :real) 8848 else (f :num -> real -> real) k x)) k``] THEN 8849 MATCH_MP_TAC(SET_RULE 8850 ``(!x. x IN s ==> (f x = g x)) 8851 ==> {f x | x IN s} SUBSET {g x | x IN s}``) THEN 8852 BETA_TAC THEN REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_SPIKE THEN 8853 EXISTS_TAC ``t:real->bool`` THEN 8854 ASM_SIMP_TAC std_ss [IN_DIFF]], 8855 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 8856 MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 8857 [MATCH_MP_TAC INTEGRABLE_SPIKE THEN EXISTS_TAC ``t:real->bool`` THEN 8858 ASM_SIMP_TAC std_ss [IN_DIFF], 8859 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN BINOP_TAC THEN 8860 REWRITE_TAC[FUN_EQ_THM] THEN REPEAT GEN_TAC THEN BETA_TAC THEN 8861 MATCH_MP_TAC INTEGRAL_SPIKE THEN EXISTS_TAC ``t:real->bool`` THEN 8862 ASM_SIMP_TAC std_ss [IN_DIFF]]]); 8863 8864val MONOTONE_CONVERGENCE_DECREASING_AE = store_thm ("MONOTONE_CONVERGENCE_DECREASING_AE", 8865 ``!f:num->real->real g s t. 8866 (!k. (f k) integrable_on s) /\ 8867 negligible t /\ 8868 (!k x. x IN s DIFF t ==> (f (SUC k) x) <= (f k x)) /\ 8869 (!x. x IN s DIFF t ==> ((\k. f k x) --> g x) sequentially) /\ 8870 bounded {integral s (f k) | k IN univ(:num)} 8871 ==> g integrable_on s /\ 8872 ((\k. integral s (f k)) --> integral s g) sequentially``, 8873 REPEAT GEN_TAC THEN STRIP_TAC THEN 8874 MP_TAC(ISPECL 8875 [``\n x. if x IN t then 0 8876 else (f:num->real->real) n x``, 8877 ``\x. if x IN t then 0 8878 else (g:real->real) x``, ``s:real->bool``] 8879 MONOTONE_CONVERGENCE_DECREASING) THEN 8880 ASM_SIMP_TAC std_ss [] THEN 8881 KNOW_TAC ``(!(k :num). 8882 (\(x :real). 8883 if x IN (t :real -> bool) then (0 :real) 8884 else (f :num -> real -> real) k x) integrable_on 8885 (s :real -> bool)) /\ 8886 (!(k :num) (x :real). 8887 x IN s ==> 8888 (if x IN t then (0 :real) else f (SUC k) x) <= 8889 if x IN t then (0 :real) else f k x) /\ 8890 (!(x :real). 8891 x IN s ==> 8892 (((\(k :num). if x IN t then (0 :real) else f k x) --> 8893 if x IN t then (0 :real) else (g :real -> real) x) sequentially : 8894 bool)) /\ 8895 (bounded 8896 {integral s (\(x :real). if x IN t then (0 :real) else f k x) | 8897 k IN univ((:num) :num itself)} :bool)`` THENL 8898 [REPEAT CONJ_TAC THENL 8899 [X_GEN_TAC ``k:num`` THEN 8900 MATCH_MP_TAC(REWRITE_RULE[AND_IMP_INTRO] INTEGRABLE_SPIKE) THEN 8901 EXISTS_TAC ``(f:num->real->real) k`` THEN 8902 EXISTS_TAC ``t:real->bool`` THEN 8903 ASM_SIMP_TAC std_ss [IN_DIFF], 8904 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 8905 ASM_REWRITE_TAC[REAL_LE_REFL] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 8906 ASM_SET_TAC[], 8907 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 8908 ASM_CASES_TAC ``(x:real) IN t`` THEN ASM_REWRITE_TAC[LIM_CONST] THEN 8909 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[IN_DIFF], 8910 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 8911 BOUNDED_SUBSET)) THEN 8912 ONCE_REWRITE_TAC [METIS [] 8913 ``integral s (f k) = (\k. integral s (f k)) k``] THEN 8914 ONCE_REWRITE_TAC [METIS [] ``integral (s :real -> bool) 8915 (\(x :real). if x IN (t :real -> bool) then (0 :real) 8916 else (f :num -> real -> real) k x) = 8917 (\k. integral (s :real -> bool) 8918 (\(x :real). if x IN (t :real -> bool) then (0 :real) 8919 else (f :num -> real -> real) k x)) k``] THEN 8920 MATCH_MP_TAC(SET_RULE 8921 ``(!x. x IN s ==> (f x = g x)) 8922 ==> {f x | x IN s} SUBSET {g x | x IN s}``) THEN BETA_TAC THEN 8923 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_SPIKE THEN 8924 EXISTS_TAC ``t:real->bool`` THEN 8925 ASM_SIMP_TAC std_ss [IN_DIFF]], 8926 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 8927 MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 8928 [MATCH_MP_TAC INTEGRABLE_SPIKE THEN EXISTS_TAC ``t:real->bool`` THEN 8929 ASM_SIMP_TAC std_ss [IN_DIFF], 8930 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN BINOP_TAC THEN 8931 REWRITE_TAC[FUN_EQ_THM] THEN REPEAT GEN_TAC THEN BETA_TAC THEN 8932 MATCH_MP_TAC INTEGRAL_SPIKE THEN EXISTS_TAC ``t:real->bool`` THEN 8933 ASM_SIMP_TAC std_ss [IN_DIFF]]]); 8934 8935(* ------------------------------------------------------------------------- *) 8936(* More lemmas about existence and bounds between integrals. *) 8937(* ------------------------------------------------------------------------- *) 8938 8939val lemma = prove ( 8940 ``(!e:real. &0 < e ==> x < y + e) ==> x <= y``, 8941 DISCH_THEN(MP_TAC o SPEC ``x - y:real``) THEN REAL_ARITH_TAC); 8942 8943val INTEGRAL_ABS_BOUND_INTEGRAL = store_thm ("INTEGRAL_ABS_BOUND_INTEGRAL", 8944 ``!f:real->real g s. 8945 f integrable_on s /\ g integrable_on s /\ 8946 (!x. x IN s ==> abs(f x) <= (g x)) 8947 ==> abs(integral s f) <= (integral s g)``, 8948 SUBGOAL_THEN 8949 ``!f:real->real g a b. 8950 f integrable_on interval[a,b] /\ g integrable_on interval[a,b] /\ 8951 (!x. x IN interval[a,b] ==> abs(f x) <= (g x)) 8952 ==> abs(integral(interval[a,b]) f) <= (integral(interval[a,b]) g)`` 8953 ASSUME_TAC THENL 8954 [REPEAT STRIP_TAC THEN MATCH_MP_TAC lemma THEN 8955 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 8956 UNDISCH_TAC ``(f:real->real) integrable_on interval[a,b]`` THEN 8957 DISCH_THEN(MP_TAC o MATCH_MP INTEGRABLE_INTEGRAL) THEN 8958 FIRST_X_ASSUM(MP_TAC o MATCH_MP INTEGRABLE_INTEGRAL) THEN 8959 REWRITE_TAC[has_integral] THEN DISCH_THEN(MP_TAC o SPEC ``e / &2:real``) THEN 8960 ASM_SIMP_TAC std_ss [REAL_HALF, LEFT_IMP_EXISTS_THM] THEN 8961 X_GEN_TAC ``d1:real->real->bool`` THEN STRIP_TAC THEN 8962 DISCH_THEN(MP_TAC o SPEC ``e / &2:real``) THEN 8963 ASM_SIMP_TAC std_ss [REAL_HALF, LEFT_IMP_EXISTS_THM] THEN 8964 X_GEN_TAC ``d2:real->real->bool`` THEN 8965 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 8966 MP_TAC(ISPECL [``d1:real->real->bool``, ``d2:real->real->bool``] 8967 GAUGE_INTER) THEN 8968 ASM_REWRITE_TAC[] THEN 8969 DISCH_THEN(MP_TAC o MATCH_MP FINE_DIVISION_EXISTS) THEN 8970 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 8971 SIMP_TAC std_ss [FINE_INTER, LEFT_IMP_EXISTS_THM] THEN 8972 X_GEN_TAC ``p:(real#(real->bool))->bool`` THEN STRIP_TAC THEN 8973 DISCH_THEN(MP_TAC o SPEC ``p:(real#(real->bool))->bool``) THEN 8974 FIRST_X_ASSUM(MP_TAC o SPEC ``p:(real#(real->bool))->bool``) THEN 8975 ASM_REWRITE_TAC[] THEN 8976 SIMP_TAC std_ss [REAL_LT_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 8977 MATCH_MP_TAC(REAL_ARITH 8978 ``abs(sg) <= dsa 8979 ==> abs(dsa - dia) * &2 < e ==> abs(sg - ig) * &2 < e 8980 ==> abs(ig) < dia + e:real``) THEN 8981 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 8982 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC SUM_ABS_LE THEN 8983 ASM_SIMP_TAC std_ss [o_DEF, FORALL_PROD] THEN 8984 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 8985 REWRITE_TAC[ABS_MUL] THEN 8986 MATCH_MP_TAC REAL_LE_MUL2 THEN REWRITE_TAC[ABS_POS] THEN 8987 REWRITE_TAC[REAL_ARITH ``abs x <= x <=> &0 <= x:real``] THEN 8988 ASM_MESON_TAC[CONTENT_POS_LE, TAGGED_DIVISION_OF, SUBSET_DEF], 8989 ALL_TAC] THEN 8990 REPEAT GEN_TAC THEN REWRITE_TAC[CONJ_ASSOC] THEN 8991 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 8992 DISCH_THEN(CONJUNCTS_THEN (fn th => 8993 ASSUME_TAC(CONJUNCT1(ONCE_REWRITE_RULE [INTEGRABLE_ALT] th)) THEN 8994 MP_TAC(MATCH_MP INTEGRABLE_INTEGRAL th))) THEN 8995 ONCE_REWRITE_TAC[HAS_INTEGRAL] THEN 8996 DISCH_TAC THEN DISCH_TAC THEN MATCH_MP_TAC lemma THEN 8997 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 8998 UNDISCH_TAC ``!e:real. 0 < e ==> 8999 ?B. 0 < B /\ !a b. ball (0,B) SUBSET interval [(a,b)] ==> 9000 ?z. ((\x. if x IN s then g x else 0) has_integral z) 9001 (interval [(a,b)]) /\ abs (z - integral s g) < e`` THEN DISCH_TAC THEN 9002 FIRST_X_ASSUM (MP_TAC o SPEC ``e / &2:real``) THEN 9003 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 9004 DISCH_THEN(X_CHOOSE_THEN ``B1:real`` 9005 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 9006 DISCH_THEN(X_CHOOSE_THEN ``B2:real`` 9007 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 9008 MP_TAC(ISPEC ``ball(0,max B1 B2:real):real->bool`` 9009 BOUNDED_SUBSET_CLOSED_INTERVAL) THEN 9010 SIMP_TAC std_ss [BOUNDED_BALL, LEFT_IMP_EXISTS_THM] THEN 9011 REWRITE_TAC[BALL_MAX_UNION, UNION_SUBSET] THEN 9012 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 9013 DISCH_THEN(CONJUNCTS_THEN(ANTE_RES_THEN MP_TAC)) THEN 9014 DISCH_THEN(X_CHOOSE_THEN ``z:real`` (CONJUNCTS_THEN2 ASSUME_TAC 9015 (fn th => DISCH_THEN(X_CHOOSE_THEN ``w:real`` 9016 (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN MP_TAC th))) THEN 9017 ASM_REWRITE_TAC[] THEN 9018 SIMP_TAC std_ss [REAL_LT_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 9019 MATCH_MP_TAC(REAL_ARITH 9020 ``abs(sg) <= dsa 9021 ==> abs(dsa - dia) * &2 < e ==> abs(sg - ig) * &2 < e 9022 ==> abs(ig) < dia + e:real``) THEN 9023 REPEAT(FIRST_X_ASSUM(SUBST1_TAC o SYM o MATCH_MP INTEGRAL_UNIQUE)) THEN 9024 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[] THEN 9025 REPEAT STRIP_TAC THEN SIMP_TAC std_ss [] THEN 9026 COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [ABS_0, REAL_LE_REFL]); 9027 9028val INTEGRAL_ABS_BOUND_INTEGRAL_COMPONENT = store_thm ("INTEGRAL_ABS_BOUND_INTEGRAL_COMPONENT", 9029 ``!f:real->real g:real->real s. 9030 f integrable_on s /\ g integrable_on s /\ 9031 (!x. x IN s ==> abs(f x) <= (g x)) 9032 ==> abs(integral s f) <= (integral s g)``, 9033 REPEAT STRIP_TAC THEN 9034 MATCH_MP_TAC REAL_LE_TRANS THEN 9035 EXISTS_TAC ``(integral s ((\y. (y)) o (g:real->real)))`` THEN 9036 SUBGOAL_THEN ``linear(\y:real. (y))`` ASSUME_TAC THENL 9037 [ASM_SIMP_TAC std_ss [linear], ALL_TAC] THEN 9038 CONJ_TAC THENL 9039 [MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 9040 ASM_SIMP_TAC std_ss [o_THM] THEN MATCH_MP_TAC INTEGRABLE_LINEAR THEN 9041 ASM_SIMP_TAC std_ss [], ALL_TAC] THEN 9042 SUBGOAL_THEN 9043 ``integral s ((\y. (y)) o (g:real->real)) = 9044 (\y. (y)) (integral s g)`` 9045 SUBST1_TAC THENL 9046 [MATCH_MP_TAC INTEGRAL_LINEAR THEN ASM_REWRITE_TAC[], 9047 SIMP_TAC std_ss [REAL_LE_REFL]]); 9048 9049val HAS_INTEGRAL_ABS_BOUND_INTEGRAL_COMPONENT = store_thm ("HAS_INTEGRAL_ABS_BOUND_INTEGRAL_COMPONENT", 9050 ``!f:real->real g:real->real s i j. 9051 (f has_integral i) s /\ (g has_integral j) s /\ 9052 (!x. x IN s ==> abs(f x) <= (g x)) 9053 ==> abs(i) <= j``, 9054 REPEAT STRIP_TAC THEN 9055 REPEAT(FIRST_X_ASSUM(fn th => 9056 SUBST1_TAC(SYM(MATCH_MP INTEGRAL_UNIQUE th)) THEN 9057 ASSUME_TAC(MATCH_MP HAS_INTEGRAL_INTEGRABLE th))) THEN 9058 MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL_COMPONENT THEN 9059 ASM_SIMP_TAC std_ss []); 9060 9061val lemma = prove ( 9062 ``!f:real->real g. 9063 (!a b. f integrable_on interval[a,b]) /\ 9064 (!x. abs(f x) <= (g x)) /\ 9065 g integrable_on univ(:real) 9066 ==> f integrable_on univ(:real)``, 9067 REPEAT GEN_TAC THEN 9068 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 9069 ONCE_REWRITE_TAC[INTEGRABLE_ALT_SUBSET] THEN 9070 ASM_SIMP_TAC std_ss [IN_UNIV, ETA_AX] THEN 9071 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 9072 DISCH_TAC THEN GEN_TAC THEN POP_ASSUM (MP_TAC o SPEC ``e:real``) THEN 9073 ASM_CASES_TAC ``&0 < e:real`` THEN ASM_REWRITE_TAC[] THEN 9074 DISCH_THEN (X_CHOOSE_TAC ``B:real``) THEN EXISTS_TAC ``B:real`` THEN 9075 POP_ASSUM MP_TAC THEN MATCH_MP_TAC MONO_AND THEN REWRITE_TAC[] THEN 9076 DISCH_TAC THEN REPEAT GEN_TAC THEN 9077 POP_ASSUM (MP_TAC o SPECL [``a:real``,``b:real``,``c:real``,``d:real``]) THEN 9078 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_REWRITE_TAC[] THEN 9079 MATCH_MP_TAC(REAL_ARITH ``a <= b ==> b < c ==> a < c:real``) THEN 9080 ONCE_REWRITE_TAC[ABS_SUB] THEN 9081 ASM_SIMP_TAC std_ss [GSYM INTEGRAL_DIFF, NEGLIGIBLE_EMPTY, 9082 METIS [SUBSET_DEF, IN_DIFF, NOT_IN_EMPTY, EXTENSION] 9083 ``s SUBSET t ==> (s DIFF t = {})``] THEN 9084 SIMP_TAC std_ss [] THEN 9085 MATCH_MP_TAC(REAL_ARITH ``x <= y ==> x <= abs y:real``) THEN 9086 MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 9087 METIS_TAC[integrable_on, HAS_INTEGRAL_DIFF, NEGLIGIBLE_EMPTY, 9088 SET_RULE ``s SUBSET t ==> (s DIFF t = {})``]); 9089 9090val INTEGRABLE_ON_ALL_INTERVALS_INTEGRABLE_BOUND = store_thm ("INTEGRABLE_ON_ALL_INTERVALS_INTEGRABLE_BOUND", 9091 ``!f:real->real g s. 9092 (!a b. (\x. if x IN s then f x else 0) 9093 integrable_on interval[a,b]) /\ 9094 (!x. x IN s ==> abs(f x) <= (g x)) /\ 9095 g integrable_on s 9096 ==> f integrable_on s``, 9097 REPEAT GEN_TAC THEN 9098 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 9099 ONCE_REWRITE_TAC[GSYM INTEGRABLE_RESTRICT_UNIV] THEN 9100 DISCH_TAC THEN MATCH_MP_TAC lemma THEN 9101 EXISTS_TAC ``(\x. if x IN s then g x else 0):real->real`` THEN 9102 ASM_SIMP_TAC std_ss [] THEN 9103 GEN_TAC THEN COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [ABS_0, REAL_POS]); 9104 9105(* ------------------------------------------------------------------------- *) 9106(* Explicit limit statement for integrals over [0,inf]. *) 9107(* ------------------------------------------------------------------------- *) 9108 9109Theorem HAS_INTEGRAL_LIM_AT_POSINFINITY : 9110 !f l:real. 9111 (f has_integral l) {t | &0 <= t} <=> 9112 (!a. f integrable_on interval[0,a]) /\ 9113 ((\a. integral (interval[0,a]) f) --> l) at_posinfinity 9114Proof 9115 REPEAT GEN_TAC THEN 9116 GEN_REWR_TAC LAND_CONV [HAS_INTEGRAL_ALT] THEN 9117 SIMP_TAC std_ss [INTEGRAL_RESTRICT_INTER, INTEGRABLE_RESTRICT_INTER] THEN 9118 SUBGOAL_THEN 9119 ``!a b. {t | &0 <= t} INTER interval[a,b] = 9120 interval[(max (&0) (a:real)),b]`` 9121 (fn th => REWRITE_TAC[th]) 9122 THENL 9123 [SIMP_TAC std_ss [EXTENSION, IN_INTER, IN_INTERVAL, GSPECIFICATION, max_def] THEN 9124 rpt GEN_TAC >> EQ_TAC >> Cases_on `0 <= a` >> rw [] \\ 9125 REAL_ASM_ARITH_TAC, 9126 ALL_TAC] THEN 9127 REWRITE_TAC[LIM_AT_POSINFINITY, dist, real_ge] THEN 9128 EQ_TAC THEN STRIP_TAC THEN CONJ_TAC THENL (* 4 subgoals *) 9129 [ (* goal 1 (of 4) *) 9130 X_GEN_TAC ``a:real`` THEN 9131 FIRST_X_ASSUM(MP_TAC o SPECL [``0:real``, ``a:real``]) THEN 9132 REWRITE_TAC[REAL_MAX_REFL], 9133 (* goal 2 (of 4) *) 9134 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 9135 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_SIMP_TAC std_ss [] THEN 9136 DISCH_THEN (X_CHOOSE_TAC ``B:real``) THEN EXISTS_TAC ``B:real`` THEN 9137 POP_ASSUM MP_TAC THEN 9138 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC) THEN 9139 X_GEN_TAC ``b:real`` THEN DISCH_TAC THEN 9140 UNDISCH_TAC `` !a b:real. 9141 ball (0,B) SUBSET interval [(a,b)] ==> 9142 abs (integral (interval [(max 0 a,b)]) f - l) < e`` THEN DISCH_TAC THEN 9143 FIRST_X_ASSUM (MP_TAC o SPECL [``(-b:real)``, ``b:real``]) THEN 9144 REWRITE_TAC[] THEN 9145 SUBGOAL_THEN ``max (&0) (-b) = &0:real`` SUBST1_TAC THENL 9146 [ Suff `-b <= 0` >- rw [REAL_MAX_ALT] >> rw [] \\ 9147 MATCH_MP_TAC REAL_LT_IMP_LE \\ 9148 MATCH_MP_TAC REAL_LTE_TRANS \\ 9149 Q.EXISTS_TAC `B` >> art [], SIMP_TAC std_ss []] THEN 9150 DISCH_THEN MATCH_MP_TAC THEN 9151 REWRITE_TAC[BALL, SUBSET_INTERVAL] THEN POP_ASSUM MP_TAC THEN 9152 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 9153 (* goal 3 (of 4) *) 9154 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 9155 UNDISCH_TAC ``!a. f integrable_on interval [(0,a)]`` THEN DISCH_TAC THEN 9156 FIRST_X_ASSUM(MP_TAC o SPEC ``b:real``) THEN 9157 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] INTEGRABLE_SUBINTERVAL) THEN 9158 SIMP_TAC std_ss [SUBSET_INTERVAL, REAL_LE_REFL] THEN 9159 rw [REAL_MAX_LE, REAL_LE_MAX], 9160 (* goal 4 (of 4) *) 9161 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 9162 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 9163 DISCH_THEN(X_CHOOSE_THEN ``B:real`` ASSUME_TAC) THEN 9164 EXISTS_TAC ``abs B + &1:real`` THEN 9165 STRONG_CONJ_TAC (* 0 < abs B + 1 *) 9166 >- (`0 <= abs B` by PROVE_TAC [ABS_POS] >> POP_ASSUM MP_TAC \\ 9167 REAL_ARITH_TAC) \\ 9168 DISCH_TAC \\ 9169 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 9170 SIMP_TAC std_ss [BALL, SUBSET_INTERVAL] THEN STRIP_TAC THEN 9171 (* stage work *) 9172 POP_ASSUM MP_TAC \\ 9173 Know `0 - (abs B + 1) < 0 + (abs B + 1)` 9174 >- (rw [] >> Q.PAT_X_ASSUM `0 < abs B + 1` MP_TAC \\ 9175 REAL_ARITH_TAC) >> rw [] \\ 9176 Know `max (&0) (a) = &0:real` 9177 >- (Suff `a <= 0` >- rw [REAL_MAX_ALT] \\ 9178 MATCH_MP_TAC REAL_LE_TRANS \\ 9179 Q.EXISTS_TAC `-(abs B + 1)` >> art [] \\ 9180 MATCH_MP_TAC REAL_LT_IMP_LE \\ 9181 Q.PAT_X_ASSUM `0 < abs B + 1` MP_TAC \\ 9182 REAL_ARITH_TAC) >> Rewr' \\ 9183 fs [] >> FIRST_X_ASSUM MATCH_MP_TAC \\ 9184 POP_ASSUM MP_TAC \\ 9185 REAL_ARITH_TAC ] 9186QED 9187 9188val FLOOR_POS = store_thm ("FLOOR_POS", 9189 ``!x. &0 <= x ==> (?n. flr x = &n)``, 9190 GEN_TAC THEN DISCH_TAC THEN REWRITE_TAC [NUM_FLOOR_def] THEN 9191 METIS_TAC []); 9192 9193Theorem HAS_INTEGRAL_LIM_SEQUENTIALLY : 9194 !f:real->real l. 9195 (f --> 0) at_posinfinity /\ 9196 (!n. f integrable_on interval[0,&n]) /\ 9197 ((\n:num. (integral (interval[0,&n]) f)) --> l) sequentially 9198 ==> (f has_integral l) {t | &0 <= t} 9199Proof 9200 REPEAT STRIP_TAC THEN 9201 ONCE_REWRITE_TAC[HAS_INTEGRAL_LIM_AT_POSINFINITY] THEN 9202 MATCH_MP_TAC(TAUT `p /\ (p ==> q) ==> p /\ q`) THEN CONJ_TAC THENL 9203 [X_GEN_TAC ``a:real`` THEN MP_TAC(SPEC ``a:real`` SIMP_REAL_ARCH) THEN 9204 DISCH_THEN(X_CHOOSE_TAC ``n:num``) THEN 9205 FIRST_X_ASSUM(MP_TAC o SPEC ``n:num``) THEN 9206 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] INTEGRABLE_SUBINTERVAL) THEN 9207 REWRITE_TAC[SUBSET_INTERVAL, REAL_LE_REFL] THEN rw [], 9208 DISCH_TAC] THEN 9209 REWRITE_TAC[LIM_AT_POSINFINITY, real_ge] THEN 9210 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 9211 UNDISCH_TAC ``(f --> 0) at_posinfinity`` THEN DISCH_TAC THEN 9212 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [LIM_AT_POSINFINITY]) THEN 9213 DISCH_THEN(MP_TAC o SPEC ``e / &2:real``) THEN 9214 ASM_REWRITE_TAC[REAL_HALF, o_THM, real_ge] THEN 9215 SIMP_TAC std_ss [DIST_0, LEFT_IMP_EXISTS_THM] THEN 9216 X_GEN_TAC ``B:real`` THEN DISCH_TAC THEN 9217 UNDISCH_TAC ``((\n. integral (interval [(0,&n)]) f) --> l) sequentially`` THEN 9218 DISCH_TAC THEN 9219 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [LIM_SEQUENTIALLY]) THEN 9220 DISCH_THEN(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 9221 DISCH_THEN(X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``max (&N) B + &1:real`` THEN 9222 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN MP_TAC(SPEC ``x:real`` FLOOR_POS) THEN 9223 KNOW_TAC ``0 <= x:real`` THENL 9224 [POP_ASSUM (MP_TAC o REWRITE_RULE [max_def]) THEN COND_CASES_TAC THEN STRIP_TAC THENL 9225 [MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``B + 1:real`` THEN 9226 ASM_REWRITE_TAC [] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 9227 EXISTS_TAC ``B:real`` THEN REWRITE_TAC [REAL_ARITH ``B <= B + 1:real``] THEN 9228 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9229 ASM_REWRITE_TAC [REAL_POS], MATCH_MP_TAC REAL_LE_TRANS THEN 9230 EXISTS_TAC ``&N + 1:real`` THEN ASM_REWRITE_TAC [] THEN 9231 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9232 ASM_REWRITE_TAC [REAL_POS] THEN REAL_ARITH_TAC], 9233 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 9234 DISCH_THEN(X_CHOOSE_TAC ``n:num``) THEN 9235 SUBGOAL_THEN 9236 ``integral(interval[0,x]) (f:real->real) = 9237 integral(interval[0,&n]) f + integral(interval[&n,x]) f`` 9238 SUBST1_TAC THENL 9239 [CONV_TAC SYM_CONV THEN MATCH_MP_TAC INTEGRAL_COMBINE THEN 9240 ASM_REWRITE_TAC[REAL_POS] THEN 9241 POP_ASSUM (MP_TAC o REWRITE_RULE [GSYM REAL_OF_NUM_EQ] o SYM) THEN 9242 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN MATCH_MP_TAC NUM_FLOOR_LE THEN 9243 UNDISCH_TAC ``max (&N) B + 1 <= x:real`` THEN REWRITE_TAC [max_def] THEN 9244 COND_CASES_TAC THEN STRIP_TAC THENL [MATCH_MP_TAC REAL_LE_TRANS THEN 9245 EXISTS_TAC ``B + 1:real`` THEN 9246 ASM_REWRITE_TAC [] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 9247 EXISTS_TAC ``B:real`` THEN REWRITE_TAC [REAL_ARITH ``B <= B + 1:real``] THEN 9248 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9249 ASM_REWRITE_TAC [REAL_POS], MATCH_MP_TAC REAL_LE_TRANS THEN 9250 EXISTS_TAC ``&N + 1:real`` THEN ASM_REWRITE_TAC [] THEN 9251 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9252 ASM_REWRITE_TAC [REAL_POS] THEN REAL_ARITH_TAC], 9253 ALL_TAC] THEN 9254 GEN_REWR_TAC RAND_CONV [GSYM REAL_HALF] THEN REWRITE_TAC [dist] THEN 9255 MATCH_MP_TAC(REAL_ARITH 9256 ``abs(a:real - l) < e / &2 /\ abs b <= e / &2 ==> 9257 abs(a + b - l) < e / 2 + e / 2:real``) THEN 9258 REWRITE_TAC [GSYM dist] THEN CONJ_TAC THENL 9259 [FULL_SIMP_TAC std_ss [] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 9260 REWRITE_TAC[GSYM REAL_OF_NUM_LE] THEN 9261 POP_ASSUM (MP_TAC o REWRITE_RULE [GSYM REAL_OF_NUM_EQ] o SYM) THEN 9262 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN KNOW_TAC ``0 <= x:real`` THENL 9263 [UNDISCH_TAC ``max (&N) B + 1 <= x:real`` THEN REWRITE_TAC [max_def] THEN 9264 COND_CASES_TAC THEN STRIP_TAC THENL 9265 [MATCH_MP_TAC REAL_LE_TRANS THEN 9266 EXISTS_TAC ``B + 1:real`` THEN 9267 ASM_REWRITE_TAC [] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 9268 EXISTS_TAC ``B:real`` THEN REWRITE_TAC [REAL_ARITH ``B <= B + 1:real``] THEN 9269 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9270 ASM_REWRITE_TAC [REAL_POS], MATCH_MP_TAC REAL_LE_TRANS THEN 9271 EXISTS_TAC ``&N + 1:real`` THEN ASM_REWRITE_TAC [] THEN 9272 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9273 ASM_REWRITE_TAC [REAL_POS] THEN REAL_ARITH_TAC], 9274 DISCH_TAC THEN ASM_SIMP_TAC std_ss [REAL_OF_NUM_LE, NUM_FLOOR_LE2]] THEN 9275 UNDISCH_TAC ``max (&N) B + 1 <= x:real`` THEN REWRITE_TAC [max_def] THEN 9276 Cases_on `&N <= B` >> rw [] 9277 >- (MATCH_MP_TAC REAL_LE_TRANS >> Q.EXISTS_TAC `B` >> art [] \\ 9278 POP_ASSUM MP_TAC >> REAL_ARITH_TAC) \\ 9279 `B < &N` by PROVE_TAC [real_lte] \\ 9280 MATCH_MP_TAC REAL_LE_TRANS >> Q.EXISTS_TAC `&(N + 1)` >> art [] \\ 9281 fs [], ALL_TAC] THEN 9282 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 9283 ``(integral(interval[&n:real,x]) (\x. (e / &2)))`` THEN 9284 CONJ_TAC THENL 9285 [MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 9286 ASM_REWRITE_TAC[INTEGRABLE_CONST, IN_INTERVAL] THEN 9287 CONJ_TAC THENL 9288 [MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 9289 EXISTS_TAC ``interval[0:real,x]`` THEN 9290 ASM_REWRITE_TAC[SUBSET_INTERVAL] THEN REWRITE_TAC [REAL_LE_REFL, REAL_POS], 9291 REPEAT STRIP_TAC THEN 9292 MATCH_MP_TAC REAL_LT_IMP_LE THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 9293 UNDISCH_TAC ``max (&N) B + 1 <= x:real`` THEN REWRITE_TAC [max_def] THEN 9294 COND_CASES_TAC THEN STRIP_TAC THENL 9295 [MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``x - 1:real`` THEN 9296 CONJ_TAC THENL [POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, ALL_TAC] THEN 9297 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&n:real`` THEN 9298 ASM_REWRITE_TAC [] THEN 9299 MATCH_MP_TAC (REAL_ARITH ``x < b + 1 ==> (x - 1 <= b:real)``) THEN 9300 REWRITE_TAC [GSYM NUM_FLOOR_LET] THEN ASM_SIMP_TAC std_ss [REAL_LE_LT], 9301 FULL_SIMP_TAC std_ss [REAL_NOT_LE] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 9302 EXISTS_TAC ``&n:real`` THEN ASM_REWRITE_TAC [] THEN 9303 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9304 ASM_REWRITE_TAC [REAL_LE_LT] THEN SIMP_TAC real_ss [GSYM REAL_LE_LT] THEN 9305 UNDISCH_TAC ``flr x = n:num`` THEN DISCH_THEN 9306 (fn th => REWRITE_TAC [ONCE_REWRITE_RULE [EQ_SYM_EQ] th]) THEN 9307 KNOW_TAC ``0 <= x:real`` THENL 9308 [MATCH_MP_TAC REAL_LE_TRANS THEN 9309 EXISTS_TAC ``&N + 1:real`` THEN ASM_REWRITE_TAC [] THEN 9310 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9311 ASM_REWRITE_TAC [REAL_POS] THEN REAL_ARITH_TAC, DISCH_TAC] THEN 9312 ASM_SIMP_TAC std_ss [NUM_FLOOR_LE2] THEN UNDISCH_TAC ``&N + 1 <= x:real`` THEN 9313 REAL_ARITH_TAC]], 9314 REWRITE_TAC[INTEGRAL_CONST] THEN KNOW_TAC ``0 <= x:real`` THENL 9315 [UNDISCH_TAC ``max (&N) B + 1 <= x:real`` THEN REWRITE_TAC [max_def] THEN 9316 COND_CASES_TAC THEN STRIP_TAC THENL 9317 [MATCH_MP_TAC REAL_LE_TRANS THEN 9318 EXISTS_TAC ``B + 1:real`` THEN 9319 ASM_REWRITE_TAC [] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 9320 EXISTS_TAC ``B:real`` THEN REWRITE_TAC [REAL_ARITH ``B <= B + 1:real``] THEN 9321 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9322 ASM_REWRITE_TAC [REAL_POS], MATCH_MP_TAC REAL_LE_TRANS THEN 9323 EXISTS_TAC ``&N + 1:real`` THEN ASM_REWRITE_TAC [] THEN 9324 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``&N:real`` THEN 9325 ASM_REWRITE_TAC [REAL_POS] THEN REAL_ARITH_TAC], DISCH_TAC] THEN 9326 FIRST_ASSUM (MP_TAC o MATCH_MP NUM_FLOOR_LE) THEN 9327 RULE_ASSUM_TAC (REWRITE_RULE [GSYM REAL_OF_NUM_EQ]) THEN ASM_REWRITE_TAC [] THEN 9328 DISCH_TAC THEN ASM_SIMP_TAC real_ss [CONTENT_CLOSED_INTERVAL] THEN 9329 GEN_REWR_TAC RAND_CONV [GSYM REAL_MUL_LID] THEN 9330 MATCH_MP_TAC REAL_LE_RMUL_IMP THEN ASM_REWRITE_TAC [REAL_HALF, REAL_LE_LT] THEN 9331 REWRITE_TAC [GSYM REAL_LE_LT] THEN 9332 MATCH_MP_TAC (REAL_ARITH ``x < &n + 1 ==> x - &n <= 1:real``) THEN 9333 REWRITE_TAC [GSYM NUM_FLOOR_LET] THEN REWRITE_TAC [GSYM REAL_OF_NUM_LE] THEN 9334 ASM_SIMP_TAC std_ss [REAL_LE_LT]] 9335QED 9336 9337(* ------------------------------------------------------------------------- *) 9338(* Interval functions of bounded variation on a set. *) 9339(* ------------------------------------------------------------------------- *) 9340 9341val _ = set_fixity "has_bounded_setvariation_on" (Infix(NONASSOC, 450)); 9342 9343val set_variation = new_definition ("set_variation", 9344 ``set_variation s (f:(real->bool)->real) = 9345 sup { sum d (\k. abs(f k)) | ?t. d division_of t /\ t SUBSET s}``); 9346 9347val has_bounded_setvariation_on = new_definition ("has_bounded_setvariation_on", 9348 ``(f:(real->bool)->real) has_bounded_setvariation_on s <=> 9349 ?B. !d t. d division_of t /\ t SUBSET s 9350 ==> sum d (\k. abs(f k)) <= B``); 9351 9352val HAS_BOUNDED_SETVARIATION_ON = store_thm ("HAS_BOUNDED_SETVARIATION_ON", 9353 ``!f:(real->bool)->real s. 9354 f has_bounded_setvariation_on s <=> 9355 ?B. &0 < B /\ !d t. d division_of t /\ t SUBSET s 9356 ==> sum d (\k. abs(f k)) <= B``, 9357 REWRITE_TAC[has_bounded_setvariation_on] THEN 9358 MESON_TAC[REAL_ARITH ``&0 < abs B + &1 /\ (x <= B ==> x <= abs B + &1:real)``]); 9359 9360val HAS_BOUNDED_SETVARIATION_ON_EQ = store_thm ("HAS_BOUNDED_SETVARIATION_ON_EQ", 9361 ``!f g:(real->bool)->real s. 9362 (!a b. ~(interval[a,b] = {}) /\ interval[a,b] SUBSET s 9363 ==> (f(interval[a,b]) = g(interval[a,b]))) /\ 9364 f has_bounded_setvariation_on s 9365 ==> g has_bounded_setvariation_on s``, 9366 REPEAT GEN_TAC THEN 9367 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 9368 REWRITE_TAC[has_bounded_setvariation_on] THEN 9369 DISCH_THEN (X_CHOOSE_TAC ``B:real``) THEN EXISTS_TAC ``B:real`` THEN 9370 POP_ASSUM MP_TAC THEN DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 9371 POP_ASSUM (MP_TAC o SPECL [``d:(real->bool)->bool``,``t:real->bool``]) THEN 9372 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_REWRITE_TAC[] THEN 9373 MATCH_MP_TAC(REAL_ARITH ``(x = y) ==> x <= B ==> y <= B:real``) THEN 9374 MATCH_MP_TAC SUM_EQ THEN UNDISCH_TAC ``d division_of t`` THEN 9375 DISCH_TAC THEN FIRST_ASSUM(fn th => 9376 ONCE_REWRITE_TAC [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 9377 REPEAT STRIP_TAC THEN SIMP_TAC std_ss [] THEN AP_TERM_TAC THEN 9378 METIS_TAC[division_of, SUBSET_TRANS]); 9379 9380val SET_VARIATION_EQ = store_thm ("SET_VARIATION_EQ", 9381 ``!f g:(real->bool)->real s. 9382 (!a b. ~(interval[a,b] = {}) /\ interval[a,b] SUBSET s 9383 ==> (f(interval[a,b]) = g(interval[a,b]))) 9384 ==> (set_variation s f = set_variation s g)``, 9385 REPEAT STRIP_TAC THEN REWRITE_TAC[set_variation] THEN AP_TERM_TAC THEN 9386 ONCE_REWRITE_TAC [METIS [] 9387 ``{sum d (\k. abs (f k)) | ?t. d division_of t /\ t SUBSET s} = 9388 {(\d. sum d (\k. abs (f k))) d | (\d. ?t. d division_of t /\ t SUBSET s) d}``] THEN 9389 MATCH_MP_TAC(SET_RULE 9390 ``(!x. P x ==> (f x = g x)) ==> ({f x | P x} = {g x | P x})``) THEN 9391 X_GEN_TAC ``d:(real->bool)->bool`` THEN SIMP_TAC std_ss [] THEN 9392 DISCH_THEN(X_CHOOSE_THEN ``t:real->bool`` STRIP_ASSUME_TAC) THEN 9393 MATCH_MP_TAC SUM_EQ THEN UNDISCH_TAC ``d division_of t`` THEN 9394 DISCH_TAC THEN FIRST_ASSUM(fn th => 9395 ONCE_REWRITE_TAC [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 9396 REPEAT STRIP_TAC THEN SIMP_TAC std_ss [] THEN AP_TERM_TAC THEN 9397 METIS_TAC[division_of, SUBSET_TRANS]); 9398 9399val HAS_BOUNDED_SETVARIATION_ON_COMPONENTWISE = store_thm ("HAS_BOUNDED_SETVARIATION_ON_COMPONENTWISE", 9400 ``!f:(real->bool)->real s. 9401 f has_bounded_setvariation_on s <=> 9402 (\k. f k) has_bounded_setvariation_on s``, 9403 METIS_TAC []); 9404 9405val HAS_BOUNDED_SETVARIATION_COMPARISON = store_thm ("HAS_BOUNDED_SETVARIATION_COMPARISON", 9406 ``!f:(real->bool)->real g:(real->bool)->real s. 9407 f has_bounded_setvariation_on s /\ 9408 (!a b. ~(interval[a,b] = {}) /\ interval[a,b] SUBSET s 9409 ==> abs(g(interval[a,b])) <= abs(f(interval[a,b]))) 9410 ==> g has_bounded_setvariation_on s``, 9411 REPEAT GEN_TAC THEN DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 9412 REWRITE_TAC[has_bounded_setvariation_on] THEN 9413 DISCH_THEN (X_CHOOSE_TAC ``B:real``) THEN EXISTS_TAC ``B:real`` THEN 9414 GEN_TAC THEN GEN_TAC THEN POP_ASSUM (MP_TAC o SPECL 9415 [``d:(real -> bool) -> bool``,``t:real -> bool``]) THEN 9416 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 9417 ASM_REWRITE_TAC[] THEN 9418 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LE_TRANS) THEN 9419 MATCH_MP_TAC SUM_LE THEN 9420 CONJ_TAC THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 9421 SIMP_TAC std_ss [] THEN METIS_TAC[division_of, SUBSET_TRANS]); 9422 9423val HAS_BOUNDED_SETVARIATION_ON_ABS = store_thm ("HAS_BOUNDED_SETVARIATION_ON_ABS", 9424 ``!f:(real->bool)->real s. 9425 (\x. (abs(f x))) has_bounded_setvariation_on s <=> 9426 (\x. (f x)) has_bounded_setvariation_on s``, 9427 REWRITE_TAC[has_bounded_setvariation_on] THEN 9428 SIMP_TAC std_ss [ABS_ABS]); 9429 9430val SETVARIATION_EQUAL_LEMMA = store_thm ("SETVARIATION_EQUAL_LEMMA", 9431 ``!mf:((real->bool)->real)->((real->bool)->real) ms ms'. 9432 (!s. (ms'(ms s) = s) /\ (ms(ms' s) = s)) /\ 9433 (!f a b. ~(interval[a,b] = {}) 9434 ==> (mf f (ms (interval[a,b])) = f (interval[a,b])) /\ 9435 ?a' b'. ~(interval[a',b'] = {}) /\ 9436 (ms' (interval[a,b]) = interval[a',b'])) /\ 9437 (!t u. t SUBSET u ==> ms t SUBSET ms u /\ ms' t SUBSET ms' u) /\ 9438 (!d t. d division_of t 9439 ==> (IMAGE ms d) division_of ms t /\ 9440 (IMAGE ms' d) division_of ms' t) 9441 ==> (!f s. (mf f) has_bounded_setvariation_on (ms s) <=> 9442 f has_bounded_setvariation_on s) /\ 9443 (!f s. set_variation (ms s) (mf f) = set_variation s f)``, 9444 REPEAT GEN_TAC THEN STRIP_TAC THEN 9445 REWRITE_TAC[has_bounded_setvariation_on, set_variation] THEN 9446 KNOW_TAC `` ((!(f :(real -> bool) -> real) (s :real -> bool). 9447 ({sum d (\(k :real -> bool). abs (mf f k)) | 9448 ?(t :real -> bool). d division_of t /\ t SUBSET ms s} = 9449 {sum d (\(k :real -> bool). abs (f k)) | 9450 ?(t :real -> bool). d division_of t /\ t SUBSET s})) ==> 9451 (!(f :(real -> bool) -> real) (s :real -> bool). 9452 (?(B :real). 9453 !(d :(real -> bool) -> bool) (t :real -> bool). 9454 d division_of t /\ 9455 t SUBSET (ms :(real -> bool) -> real -> bool) s ==> 9456 sum d (\(k :real -> bool). 9457 abs ((mf :((real->bool)->real)->(real->bool)->real) f k)) <= B) <=> 9458 ?(B :real). 9459 !(d :(real -> bool) -> bool) (t :real -> bool). 9460 d division_of t /\ t SUBSET s ==> 9461 sum d (\(k :real -> bool). abs (f k)) <= B)) /\ 9462 (!(f :(real -> bool) -> real) (s :real -> bool). 9463 ({sum d (\(k :real -> bool). abs (mf f k)) | 9464 ?(t :real -> bool). d division_of t /\ t SUBSET ms s} = 9465 {sum d (\(k :real -> bool). abs (f k)) | 9466 ?(t :real -> bool). d division_of t /\ t SUBSET s}))`` THENL 9467 [ALL_TAC, METIS_TAC []] THEN CONJ_TAC THENL 9468 [SIMP_TAC std_ss [EXTENSION, GSPECIFICATION] THEN 9469 METIS_TAC [], ALL_TAC] THEN 9470 SIMP_TAC std_ss [EXTENSION, GSPECIFICATION] THEN REPEAT GEN_TAC THEN EQ_TAC THEN 9471 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN ONCE_REWRITE_TAC [CONJ_SYM] THENL 9472 [EXISTS_TAC ``IMAGE (ms':(real->bool)->real->bool) d``, 9473 EXISTS_TAC ``IMAGE (ms:(real->bool)->real->bool) d``] THENL 9474 [CONJ_TAC THENL [METIS_TAC[], ALL_TAC] THEN 9475 W(MP_TAC o PART_MATCH (lhand o rand) SUM_IMAGE o rand o snd) THEN 9476 KNOW_TAC ``(!(x :real -> bool) (y :real -> bool). 9477 x IN (d :(real -> bool) -> bool) /\ y IN d /\ 9478 ((ms' :(real -> bool) -> real -> bool) x = ms' y) ==> 9479 (x = y))`` THENL 9480 [ASM_MESON_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 9481 POP_ASSUM K_TAC THEN DISCH_THEN SUBST1_TAC], 9482 CONJ_TAC THENL [METIS_TAC[], ALL_TAC] THEN 9483 W(MP_TAC o PART_MATCH (lhand o rand) SUM_IMAGE o rand o snd) THEN 9484 KNOW_TAC ``(!(x :real -> bool) (y :real -> bool). 9485 x IN (d :(real -> bool) -> bool) /\ y IN d /\ 9486 ((ms :(real -> bool) -> real -> bool) x = ms y) ==> 9487 (x = y))`` THENL 9488 [ASM_MESON_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 9489 POP_ASSUM K_TAC THEN DISCH_THEN SUBST1_TAC]] THEN 9490 MATCH_MP_TAC SUM_EQ THEN REWRITE_TAC[o_THM] THEN 9491 UNDISCH_TAC ``d division_of t`` THEN DISCH_TAC THEN FIRST_ASSUM 9492 (fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 9493 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN STRIP_TAC THEN 9494 AP_TERM_TAC THEN ASM_SIMP_TAC std_ss [] THEN 9495 SUBGOAL_THEN ``?a' b':real. ~(interval[a',b'] = {}) /\ 9496 (ms' (interval[a:real,b]) = interval[a',b'])`` 9497 STRIP_ASSUME_TAC THENL [ASM_MESON_TAC[], ALL_TAC] THEN 9498 ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[]); 9499 9500val HAS_BOUNDED_SETVARIATION_ON_ELEMENTARY = store_thm ("HAS_BOUNDED_SETVARIATION_ON_ELEMENTARY", 9501 ``!f:(real->bool)->real s. 9502 (?d. d division_of s) 9503 ==> (f has_bounded_setvariation_on s <=> 9504 ?B. !d. d division_of s ==> sum d (\k. abs(f k)) <= B)``, 9505 REPEAT GEN_TAC THEN DISCH_TAC THEN 9506 REWRITE_TAC[has_bounded_setvariation_on] THEN EQ_TAC THEN 9507 DISCH_THEN (X_CHOOSE_TAC ``B:real``) THEN EXISTS_TAC ``B:real`` THEN 9508 POP_ASSUM MP_TAC THENL [MESON_TAC[SUBSET_REFL], ALL_TAC] THEN 9509 DISCH_TAC THEN 9510 MAP_EVERY X_GEN_TAC [``d:(real->bool)->bool``, ``t:real->bool``] THEN 9511 STRIP_TAC THEN FIRST_X_ASSUM(X_CHOOSE_TAC ``d':(real->bool)->bool``) THEN 9512 MP_TAC(ISPECL [``d:(real->bool)->bool``, ``d':(real->bool)->bool``, 9513 ``t:real->bool``, ``s:real->bool``] PARTIAL_DIVISION_EXTEND) THEN 9514 ASM_REWRITE_TAC[] THEN 9515 DISCH_THEN(X_CHOOSE_TAC ``d'':(real->bool)->bool``) THEN 9516 MATCH_MP_TAC REAL_LE_TRANS THEN 9517 EXISTS_TAC ``sum d'' (\k:real->bool. abs(f k:real))`` THEN 9518 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC SUM_SUBSET_SIMPLE THEN 9519 ASM_SIMP_TAC std_ss [ABS_POS] THEN ASM_MESON_TAC[DIVISION_OF_FINITE]); 9520 9521val HAS_BOUNDED_SETVARIATION_ON_INTERVAL = store_thm ("HAS_BOUNDED_SETVARIATION_ON_INTERVAL", 9522 ``!f:(real->bool)->real a b. 9523 f has_bounded_setvariation_on interval[a,b] <=> 9524 ?B. !d. d division_of interval[a,b] ==> sum d (\k. abs(f k)) <= B``, 9525 REPEAT GEN_TAC THEN MATCH_MP_TAC HAS_BOUNDED_SETVARIATION_ON_ELEMENTARY THEN 9526 REWRITE_TAC[ELEMENTARY_INTERVAL]); 9527 9528val HAS_BOUNDED_SETVARIATION_ON_UNIV = store_thm ("HAS_BOUNDED_SETVARIATION_ON_UNIV", 9529 ``!f:(real->bool)->real. 9530 f has_bounded_setvariation_on univ(:real) <=> 9531 ?B. !d. d division_of BIGUNION d ==> sum d (\k. abs(f k)) <= B``, 9532 REPEAT GEN_TAC THEN 9533 REWRITE_TAC[has_bounded_setvariation_on, SUBSET_UNIV] THEN 9534 MESON_TAC[DIVISION_OF_UNION_SELF]); 9535 9536val HAS_BOUNDED_SETVARIATION_ON_SUBSET = store_thm ("HAS_BOUNDED_SETVARIATION_ON_SUBSET", 9537 ``!f:(real->bool)->real s t. 9538 f has_bounded_setvariation_on s /\ t SUBSET s 9539 ==> f has_bounded_setvariation_on t``, 9540 REPEAT GEN_TAC THEN 9541 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 9542 REWRITE_TAC[has_bounded_setvariation_on] THEN 9543 METIS_TAC[SUBSET_TRANS]); 9544 9545Theorem HAS_BOUNDED_SETVARIATION_ON_IMP_BOUNDED_ON_SUBINTERVALS : 9546 !f:(real->bool)->real s. 9547 f has_bounded_setvariation_on s 9548 ==> bounded { f(interval[c,d]) | interval[c,d] SUBSET s} 9549Proof 9550 rpt GEN_TAC >> REWRITE_TAC[has_bounded_setvariation_on, bounded_def] 9551 >> DISCH_THEN (X_CHOOSE_TAC ``B:real``) 9552 >> EXISTS_TAC ``max (abs B) (abs((f:(real->bool)->real) {}))`` 9553 >> SIMP_TAC std_ss [FORALL_IN_GSPEC] 9554 >> MAP_EVERY X_GEN_TAC [``c:real``, ``d:real``] THEN DISCH_TAC 9555 >> ASM_CASES_TAC ``interval[c:real,d] = {}`` (* 2 subgoals *) 9556 >> ASM_REWRITE_TAC [REAL_LE_MAX2] 9557 >> FIRST_X_ASSUM (MP_TAC o SPECL 9558 [``{interval[c:real,d]}``, ``interval[c:real,d]``]) 9559 >> ASM_SIMP_TAC std_ss [DIVISION_OF_SELF, SUM_SING, max_def] 9560 >> DISCH_TAC 9561 >> reverse (Cases_on `abs B <= abs (f {})`) >> fs [] 9562 >- (MATCH_MP_TAC REAL_LE_TRANS \\ 9563 Q.EXISTS_TAC `B` >> art [ABS_LE]) 9564 >> MATCH_MP_TAC REAL_LE_TRANS 9565 >> Q.EXISTS_TAC `B` >> art [] 9566 >> MATCH_MP_TAC REAL_LE_TRANS 9567 >> Q.EXISTS_TAC `abs B` >> art [ABS_LE] 9568QED 9569 9570val HAS_BOUNDED_SETVARIATION_ON_ABS = store_thm ("HAS_BOUNDED_SETVARIATION_ON_ABS", 9571 ``!f:(real->bool)->real s. 9572 (\x. (abs(f x))) has_bounded_setvariation_on s <=> 9573 f has_bounded_setvariation_on s``, 9574 REWRITE_TAC[has_bounded_setvariation_on] THEN 9575 SIMP_TAC std_ss [ABS_ABS]); 9576 9577val HAS_BOUNDED_SETVARIATION_ON_COMPOSE_LINEAR = store_thm ("HAS_BOUNDED_SETVARIATION_ON_COMPOSE_LINEAR", 9578 ``!f:(real->bool)->real g:real->real s. 9579 f has_bounded_setvariation_on s /\ linear g 9580 ==> (g o f) has_bounded_setvariation_on s``, 9581 REPEAT GEN_TAC THEN 9582 REWRITE_TAC[HAS_BOUNDED_SETVARIATION_ON] THEN 9583 DISCH_THEN(CONJUNCTS_THEN2 (X_CHOOSE_TAC ``B:real``) ASSUME_TAC) THEN 9584 FIRST_X_ASSUM(X_CHOOSE_TAC ``C:real`` o MATCH_MP LINEAR_BOUNDED_POS) THEN 9585 EXISTS_TAC ``B * C:real`` THEN ASM_SIMP_TAC std_ss [REAL_LT_MUL] THEN 9586 MAP_EVERY X_GEN_TAC [``d:(real->bool)->bool``, ``t:real->bool``] THEN 9587 STRIP_TAC THEN REWRITE_TAC[o_THM] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 9588 EXISTS_TAC ``sum d (\k. C * abs((f:(real->bool)->real) k))`` THEN 9589 CONJ_TAC THENL 9590 [MATCH_MP_TAC SUM_LE THEN ASM_MESON_TAC[DIVISION_OF_FINITE], 9591 GEN_REWR_TAC RAND_CONV [REAL_MUL_SYM] THEN 9592 SIMP_TAC std_ss [SUM_LMUL] THEN ASM_SIMP_TAC std_ss [REAL_LE_LMUL] THEN 9593 ASM_MESON_TAC[]]); 9594 9595val HAS_BOUNDED_SETVARIATION_ON_0 = store_thm ("HAS_BOUNDED_SETVARIATION_ON_0", 9596 ``!s:real->bool. (\x. 0) has_bounded_setvariation_on s``, 9597 REWRITE_TAC[has_bounded_setvariation_on, ABS_0, SUM_0] THEN 9598 MESON_TAC[REAL_LE_REFL]); 9599 9600val SET_VARIATION_0 = store_thm ("SET_VARIATION_0", 9601 ``!s:real->bool. set_variation s (\x. 0) = &0``, 9602 GEN_TAC THEN REWRITE_TAC[set_variation, ABS_0, SUM_0] THEN 9603 GEN_REWR_TAC RAND_CONV [GSYM SUP_SING] THEN 9604 AP_TERM_TAC THEN SIMP_TAC std_ss [EXTENSION, GSPECIFICATION, IN_SING] THEN 9605 MESON_TAC[ELEMENTARY_EMPTY, EMPTY_SUBSET]); 9606 9607val HAS_BOUNDED_SETVARIATION_ON_CMUL = store_thm ("HAS_BOUNDED_SETVARIATION_ON_CMUL", 9608 ``!f:(real->bool)->real c s. 9609 f has_bounded_setvariation_on s 9610 ==> (\x. c * f x) has_bounded_setvariation_on s``, 9611 REPEAT GEN_TAC THEN 9612 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT, o_DEF] 9613 HAS_BOUNDED_SETVARIATION_ON_COMPOSE_LINEAR) THEN 9614 REWRITE_TAC[linear] THEN REAL_ARITH_TAC); 9615 9616val HAS_BOUNDED_SETVARIATION_ON_NEG = store_thm ("HAS_BOUNDED_SETVARIATION_ON_NEG", 9617 ``!f:(real->bool)->real s. 9618 (\x. -(f x)) has_bounded_setvariation_on s <=> 9619 f has_bounded_setvariation_on s``, 9620 SIMP_TAC std_ss [has_bounded_setvariation_on, ABS_NEG]); 9621 9622val HAS_BOUNDED_SETVARIATION_ON_ADD = store_thm ("HAS_BOUNDED_SETVARIATION_ON_ADD", 9623 ``!f:(real->bool)->real g s. 9624 f has_bounded_setvariation_on s /\ 9625 g has_bounded_setvariation_on s 9626 ==> (\x. f x + g x) has_bounded_setvariation_on s``, 9627 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_setvariation_on] THEN 9628 DISCH_THEN(CONJUNCTS_THEN2 9629 (X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) 9630 (X_CHOOSE_THEN ``C:real`` STRIP_ASSUME_TAC)) THEN 9631 EXISTS_TAC ``B + C:real`` THEN 9632 MAP_EVERY X_GEN_TAC [``d:(real->bool)->bool``, ``t:real->bool``] THEN 9633 STRIP_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN 9634 EXISTS_TAC ``sum d (\k. abs((f:(real->bool)->real) k)) + 9635 sum d (\k. abs((g:(real->bool)->real) k))`` THEN 9636 CONJ_TAC THENL [ALL_TAC, ASM_MESON_TAC[REAL_LE_ADD2]] THEN 9637 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 9638 ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN 9639 MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [ABS_TRIANGLE]); 9640 9641val HAS_BOUNDED_SETVARIATION_ON_SUB = store_thm ("HAS_BOUNDED_SETVARIATION_ON_SUB", 9642 ``!f:(real->bool)->real g s. 9643 f has_bounded_setvariation_on s /\ 9644 g has_bounded_setvariation_on s 9645 ==> (\x. f x - g x) has_bounded_setvariation_on s``, 9646 REWRITE_TAC[REAL_ARITH ``x - y:real = x + -y``] THEN 9647 SIMP_TAC std_ss [HAS_BOUNDED_SETVARIATION_ON_ADD, HAS_BOUNDED_SETVARIATION_ON_NEG]); 9648 9649val HAS_BOUNDED_SETVARIATION_ON_NULL = store_thm ("HAS_BOUNDED_SETVARIATION_ON_NULL", 9650 ``!f:(real->bool)->real s. 9651 (!a b. (content(interval[a,b]) = &0) ==> (f(interval[a,b]) = 0)) /\ 9652 (content s = &0) /\ bounded s 9653 ==> f has_bounded_setvariation_on s``, 9654 REPEAT STRIP_TAC THEN REWRITE_TAC[has_bounded_setvariation_on] THEN 9655 EXISTS_TAC ``&0:real`` THEN REPEAT STRIP_TAC THEN 9656 MATCH_MP_TAC(REAL_ARITH ``(x = &0) ==> x <= &0:real``) THEN 9657 MATCH_MP_TAC SUM_EQ_0 THEN SIMP_TAC std_ss [ABS_ZERO] THEN 9658 UNDISCH_TAC ``d division_of t`` THEN DISCH_TAC THEN 9659 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 9660 REPEAT STRIP_TAC THEN FIRST_ASSUM MATCH_MP_TAC THEN 9661 MATCH_MP_TAC CONTENT_0_SUBSET_GEN THEN 9662 EXISTS_TAC ``s:real->bool`` THEN ASM_REWRITE_TAC[] THEN 9663 ASM_MESON_TAC[division_of, SUBSET_TRANS]); 9664 9665val SET_VARIATION_ELEMENTARY_LEMMA = store_thm ("SET_VARIATION_ELEMENTARY_LEMMA", 9666 ``!f:(real->bool)->real s b. 9667 (?d. d division_of s) 9668 ==> ((!d t. d division_of t /\ t SUBSET s 9669 ==> sum d (\k. abs(f k)) <= b) <=> 9670 (!d. d division_of s ==> sum d (\k. abs(f k)) <= b))``, 9671 REPEAT GEN_TAC THEN DISCH_THEN(X_CHOOSE_TAC ``d1:(real->bool)->bool``) THEN 9672 EQ_TAC THENL [MESON_TAC[SUBSET_REFL], ALL_TAC] THEN 9673 DISCH_TAC THEN X_GEN_TAC ``d2:(real->bool)->bool`` THEN 9674 X_GEN_TAC ``t:real->bool`` THEN STRIP_TAC THEN MP_TAC(ISPECL 9675 [``d2:(real->bool)->bool``, ``d1:(real->bool)->bool``, 9676 ``t:real->bool``, ``s:real->bool``] PARTIAL_DIVISION_EXTEND) THEN 9677 ASM_REWRITE_TAC[] THEN 9678 DISCH_THEN(X_CHOOSE_TAC ``d3:(real->bool)->bool``) THEN 9679 MATCH_MP_TAC REAL_LE_TRANS THEN 9680 EXISTS_TAC ``sum d3 (\k:real->bool. abs(f k:real))`` THEN 9681 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC SUM_SUBSET_SIMPLE THEN 9682 ASM_SIMP_TAC std_ss [ABS_POS] THEN ASM_MESON_TAC[DIVISION_OF_FINITE]); 9683 9684val SET_VARIATION_ON_ELEMENTARY = store_thm ("SET_VARIATION_ON_ELEMENTARY", 9685 ``!f:(real->bool)->real s. 9686 (?d. d division_of s) 9687 ==> (set_variation s f = 9688 sup { sum d (\k. abs(f k)) | d division_of s})``, 9689 REPEAT GEN_TAC THEN DISCH_TAC THEN REWRITE_TAC[set_variation, sup_alt] THEN 9690 SIMP_TAC std_ss [FORALL_IN_GSPEC, LEFT_IMP_EXISTS_THM] THEN 9691 ASM_SIMP_TAC std_ss [SET_VARIATION_ELEMENTARY_LEMMA]); 9692 9693val SET_VARIATION_ON_INTERVAL = store_thm ("SET_VARIATION_ON_INTERVAL", 9694 ``!f:(real->bool)->real a b. 9695 set_variation (interval[a,b]) f = 9696 sup { sum d (\k. abs(f k)) | d division_of interval[a,b]}``, 9697 REPEAT GEN_TAC THEN MATCH_MP_TAC SET_VARIATION_ON_ELEMENTARY THEN 9698 REWRITE_TAC[ELEMENTARY_INTERVAL]); 9699 9700val HAS_BOUNDED_SETVARIATION_WORKS = store_thm ("HAS_BOUNDED_SETVARIATION_WORKS", 9701 ``!f:(real->bool)->real s. 9702 f has_bounded_setvariation_on s 9703 ==> (!d t. d division_of t /\ t SUBSET s 9704 ==> sum d (\k. abs(f k)) <= set_variation s f) /\ 9705 (!B. (!d t. d division_of t /\ t SUBSET s 9706 ==> sum d (\k. abs (f k)) <= B) 9707 ==> set_variation s f <= B)``, 9708 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_setvariation_on] THEN 9709 DISCH_TAC THEN 9710 MP_TAC(ISPEC ``{ sum d (\k. abs((f:(real->bool)->real) k)) | 9711 ?t. d division_of t /\ t SUBSET s}`` 9712 SUP) THEN 9713 SIMP_TAC std_ss [FORALL_IN_GSPEC, LEFT_IMP_EXISTS_THM] THEN 9714 REWRITE_TAC[set_variation] THEN DISCH_THEN MATCH_MP_TAC THEN 9715 ASM_SIMP_TAC std_ss [GSYM MEMBER_NOT_EMPTY, GSPECIFICATION] THEN 9716 MAP_EVERY EXISTS_TAC [``{}:(real->bool)->bool``] THEN 9717 REWRITE_TAC[SUM_CLAUSES] THEN EXISTS_TAC ``{}:real->bool`` THEN 9718 SIMP_TAC std_ss [division_of, EMPTY_SUBSET, NOT_IN_EMPTY, FINITE_EMPTY, 9719 BIGUNION_EMPTY]); 9720 9721val HAS_BOUNDED_SETVARIATION_WORKS_ON_ELEMENTARY = store_thm ("HAS_BOUNDED_SETVARIATION_WORKS_ON_ELEMENTARY", 9722 ``!f:(real->bool)->real s. 9723 f has_bounded_setvariation_on s /\ (?d. d division_of s) 9724 ==> (!d. d division_of s 9725 ==> sum d (\k. abs(f k)) <= set_variation s f) /\ 9726 (!B. (!d. d division_of s ==> sum d (\k. abs(f k)) <= B) 9727 ==> set_variation s f <= B)``, 9728 SIMP_TAC std_ss [GSYM SET_VARIATION_ELEMENTARY_LEMMA] THEN 9729 METIS_TAC[HAS_BOUNDED_SETVARIATION_WORKS]); 9730 9731val HAS_BOUNDED_SETVARIATION_WORKS_ON_INTERVAL = store_thm ("HAS_BOUNDED_SETVARIATION_WORKS_ON_INTERVAL", 9732 ``!f:(real->bool)->real a b. 9733 f has_bounded_setvariation_on interval[a,b] 9734 ==> (!d. d division_of interval[a,b] 9735 ==> sum d (\k. abs(f k)) <= set_variation (interval[a,b]) f) /\ 9736 (!B. (!d. d division_of interval[a,b] 9737 ==> sum d (\k. abs(f k)) <= B) 9738 ==> set_variation (interval[a,b]) f <= B)``, 9739 SIMP_TAC std_ss [HAS_BOUNDED_SETVARIATION_WORKS_ON_ELEMENTARY, ELEMENTARY_INTERVAL]); 9740 9741val SET_VARIATION_UBOUND = store_thm ("SET_VARIATION_UBOUND", 9742 ``!f:(real->bool)->real s B. 9743 f has_bounded_setvariation_on s /\ 9744 (!d t. d division_of t /\ t SUBSET s ==> sum d (\k. abs(f k)) <= B) 9745 ==> set_variation s f <= B``, 9746 METIS_TAC[HAS_BOUNDED_SETVARIATION_WORKS]); 9747 9748val SET_VARIATION_UBOUND_ON_INTERVAL = store_thm ("SET_VARIATION_UBOUND_ON_INTERVAL", 9749 ``!f:(real->bool)->real a b B. 9750 f has_bounded_setvariation_on interval[a,b] /\ 9751 (!d. d division_of interval[a,b] ==> sum d (\k. abs(f k)) <= B) 9752 ==> set_variation (interval[a,b]) f <= B``, 9753 SIMP_TAC std_ss [GSYM SET_VARIATION_ELEMENTARY_LEMMA, ELEMENTARY_INTERVAL] THEN 9754 METIS_TAC[SET_VARIATION_UBOUND]); 9755 9756val SET_VARIATION_LBOUND = store_thm ("SET_VARIATION_LBOUND", 9757 ``!f:(real->bool)->real s B. 9758 f has_bounded_setvariation_on s /\ 9759 (?d t. d division_of t /\ t SUBSET s /\ B <= sum d (\k. abs(f k))) 9760 ==> B <= set_variation s f``, 9761 METIS_TAC[HAS_BOUNDED_SETVARIATION_WORKS, REAL_LE_TRANS]); 9762 9763val SET_VARIATION_LBOUND_ON_INTERVAL = store_thm ("SET_VARIATION_LBOUND_ON_INTERVAL", 9764 ``!f:(real->bool)->real a b B. 9765 f has_bounded_setvariation_on interval[a,b] /\ 9766 (?d. d division_of interval[a,b] /\ B <= sum d (\k. abs(f k))) 9767 ==> B <= set_variation (interval[a,b]) f``, 9768 METIS_TAC[HAS_BOUNDED_SETVARIATION_WORKS_ON_INTERVAL, REAL_LE_TRANS]); 9769 9770val SET_VARIATION = store_thm ("SET_VARIATION", 9771 ``!f:(real->bool)->real s d t. 9772 f has_bounded_setvariation_on s /\ d division_of t /\ t SUBSET s 9773 ==> sum d (\k. abs(f k)) <= set_variation s f``, 9774 METIS_TAC[HAS_BOUNDED_SETVARIATION_WORKS]); 9775 9776val SET_VARIATION_WORKS_ON_INTERVAL = store_thm ("SET_VARIATION_WORKS_ON_INTERVAL", 9777 ``!f:(real->bool)->real a b d. 9778 f has_bounded_setvariation_on interval[a,b] /\ 9779 d division_of interval[a,b] 9780 ==> sum d (\k. abs(f k)) <= set_variation (interval[a,b]) f``, 9781 METIS_TAC[HAS_BOUNDED_SETVARIATION_WORKS_ON_INTERVAL]); 9782 9783val SET_VARIATION_POS_LE = store_thm ("SET_VARIATION_POS_LE", 9784 ``!f:(real->bool)->real s. 9785 f has_bounded_setvariation_on s ==> &0 <= set_variation s f``, 9786 REPEAT STRIP_TAC THEN 9787 FIRST_ASSUM(MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] SET_VARIATION)) THEN 9788 DISCH_THEN(MP_TAC o SPECL[``{}:(real->bool)->bool``, ``{}:real->bool``]) THEN 9789 REWRITE_TAC[EMPTY_SUBSET, SUM_CLAUSES, DIVISION_OF_TRIVIAL]); 9790 9791val SET_VARIATION_COMPARISON = store_thm ("SET_VARIATION_COMPARISON", 9792 ``!f:(real->bool)->real g:(real->bool)->real s. 9793 f has_bounded_setvariation_on s /\ 9794 (!a b. ~(interval[a,b] = {}) /\ interval[a,b] SUBSET s 9795 ==> abs(g(interval[a,b])) <= abs(f(interval[a,b]))) 9796 ==> set_variation s g <= set_variation s f``, 9797 REPEAT STRIP_TAC THEN MATCH_MP_TAC SET_VARIATION_UBOUND THEN CONJ_TAC THENL 9798 [ASM_MESON_TAC[HAS_BOUNDED_SETVARIATION_COMPARISON], ALL_TAC] THEN 9799 UNDISCH_TAC ``f has_bounded_setvariation_on s`` THEN DISCH_TAC THEN 9800 FIRST_ASSUM(MP_TAC o CONJUNCT1 o MATCH_MP 9801 HAS_BOUNDED_SETVARIATION_WORKS) THEN 9802 DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 9803 POP_ASSUM (MP_TAC o SPECL [``d:(real -> bool) -> bool``,``t:real -> bool``]) THEN 9804 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 9805 ASM_REWRITE_TAC[] THEN 9806 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LE_TRANS) THEN 9807 MATCH_MP_TAC SUM_LE THEN 9808 CONJ_TAC THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 9809 UNDISCH_TAC ``d division_of t`` THEN DISCH_TAC THEN FIRST_ASSUM 9810 (fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 9811 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 9812 METIS_TAC[division_of, SUBSET_TRANS]); 9813 9814val SET_VARIATION_GE_FUNCTION = store_thm ("SET_VARIATION_GE_FUNCTION", 9815 ``!f:(real->bool)->real s a b. 9816 f has_bounded_setvariation_on s /\ 9817 interval[a,b] SUBSET s /\ ~(interval[a,b] = {}) 9818 ==> abs(f(interval[a,b])) <= set_variation s f``, 9819 REPEAT STRIP_TAC THEN MATCH_MP_TAC SET_VARIATION_LBOUND THEN 9820 ASM_SIMP_TAC std_ss [] THEN EXISTS_TAC ``{interval[a:real,b]}`` THEN 9821 EXISTS_TAC ``interval[a:real,b]`` THEN 9822 ASM_SIMP_TAC std_ss [SUM_SING, REAL_LE_REFL] THEN 9823 ASM_SIMP_TAC std_ss [DIVISION_OF_SELF]); 9824 9825val SET_VARIATION_ON_NULL = store_thm ("SET_VARIATION_ON_NULL", 9826 ``!f:(real->bool)->real s. 9827 (!a b. (content(interval[a,b]) = &0) ==> (f(interval[a,b]) = 0)) /\ 9828 (content s = &0) /\ bounded s 9829 ==> (set_variation s f = &0)``, 9830 REPEAT STRIP_TAC THEN 9831 ONCE_REWRITE_TAC[GSYM REAL_LE_ANTISYM] THEN CONJ_TAC THENL 9832 [MATCH_MP_TAC SET_VARIATION_UBOUND THEN 9833 ASM_SIMP_TAC std_ss [HAS_BOUNDED_SETVARIATION_ON_NULL] THEN 9834 REPEAT STRIP_TAC THEN 9835 MATCH_MP_TAC(REAL_ARITH ``(x = &0) ==> x <= &0:real``) THEN 9836 MATCH_MP_TAC SUM_EQ_0 THEN SIMP_TAC std_ss [ABS_ZERO] THEN 9837 UNDISCH_TAC ``d division_of t`` THEN DISCH_TAC THEN 9838 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 9839 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 9840 MATCH_MP_TAC CONTENT_0_SUBSET_GEN THEN 9841 EXISTS_TAC ``s:real->bool`` THEN ASM_REWRITE_TAC[] THEN 9842 ASM_MESON_TAC[division_of, SUBSET_TRANS], 9843 MATCH_MP_TAC SET_VARIATION_POS_LE THEN 9844 ASM_SIMP_TAC std_ss [HAS_BOUNDED_SETVARIATION_ON_NULL]]); 9845 9846val SET_VARIATION_TRIANGLE = store_thm ("SET_VARIATION_TRIANGLE", 9847 ``!f:(real->bool)->real g s. 9848 f has_bounded_setvariation_on s /\ 9849 g has_bounded_setvariation_on s 9850 ==> set_variation s (\x. f x + g x) 9851 <= set_variation s f + set_variation s g``, 9852 REPEAT STRIP_TAC THEN MATCH_MP_TAC SET_VARIATION_UBOUND THEN 9853 ASM_SIMP_TAC std_ss [HAS_BOUNDED_SETVARIATION_ON_ADD] THEN 9854 MAP_EVERY X_GEN_TAC [``d:(real->bool)->bool``, ``t:real->bool``] THEN 9855 STRIP_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN 9856 EXISTS_TAC ``sum d (\k. abs((f:(real->bool)->real) k)) + 9857 sum d (\k. abs((g:(real->bool)->real) k))`` THEN 9858 CONJ_TAC THENL 9859 [FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 9860 ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN 9861 MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [ABS_TRIANGLE], 9862 MATCH_MP_TAC REAL_LE_ADD2 THEN 9863 CONJ_TAC THEN MATCH_MP_TAC SET_VARIATION THEN ASM_MESON_TAC[]]); 9864 9865val HAS_BOUNDED_SETVARIATION_ON_SUM_AND_SET_VARIATION_SUM_LE = store_thm ("HAS_BOUNDED_SETVARIATION_ON_SUM_AND_SET_VARIATION_SUM_LE", 9866 ``(!f:'a->(real->bool)->real s k. 9867 FINITE k /\ 9868 (!i. i IN k ==> f i has_bounded_setvariation_on s) 9869 ==> (\x. sum k (\i. f i x)) has_bounded_setvariation_on s) /\ 9870 (!f:'a->(real->bool)->real s k. 9871 FINITE k /\ 9872 (!i. i IN k ==> f i has_bounded_setvariation_on s) 9873 ==> set_variation s (\x. sum k (\i. f i x)) 9874 <= sum k (\i. set_variation s (f i)))``, 9875 SIMP_TAC std_ss [GSYM FORALL_AND_THM, TAUT 9876 `(p ==> q) /\ (p ==> r) <=> p ==> q /\ r`] THEN 9877 GEN_TAC THEN GEN_TAC THEN REWRITE_TAC[IMP_CONJ] THEN 9878 ONCE_REWRITE_TAC [METIS [] 9879 ``!k. ((!i. i IN k ==> f i has_bounded_setvariation_on s) ==> 9880 (\x. sum k (\i. f i x)) has_bounded_setvariation_on s /\ 9881 set_variation s (\x. sum k (\i. f i x)) <= 9882 sum k (\i. set_variation s (f i))) = 9883 (\k. (!i. i IN k ==> f i has_bounded_setvariation_on s) ==> 9884 (\x. sum k (\i. f i x)) has_bounded_setvariation_on s /\ 9885 set_variation s (\x. sum k (\i. f i x)) <= 9886 sum k (\i. set_variation s (f i))) k``] THEN 9887 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 9888 SIMP_TAC std_ss [SUM_CLAUSES, FORALL_IN_INSERT] THEN 9889 SIMP_TAC std_ss [SET_VARIATION_0, REAL_LE_REFL, HAS_BOUNDED_SETVARIATION_ON_0, 9890 HAS_BOUNDED_SETVARIATION_ON_ADD, ETA_AX] THEN 9891 REPEAT STRIP_TAC THENL 9892 [ONCE_REWRITE_TAC [METIS [] ``(\x. f e x + sum s' (\i. f i x)) = 9893 (\x. (\x. f e x) x + (\x. sum s' (\i. f i x)) x)``] THEN 9894 MATCH_MP_TAC HAS_BOUNDED_SETVARIATION_ON_ADD THEN METIS_TAC [ETA_AX], 9895 ALL_TAC] THEN 9896 ONCE_REWRITE_TAC [METIS [] ``(\x. f e x + sum s' (\i. f i x)) = 9897 (\x. (\x. f e x) x + (\x. sum s' (\i. f i x)) x)``] THEN 9898 W(MP_TAC o PART_MATCH (lhand o rand) 9899 SET_VARIATION_TRIANGLE o lhand o snd) THEN 9900 ASM_SIMP_TAC std_ss [METIS [ETA_AX] ``(\x. f e x) = f e``] THEN 9901 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] REAL_LE_TRANS) THEN 9902 ASM_SIMP_TAC std_ss [REAL_LE_LADD]); 9903 9904val HAS_BOUNDED_SETVARIATION_ON_SUM = store_thm ("HAS_BOUNDED_SETVARIATION_ON_SUM", 9905 ``(!f:'a->(real->bool)->real s k. 9906 FINITE k /\ 9907 (!i. i IN k ==> f i has_bounded_setvariation_on s) 9908 ==> (\x. sum k (\i. f i x)) has_bounded_setvariation_on s)``, 9909 REWRITE_TAC [HAS_BOUNDED_SETVARIATION_ON_SUM_AND_SET_VARIATION_SUM_LE]); 9910 9911val SET_VARIATION_SUM_LE = store_thm ("SET_VARIATION_SUM_LE", 9912 ``(!f:'a->(real->bool)->real s k. 9913 FINITE k /\ 9914 (!i. i IN k ==> f i has_bounded_setvariation_on s) 9915 ==> set_variation s (\x. sum k (\i. f i x)) 9916 <= sum k (\i. set_variation s (f i)))``, 9917 REWRITE_TAC [HAS_BOUNDED_SETVARIATION_ON_SUM_AND_SET_VARIATION_SUM_LE]); 9918 9919val lemma1 = prove ( 9920 ``!f:(real->bool)->real B1 B2 a b. 9921 (!a b. (content(interval[a,b]) = &0) ==> (f(interval[a,b]) = &0)) /\ 9922 (!a b c. f(interval[a,b]) <= 9923 f(interval[a,b] INTER {x | x <= c}) + 9924 f(interval[a,b] INTER {x | x >= c})) /\ 9925 (!d. d division_of (interval[a,b] INTER {x | x <= c}) 9926 ==> sum d f <= B1) /\ 9927 (!d. d division_of (interval[a,b] INTER {x | x >= c}) 9928 ==> sum d f <= B2) 9929 ==> !d. d division_of interval[a,b] ==> sum d f <= B1 + B2``, 9930 REPEAT GEN_TAC THEN 9931 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 9932 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 9933 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 9934 DISCH_TAC THEN 9935 GEN_TAC THEN DISCH_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN 9936 EXISTS_TAC 9937 ``sum {l INTER {x:real | x <= c} | l | l IN d /\ 9938 ~(l INTER {x | x <= c} = {})} f + 9939 sum {l INTER {x | x >= c} | l | l IN d /\ 9940 ~(l INTER {x | x >= c} = {})} f`` THEN 9941 CONJ_TAC THENL 9942 [ALL_TAC, 9943 MATCH_MP_TAC REAL_LE_ADD2 THEN CONJ_TAC THEN 9944 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC std_ss [DIVISION_SPLIT]] THEN 9945 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 9946 ``{l INTER {x | x <= c:real} | l | l IN d /\ l INTER {x | x <= c} <> {}} = 9947 IMAGE (\l. l INTER {x | x <= c}) 9948 {l | l IN d /\ l INTER {x | x <= c} <> {}}``] THEN 9949 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 9950 ``{l INTER {x | x >= c:real} | l | l IN d /\ l INTER {x | x >= c} <> {}} = 9951 IMAGE (\l. l INTER {x | x >= c}) 9952 {l | l IN d /\ l INTER {x | x >= c} <> {}}``] THEN 9953 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 9954 W(fn (asl,w) => 9955 MP_TAC(PART_MATCH (lhs o rand) SUM_IMAGE_NONZERO (lhand(rand w))) THEN 9956 MP_TAC(PART_MATCH (lhs o rand) SUM_IMAGE_NONZERO (rand(rand w)))) THEN 9957 MATCH_MP_TAC(TAUT 9958 `(a1 /\ a2) /\ (b1 /\ b2 ==> c) 9959 ==> (a1 ==> b1) ==> (a2 ==> b2) ==> c`) THEN 9960 CONJ_TAC THENL 9961 [ASM_SIMP_TAC std_ss [FINITE_RESTRICT, IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 9962 SIMP_TAC std_ss [FORALL_IN_GSPEC, IMP_CONJ] THEN 9963 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 9964 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 9965 REPEAT STRIP_TAC THEN ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 9966 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC std_ss [GSYM INTERVAL_SPLIT] THENL 9967 [MATCH_MP_TAC DIVISION_SPLIT_RIGHT_INJ, 9968 MATCH_MP_TAC DIVISION_SPLIT_LEFT_INJ] THEN 9969 ASM_MESON_TAC[], 9970 DISCH_THEN(CONJUNCTS_THEN SUBST1_TAC)] THEN 9971 MATCH_MP_TAC REAL_LE_TRANS THEN 9972 EXISTS_TAC 9973 ``sum d (f o (\l. l INTER {x | x <= c})) + 9974 sum d (f o (\l. l INTER {x:real | x >= c}))`` THEN 9975 CONJ_TAC THENL 9976 [ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN MATCH_MP_TAC SUM_LE THEN 9977 ASM_REWRITE_TAC[o_THM] THEN 9978 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 9979 FIRST_ASSUM(fn th => ASM_SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]), 9980 MATCH_MP_TAC(REAL_ARITH ``(x = y) /\ (w = z) ==> x + w <= y + z:real``) THEN 9981 CONJ_TAC THEN MATCH_MP_TAC SUM_SUPERSET THEN 9982 ONCE_REWRITE_TAC [METIS [] ``({l | l IN d /\ l INTER {x | x <= c:real} <> {}}) = 9983 {l | l IN d /\ (\l. l INTER {x | x <= c} <> {}) l}``] THEN 9984 ONCE_REWRITE_TAC [METIS [] ``({l | l IN d /\ l INTER {x | x >= c:real} <> {}}) = 9985 {l | l IN d /\ (\l. l INTER {x | x >= c} <> {}) l}``] THEN 9986 REWRITE_TAC[SET_RULE ``{x | x IN s /\ P x} SUBSET s``] THEN 9987 ONCE_REWRITE_TAC [METIS [] ``((f o (\l. l INTER {x | x <= c:real})) x = 0) = 9988 (\x. ((f:(real -> bool) -> real o (\l. l INTER {x | x <= c})) x = 0)) x``] THEN 9989 ONCE_REWRITE_TAC [METIS [] ``((f o (\l. l INTER {x | x >= c:real})) x = 0) = 9990 (\x. ((f:(real -> bool) -> real o (\l. l INTER {x | x >= c})) x = 0)) x``] THEN 9991 REWRITE_TAC[SET_RULE ``(x IN s /\ ~(x IN {l | l IN s /\ P l}) ==> Q x) <=> 9992 (x IN s ==> ~P x ==> Q x)``] THEN 9993 SIMP_TAC std_ss [o_THM] THEN ASM_MESON_TAC[EMPTY_AS_INTERVAL, CONTENT_EMPTY]]); 9994 9995val lemma2 = prove ( 9996 ``!f:(real->bool)->real B. 9997 (!a b. (content(interval[a,b]) = &0) ==> (f(interval[a,b]) = &0)) /\ 9998 (!d. d division_of interval[a,b] ==> sum d f <= B) 9999 ==> !d1 d2. d1 division_of (interval[a,b] INTER {x | x <= c}) /\ 10000 d2 division_of (interval[a,b] INTER {x | x >= c}) 10001 ==> sum d1 f + sum d2 f <= B``, 10002 REPEAT STRIP_TAC THEN 10003 FIRST_X_ASSUM(MP_TAC o SPEC ``d1 UNION d2:(real->bool)->bool``) THEN 10004 KNOW_TAC ``(d1:(real->bool)->bool) UNION d2 division_of interval [(a,b)]`` THENL 10005 [ (* goal 1 (of 2) *) 10006 SUBGOAL_THEN 10007 ``interval[a,b] = (interval[a,b] INTER {x:real | x <= c}) UNION 10008 (interval[a,b] INTER {x:real | x >= c})`` 10009 SUBST1_TAC THENL 10010 [MATCH_MP_TAC(SET_RULE 10011 ``(!x. x IN t \/ x IN u) ==> (s = s INTER t UNION s INTER u)``) THEN 10012 SIMP_TAC std_ss [GSPECIFICATION] THEN REAL_ARITH_TAC, 10013 MATCH_MP_TAC DIVISION_DISJOINT_UNION THEN ASM_REWRITE_TAC[] THEN 10014 REWRITE_TAC[GSYM INTERIOR_INTER] THEN 10015 MATCH_MP_TAC(SET_RULE 10016 ``!t. interior s SUBSET interior t /\ (interior t = {}) 10017 ==> (interior s = {})``) THEN 10018 EXISTS_TAC ``{x:real | x = c}`` THEN CONJ_TAC THENL 10019 [ALL_TAC, REWRITE_TAC[INTERIOR_STANDARD_HYPERPLANE]] THEN 10020 MATCH_MP_TAC SUBSET_INTERIOR THEN 10021 SIMP_TAC std_ss [SUBSET_DEF, IN_INTER, GSPECIFICATION] THEN REAL_ARITH_TAC], 10022 (* goal 2 (of 2) *) 10023 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 10024 MATCH_MP_TAC(REAL_ARITH ``(x = y) ==> x <= b ==> y <= b:real``) THEN 10025 MATCH_MP_TAC SUM_UNION_NONZERO THEN 10026 REPEAT(CONJ_TAC THENL [ASM_MESON_TAC[DIVISION_OF_FINITE], ALL_TAC]) THEN 10027 X_GEN_TAC ``k:real->bool`` THEN REWRITE_TAC[IN_INTER] THEN STRIP_TAC THEN 10028 SUBGOAL_THEN ``?u v:real. k = interval[u,v]`` 10029 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 10030 THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 10031 FIRST_X_ASSUM MATCH_MP_TAC THEN MATCH_MP_TAC CONTENT_0_SUBSET_GEN THEN 10032 EXISTS_TAC ``interval[a,b] INTER {x:real | x = c}`` THEN CONJ_TAC THENL 10033 [ (* goal 2.1 (of 2) *) 10034 MATCH_MP_TAC SUBSET_TRANS THEN 10035 EXISTS_TAC ``(interval[a,b] INTER {x:real | x <= c}) INTER 10036 (interval[a,b] INTER {x:real | x >= c})`` THEN 10037 CONJ_TAC THENL 10038 [ ONCE_REWRITE_TAC[SUBSET_INTER] THEN ASM_MESON_TAC[division_of], 10039 REWRITE_TAC[SET_RULE 10040 ``(s INTER t) INTER (s INTER u) = s INTER t INTER u``] THEN 10041 SIMP_TAC std_ss [SUBSET_DEF, IN_INTER, GSPECIFICATION] THEN 10042 RW_TAC std_ss [] \\ 10043 REWRITE_TAC [GSYM REAL_LE_ANTISYM] >> fs [real_ge] ], 10044 (* goal 2.2 (of 2) *) 10045 SIMP_TAC std_ss [BOUNDED_INTER, BOUNDED_INTERVAL] THEN 10046 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) 10047 [REAL_ARITH ``(x = y) <=> x <= y /\ x >= y:real``] THEN 10048 REWRITE_TAC[SET_RULE 10049 ``{x | x <= c /\ x >= c} = {x | x <= c} INTER {x | x >= c}``] THEN 10050 ASM_SIMP_TAC std_ss [INTER_ASSOC, INTERVAL_SPLIT] THEN 10051 SIMP_TAC std_ss [CONTENT_EQ_0, min_def, max_def] THEN KILL_TAC THEN 10052 rpt COND_CASES_TAC >> fs [REAL_LE_REFL] >> REAL_ASM_ARITH_TAC 10053 ] ]); 10054 10055val OPERATIVE_LIFTED_SETVARIATION = store_thm ("OPERATIVE_LIFTED_SETVARIATION", 10056 ``!f:(real->bool)->real. 10057 operative(+) f 10058 ==> operative (lifted(+)) 10059 (\i. if f has_bounded_setvariation_on i 10060 then SOME(set_variation i f) else NONE)``, 10061 REWRITE_TAC[operative, NEUTRAL_REAL_ADD] THEN REPEAT GEN_TAC THEN 10062 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (ASSUME_TAC o GSYM)) THEN 10063 ASM_SIMP_TAC std_ss [HAS_BOUNDED_SETVARIATION_ON_NULL, BOUNDED_INTERVAL, 10064 MONOIDAL_REAL_ADD, SET_VARIATION_ON_NULL, NEUTRAL_LIFTED, 10065 NEUTRAL_REAL_ADD] THEN 10066 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``, ``c:real``] THEN 10067 ASM_CASES_TAC 10068 ``(f:(real->bool)->real) has_bounded_setvariation_on interval[a,b]`` THEN 10069 ASM_REWRITE_TAC[] THENL 10070 [SUBGOAL_THEN 10071 ``(f:(real->bool)->real) has_bounded_setvariation_on 10072 interval[a,b] INTER {x | x <= c} /\ 10073 (f:(real->bool)->real) has_bounded_setvariation_on 10074 interval[a,b] INTER {x | x >= c}`` 10075 ASSUME_TAC THENL 10076 [CONJ_TAC THEN FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP 10077 (REWRITE_RULE[IMP_CONJ] HAS_BOUNDED_SETVARIATION_ON_SUBSET)) THEN 10078 REWRITE_TAC[INTER_SUBSET], 10079 ALL_TAC] THEN 10080 ASM_REWRITE_TAC[lifted] THEN AP_TERM_TAC THEN 10081 REWRITE_TAC[GSYM REAL_LE_ANTISYM] THEN CONJ_TAC THENL 10082 [MATCH_MP_TAC SET_VARIATION_UBOUND_ON_INTERVAL THEN ASM_REWRITE_TAC[] THEN 10083 REPEAT STRIP_TAC THEN MATCH_MP_TAC 10084 (SIMP_RULE std_ss [AND_IMP_INTRO, RIGHT_IMP_FORALL_THM] lemma1) THEN 10085 MAP_EVERY EXISTS_TAC [``a:real``, ``b:real``] THEN 10086 ASM_SIMP_TAC std_ss [ABS_0] THEN CONJ_TAC THENL 10087 [REPEAT GEN_TAC THEN 10088 MATCH_MP_TAC(REAL_ARITH 10089 ``(x:real = y + z) ==> abs(x) <= abs y + abs z``) THEN 10090 ASM_SIMP_TAC std_ss [], 10091 FIRST_X_ASSUM(fn th => MP_TAC th THEN MATCH_MP_TAC MONO_AND) THEN 10092 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, SET_VARIATION_WORKS_ON_INTERVAL]], 10093 ONCE_REWRITE_TAC[REAL_ARITH ``x + y <= z <=> x <= z - y:real``] THEN 10094 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 10095 MATCH_MP_TAC SET_VARIATION_UBOUND_ON_INTERVAL THEN 10096 ASM_SIMP_TAC std_ss [GSYM INTERVAL_SPLIT] THEN 10097 X_GEN_TAC ``d1:(real->bool)->bool`` THEN STRIP_TAC THEN 10098 ONCE_REWRITE_TAC[REAL_ARITH ``x <= y - z <=> z <= y - x:real``] THEN 10099 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 10100 MATCH_MP_TAC SET_VARIATION_UBOUND_ON_INTERVAL THEN 10101 ASM_SIMP_TAC std_ss [GSYM INTERVAL_SPLIT] THEN 10102 X_GEN_TAC ``d2:(real->bool)->bool`` THEN STRIP_TAC THEN 10103 REWRITE_TAC[REAL_ARITH ``x <= y - z <=> z + x <= y:real``] THEN 10104 REPEAT STRIP_TAC THEN MATCH_MP_TAC 10105 (SIMP_RULE std_ss [AND_IMP_INTRO, RIGHT_IMP_FORALL_THM] lemma2) THEN 10106 ASM_SIMP_TAC std_ss [ABS_0, SET_VARIATION_WORKS_ON_INTERVAL]], 10107 REPEAT(COND_CASES_TAC THEN ASM_REWRITE_TAC[lifted]) THEN 10108 UNDISCH_TAC ``~(f has_bounded_setvariation_on interval [(a,b)])`` THEN 10109 MATCH_MP_TAC(TAUT `p ==> ~p ==> q`) THEN 10110 REWRITE_TAC[HAS_BOUNDED_SETVARIATION_ON_INTERVAL] THEN 10111 EXISTS_TAC ``set_variation (interval[a,b] INTER {x | x <= c}) 10112 (f:(real->bool)->real) + 10113 set_variation (interval[a,b] INTER {x | x >= c}) f`` THEN 10114 REPEAT STRIP_TAC THEN MATCH_MP_TAC 10115 (SIMP_RULE std_ss [AND_IMP_INTRO, RIGHT_IMP_FORALL_THM] lemma1) THEN 10116 MAP_EVERY EXISTS_TAC [``a:real``, ``b:real``] THEN 10117 ASM_SIMP_TAC std_ss [ABS_0] THEN REPEAT CONJ_TAC THENL 10118 [REPEAT GEN_TAC THEN 10119 MATCH_MP_TAC(REAL_ARITH 10120 ``(x:real = y + z) ==> abs(x) <= abs y + abs z``) THEN 10121 ASM_SIMP_TAC std_ss [], 10122 UNDISCH_TAC 10123 ``(f:(real->bool)->real) has_bounded_setvariation_on 10124 (interval[a,b] INTER {x | x <= c})`` THEN 10125 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, SET_VARIATION_WORKS_ON_INTERVAL], 10126 UNDISCH_TAC 10127 ``(f:(real->bool)->real) has_bounded_setvariation_on 10128 (interval[a,b] INTER {x | x >= c})`` THEN 10129 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, SET_VARIATION_WORKS_ON_INTERVAL]]]); 10130 10131val HAS_BOUNDED_SETVARIATION_ON_DIVISION = store_thm ("HAS_BOUNDED_SETVARIATION_ON_DIVISION", 10132 ``!f:(real->bool)->real a b d. 10133 operative (+) f /\ d division_of interval[a,b] 10134 ==> ((!k. k IN d ==> f has_bounded_setvariation_on k) <=> 10135 f has_bounded_setvariation_on interval[a,b])``, 10136 REPEAT STRIP_TAC THEN MATCH_MP_TAC OPERATIVE_DIVISION_AND THEN 10137 ASM_REWRITE_TAC[operative, NEUTRAL_AND] THEN CONJ_TAC THENL 10138 [RULE_ASSUM_TAC(REWRITE_RULE[operative, NEUTRAL_REAL_ADD]) THEN 10139 ASM_SIMP_TAC std_ss [HAS_BOUNDED_SETVARIATION_ON_NULL, BOUNDED_INTERVAL], 10140 FIRST_ASSUM(MP_TAC o MATCH_MP OPERATIVE_LIFTED_SETVARIATION) THEN 10141 REWRITE_TAC[operative] THEN DISCH_THEN(MP_TAC o CONJUNCT2) THEN 10142 POP_ASSUM K_TAC THEN DISCH_TAC THEN REPEAT GEN_TAC THEN 10143 POP_ASSUM (MP_TAC o SPECL [``a:real``,``b:real``,``c:real``]) THEN 10144 SIMP_TAC std_ss [] THEN 10145 REPEAT(COND_CASES_TAC THEN 10146 ASM_SIMP_TAC std_ss [lifted, NOT_NONE_SOME, option_CLAUSES])]); 10147 10148val lemma0 = prove ( 10149 ``!op x y. ((lifted op (SOME x) y = SOME z) <=> ?w. (y = SOME w) /\ (op x w = z))``, 10150 GEN_TAC THEN GEN_TAC THEN ONCE_REWRITE_TAC [METIS [] 10151 ``((lifted op (SOME x) y = SOME z) <=> ?w. (y = SOME w) /\ (op x w = z)) = 10152 (\y. (lifted op (SOME x) y = SOME z) <=> ?w. (y = SOME w) /\ (op x w = z)) y``] THEN 10153 MATCH_MP_TAC option_induction THEN 10154 SIMP_TAC std_ss [lifted, NOT_NONE_SOME, SOME_11] THEN 10155 MESON_TAC[]); 10156 10157val lemma = prove ( 10158 ``!P op f s z. 10159 monoidal op /\ FINITE s /\ 10160 (iterate(lifted op) s (\i. if P i then SOME(f i) else NONE) = SOME z) 10161 ==> (iterate op s f = z)``, 10162 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 10163 REPEAT GEN_TAC THEN DISCH_TAC THEN GEN_TAC THEN 10164 ONCE_REWRITE_TAC [METIS [] 10165 ``!s. (!z. (iterate (lifted op) s (\i. if P i then SOME (f i) else NONE) = 10166 SOME z) ==> (iterate op s f = z)) = 10167 (\s. !z. (iterate (lifted op) s (\i. if P i then SOME (f i) else NONE) = 10168 SOME z) ==> (iterate op s f = z)) s``] THEN 10169 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 10170 ASM_SIMP_TAC std_ss [ITERATE_CLAUSES, MONOIDAL_LIFTED, NEUTRAL_LIFTED] THEN 10171 SIMP_TAC std_ss [SOME_11] THEN REPEAT GEN_TAC THEN 10172 STRIP_TAC THEN GEN_TAC THEN COND_CASES_TAC THEN 10173 SIMP_TAC std_ss [lifted, NOT_NONE_SOME] THEN ASM_MESON_TAC[lemma0]); 10174 10175val SET_VARIATION_ON_DIVISION = store_thm ("SET_VARIATION_ON_DIVISION", 10176 ``!f:(real->bool)->real a b d. 10177 operative (+) f /\ d division_of interval[a,b] /\ 10178 f has_bounded_setvariation_on interval[a,b] 10179 ==> (sum d (\k. set_variation k f) = set_variation (interval[a,b]) f)``, 10180 REPEAT STRIP_TAC THEN 10181 FIRST_ASSUM(MP_TAC o MATCH_MP OPERATIVE_LIFTED_SETVARIATION) THEN 10182 DISCH_THEN(MP_TAC o SPECL[``d:(real->bool)->bool``, ``a:real``, ``b:real``] o 10183 MATCH_MP (REWRITE_RULE [TAUT `a /\ b /\ c ==> d <=> b ==> a /\ c ==> d`] 10184 OPERATIVE_DIVISION)) THEN 10185 ASM_SIMP_TAC std_ss [MONOIDAL_LIFTED, MONOIDAL_REAL_ADD] THEN 10186 MP_TAC(ISPECL 10187 [``\k. (f:(real->bool)->real) has_bounded_setvariation_on k``, 10188 ``(+):real->real->real``, 10189 ``\k. set_variation k (f:(real->bool)->real)``, 10190 ``d:(real->bool)->bool``, 10191 ``set_variation (interval[a,b]) (f:(real->bool)->real)``] 10192 lemma) THEN 10193 FIRST_X_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 10194 ASM_SIMP_TAC std_ss [sum_def, MONOIDAL_REAL_ADD]); 10195 10196val SET_VARIATION_MONOTONE = store_thm ("SET_VARIATION_MONOTONE", 10197 ``!f:(real->bool)->real s t. 10198 f has_bounded_setvariation_on s /\ t SUBSET s 10199 ==> set_variation t f <= set_variation s f``, 10200 REPEAT STRIP_TAC THEN REWRITE_TAC[set_variation] THEN 10201 MATCH_MP_TAC REAL_SUP_LE_SUBSET THEN REPEAT CONJ_TAC THENL 10202 [SIMP_TAC std_ss [GSYM MEMBER_NOT_EMPTY, GSPECIFICATION] THEN 10203 MAP_EVERY EXISTS_TAC [``{}:(real->bool)->bool``] THEN 10204 REWRITE_TAC[SUM_CLAUSES] THEN EXISTS_TAC ``{}:real->bool`` THEN 10205 REWRITE_TAC[EMPTY_SUBSET, DIVISION_OF_TRIVIAL], 10206 ONCE_REWRITE_TAC [METIS [] 10207 ``{sum d (\k. abs (f k)) | ?t. d division_of t /\ t SUBSET s} = 10208 {(\d. sum d (\k. abs (f k))) d | (\d. ?t. d division_of t /\ t SUBSET s) d}``] THEN 10209 MATCH_MP_TAC(SET_RULE 10210 ``(!d. P d ==> Q d) ==> {f d | P d} SUBSET {f d | Q d}``) THEN 10211 ASM_MESON_TAC[SUBSET_TRANS], 10212 SIMP_TAC std_ss [FORALL_IN_GSPEC, LEFT_IMP_EXISTS_THM] THEN 10213 ASM_REWRITE_TAC[GSYM has_bounded_setvariation_on]]); 10214 10215val HAS_BOUNDED_SETVARIATION_REFLECT2_EQ_AND_SET_VARIATION_REFLECT2 = store_thm ("HAS_BOUNDED_SETVARIATION_REFLECT2_EQ_AND_SET_VARIATION_REFLECT2", 10216 ``(!f:(real->bool)->real s. 10217 (\k. f(IMAGE (\x. -x) k)) has_bounded_setvariation_on (IMAGE (\x. -x) s) <=> 10218 f has_bounded_setvariation_on s) /\ 10219 (!f:(real->bool)->real s. 10220 set_variation (IMAGE (\x. -x) s) (\k. f(IMAGE (\x. -x) k)) = 10221 set_variation s f)``, 10222 ONCE_REWRITE_TAC [METIS [] ``(IMAGE (\x. -x) s) = (\s. (IMAGE (\x. -x) s)) s:real->bool``] THEN 10223 ONCE_REWRITE_TAC [METIS [] ``(\k. f ((\s. IMAGE (\x. -x) s) k)) = 10224 (\f. (\k. f ((\s. IMAGE (\x. -x) s) k))) f:(real->bool)->real``] THEN 10225 MATCH_MP_TAC SETVARIATION_EQUAL_LEMMA THEN 10226 EXISTS_TAC ``IMAGE ((\x. -x):real->real)`` THEN 10227 SIMP_TAC std_ss [IMAGE_SUBSET, GSYM IMAGE_COMPOSE, o_DEF] THEN 10228 SIMP_TAC std_ss [REAL_NEG_NEG, IMAGE_ID, REFLECT_INTERVAL] THEN 10229 SIMP_TAC std_ss [ETA_AX, DIVISION_OF_REFLECT] THEN 10230 SIMP_TAC std_ss [EQ_INTERVAL, TAUT `~q /\ (p /\ q \/ r) <=> ~q /\ r`] THEN 10231 REWRITE_TAC[TAUT `p /\ q /\ r <=> r /\ q /\ p`] THEN 10232 SIMP_TAC std_ss [UNWIND_THM1, GSYM MONO_NOT_EQ] THEN 10233 SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, REAL_LT_NEG] THEN 10234 METIS_TAC [ETA_AX, DIVISION_OF_REFLECT]); 10235 10236val HAS_BOUNDED_SETVARIATION_REFLECT2_EQ = store_thm ("HAS_BOUNDED_SETVARIATION_REFLECT2_EQ", 10237 ``(!f:(real->bool)->real s. 10238 (\k. f(IMAGE (\x. -x) k)) has_bounded_setvariation_on (IMAGE (\x. -x) s) <=> 10239 f has_bounded_setvariation_on s)``, 10240 REWRITE_TAC [HAS_BOUNDED_SETVARIATION_REFLECT2_EQ_AND_SET_VARIATION_REFLECT2]); 10241 10242val SET_VARIATION_REFLECT2 = store_thm ("SET_VARIATION_REFLECT2", 10243 ``(!f:(real->bool)->real s. 10244 set_variation (IMAGE (\x. -x) s) (\k. f(IMAGE (\x. -x) k)) = 10245 set_variation s f)``, 10246 REWRITE_TAC [HAS_BOUNDED_SETVARIATION_REFLECT2_EQ_AND_SET_VARIATION_REFLECT2]); 10247 10248val HAS_BOUNDED_SETVARIATION_TRANSLATION2_EQ_AND_SET_VARIATION_TRANSLATION2 = store_thm ("HAS_BOUNDED_SETVARIATION_TRANSLATION2_EQ_AND_SET_VARIATION_TRANSLATION2", 10249 ``(!a f:(real->bool)->real s. 10250 (\k. f(IMAGE (\x. a + x) k)) 10251 has_bounded_setvariation_on (IMAGE (\x. -a + x) s) <=> 10252 f has_bounded_setvariation_on s) /\ 10253 (!a f:(real->bool)->real s. 10254 set_variation (IMAGE (\x. -a + x) s) (\k. f(IMAGE (\x. a + x) k)) = 10255 set_variation s f)``, 10256 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN X_GEN_TAC ``a:real`` THEN 10257 SIMP_TAC std_ss [FORALL_AND_THM] THEN 10258 ONCE_REWRITE_TAC [METIS [] ``(IMAGE (\x. -a + x) s) = 10259 (\s. (IMAGE (\x. -a + x) s)) s:real->bool``] THEN 10260 ONCE_REWRITE_TAC [METIS [] ``(\k. f (IMAGE (\x. a + x) k)) = 10261 (\f. ((\k. f (IMAGE (\x. a + x) k)))) (f:(real->bool)->real)``] THEN 10262 MATCH_MP_TAC SETVARIATION_EQUAL_LEMMA THEN 10263 EXISTS_TAC ``\s. IMAGE (\x:real. a + x) s`` THEN 10264 SIMP_TAC std_ss [IMAGE_SUBSET, GSYM IMAGE_COMPOSE, o_DEF] THEN 10265 REWRITE_TAC[REAL_ARITH ``a + -a + x:real = x``, IMAGE_ID, 10266 REAL_ARITH ``-a + a + x:real = x``] THEN 10267 SIMP_TAC std_ss [GSYM INTERVAL_TRANSLATION] THEN 10268 SIMP_TAC std_ss [EQ_INTERVAL, TAUT `~q /\ (p /\ q \/ r) <=> ~q /\ r`] THEN 10269 ONCE_REWRITE_TAC[TAUT `p /\ q /\ r <=> r /\ q /\ p`] THEN 10270 SIMP_TAC std_ss [UNWIND_THM1, GSYM MONO_NOT_EQ] THEN 10271 REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY, REAL_LT_LADD] THEN 10272 REPEAT STRIP_TAC THEN 10273 SIMP_TAC std_ss [REAL_ARITH ``a + (-a + x) = x:real``, IMAGE_ID] THEN 10274 SIMP_TAC std_ss [REAL_ARITH ``-a + (a + x) = x:real``, IMAGE_ID] THEN 10275 (GEN_REWR_TAC (LAND_CONV o LAND_CONV) [ETA_AX] THEN 10276 ASM_SIMP_TAC std_ss [DIVISION_OF_TRANSLATION])); 10277 10278val HAS_BOUNDED_SETVARIATION_TRANSLATION2_EQ = store_thm ("HAS_BOUNDED_SETVARIATION_TRANSLATION2_EQ", 10279 ``(!a f:(real->bool)->real s. 10280 (\k. f(IMAGE (\x. a + x) k)) 10281 has_bounded_setvariation_on (IMAGE (\x. -a + x) s) <=> 10282 f has_bounded_setvariation_on s)``, 10283 REWRITE_TAC [HAS_BOUNDED_SETVARIATION_TRANSLATION2_EQ_AND_SET_VARIATION_TRANSLATION2]); 10284 10285val SET_VARIATION_TRANSLATION2 = store_thm ("SET_VARIATION_TRANSLATION2", 10286 ``(!a f:(real->bool)->real s. 10287 set_variation (IMAGE (\x. -a + x) s) (\k. f(IMAGE (\x. a + x) k)) = 10288 set_variation s f)``, 10289 REWRITE_TAC [HAS_BOUNDED_SETVARIATION_TRANSLATION2_EQ_AND_SET_VARIATION_TRANSLATION2]); 10290 10291val HAS_BOUNDED_SETVARIATION_TRANSLATION = store_thm ("HAS_BOUNDED_SETVARIATION_TRANSLATION", 10292 ``!f:(real->bool)->real s a. 10293 f has_bounded_setvariation_on s 10294 ==> (\k. f(IMAGE (\x. a + x) k)) 10295 has_bounded_setvariation_on (IMAGE (\x. -a + x) s)``, 10296 SIMP_TAC real_ss [HAS_BOUNDED_SETVARIATION_TRANSLATION2_EQ]); 10297 10298(* ------------------------------------------------------------------------- *) 10299(* Absolute integrability (this is the same as Lebesgue integrability). *) 10300(* ------------------------------------------------------------------------- *) 10301 10302val _ = set_fixity "absolutely_integrable_on" (Infix(NONASSOC, 450)); 10303 10304val absolutely_integrable_on = new_definition ("absolutely_integrable_on", 10305 ``f absolutely_integrable_on s <=> 10306 f integrable_on s /\ (\x. abs(f x)) integrable_on s``); 10307 10308val ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE = store_thm ("ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE", 10309 ``!f s. f absolutely_integrable_on s ==> f integrable_on s``, 10310 SIMP_TAC std_ss [absolutely_integrable_on]); 10311 10312val ABSOLUTELY_INTEGRABLE_IMP_ABS_INTEGRABLE = store_thm ("ABSOLUTELY_INTEGRABLE_IMP_ABS_INTEGRABLE", 10313 ``!f:real->real s. 10314 f absolutely_integrable_on s ==> (\x. abs (f x)) integrable_on s``, 10315 REWRITE_TAC[absolutely_integrable_on] THEN MESON_TAC[]); 10316 10317val ABSOLUTELY_INTEGRABLE_LE = store_thm ("ABSOLUTELY_INTEGRABLE_LE", 10318 ``!f:real->real s. 10319 f absolutely_integrable_on s 10320 ==> abs(integral s f) <= (integral s (\x. abs(f x)))``, 10321 REWRITE_TAC[absolutely_integrable_on] THEN 10322 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 10323 ASM_SIMP_TAC std_ss [REAL_LE_REFL]); 10324 10325val ABSOLUTELY_INTEGRABLE_ON_NULL = store_thm ("ABSOLUTELY_INTEGRABLE_ON_NULL", 10326 ``!f a b. (content(interval[a,b]) = &0) 10327 ==> f absolutely_integrable_on interval[a,b]``, 10328 SIMP_TAC std_ss [absolutely_integrable_on, INTEGRABLE_ON_NULL]); 10329 10330val ABSOLUTELY_INTEGRABLE_0 = store_thm ("ABSOLUTELY_INTEGRABLE_0", 10331 ``!s. (\x. 0) absolutely_integrable_on s``, 10332 REWRITE_TAC[absolutely_integrable_on, ABS_0, INTEGRABLE_0]); 10333 10334val ABSOLUTELY_INTEGRABLE_CMUL = store_thm ("ABSOLUTELY_INTEGRABLE_CMUL", 10335 ``!f s c. f absolutely_integrable_on s 10336 ==> (\x. c * f(x)) absolutely_integrable_on s``, 10337 SIMP_TAC std_ss [absolutely_integrable_on, INTEGRABLE_CMUL, ABS_MUL]); 10338 10339val ABSOLUTELY_INTEGRABLE_NEG = store_thm ("ABSOLUTELY_INTEGRABLE_NEG", 10340 ``!f s. f absolutely_integrable_on s 10341 ==> (\x. -f(x)) absolutely_integrable_on s``, 10342 SIMP_TAC std_ss [absolutely_integrable_on, INTEGRABLE_NEG, ABS_NEG]); 10343 10344val ABSOLUTELY_INTEGRABLE_ABS = store_thm ("ABSOLUTELY_INTEGRABLE_ABS", 10345 ``!f s. f absolutely_integrable_on s 10346 ==> (\x. abs(f x)) absolutely_integrable_on s``, 10347 SIMP_TAC std_ss [absolutely_integrable_on, ABS_ABS]); 10348 10349val ABSOLUTELY_INTEGRABLE_ON_SUBINTERVAL = store_thm ("ABSOLUTELY_INTEGRABLE_ON_SUBINTERVAL", 10350 ``!f:real->real s a b. 10351 f absolutely_integrable_on s /\ interval[a,b] SUBSET s 10352 ==> f absolutely_integrable_on interval[a,b]``, 10353 REWRITE_TAC[absolutely_integrable_on] THEN 10354 MESON_TAC[INTEGRABLE_ON_SUBINTERVAL]); 10355 10356val ABSOLUTELY_INTEGRABLE_SPIKE = store_thm ("ABSOLUTELY_INTEGRABLE_SPIKE", 10357 ``!f:real->real g s t. 10358 negligible s /\ (!x. x IN t DIFF s ==> (g x = f x)) 10359 ==> f absolutely_integrable_on t ==> g absolutely_integrable_on t``, 10360 REPEAT GEN_TAC THEN STRIP_TAC THEN 10361 REWRITE_TAC[absolutely_integrable_on] THEN MATCH_MP_TAC MONO_AND THEN 10362 CONJ_TAC THEN MATCH_MP_TAC INTEGRABLE_SPIKE THEN 10363 EXISTS_TAC ``s:real->bool`` THEN ASM_SIMP_TAC std_ss []); 10364 10365val ABSOLUTELY_INTEGRABLE_RESTRICT_INTER = store_thm ("ABSOLUTELY_INTEGRABLE_RESTRICT_INTER", 10366 ``!f:real->real s t. 10367 (\x. if x IN s then f x else 0) absolutely_integrable_on t <=> 10368 f absolutely_integrable_on (s INTER t)``, 10369 SIMP_TAC std_ss [absolutely_integrable_on, GSYM INTEGRABLE_RESTRICT_INTER] THEN 10370 SIMP_TAC std_ss [COND_RAND, ABS_0]); 10371 10372val ABSOLUTELY_INTEGRABLE_EQ = store_thm ("ABSOLUTELY_INTEGRABLE_EQ", 10373 ``!f:real->real g s. 10374 (!x. x IN s ==> (f x = g x)) /\ f absolutely_integrable_on s 10375 ==> g absolutely_integrable_on s``, 10376 REWRITE_TAC[absolutely_integrable_on] THEN REPEAT STRIP_TAC THEN 10377 MATCH_MP_TAC INTEGRABLE_EQ THENL 10378 [EXISTS_TAC ``f:real->real``, 10379 EXISTS_TAC ``\x. abs((f:real->real) x)``] THEN 10380 ASM_SIMP_TAC std_ss []); 10381 10382val ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION = store_thm ("ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION", 10383 ``!f:real->real s. 10384 f absolutely_integrable_on s 10385 ==> (\k. integral k f) has_bounded_setvariation_on s``, 10386 REWRITE_TAC[has_bounded_setvariation_on] THEN REPEAT STRIP_TAC THEN 10387 EXISTS_TAC 10388 ``integral (s:real->bool) (\x. abs(f x:real))`` THEN 10389 X_GEN_TAC ``d:(real->bool)->bool`` THEN 10390 X_GEN_TAC ``t:real->bool`` THEN STRIP_TAC THEN 10391 SUBGOAL_THEN ``(BIGUNION d:real->bool) SUBSET s`` ASSUME_TAC THENL 10392 [METIS_TAC[SUBSET_TRANS, division_of], ALL_TAC] THEN 10393 MATCH_MP_TAC REAL_LE_TRANS THEN 10394 EXISTS_TAC 10395 ``integral (BIGUNION d) (\x. abs((f:real->real) x))`` THEN 10396 CONJ_TAC THENL 10397 [ALL_TAC, 10398 MATCH_MP_TAC INTEGRAL_SUBSET_DROP_LE THEN 10399 ASM_SIMP_TAC real_ss [ABS_POS] THEN CONJ_TAC THENL 10400 [MATCH_MP_TAC INTEGRABLE_ON_SUBDIVISION THEN 10401 EXISTS_TAC ``s:real->bool`` THEN 10402 EXISTS_TAC ``d:(real->bool)->bool`` THEN CONJ_TAC THENL 10403 [ASM_MESON_TAC[DIVISION_OF_SUBSET, division_of], ALL_TAC] THEN 10404 ASM_SIMP_TAC std_ss [], 10405 ALL_TAC] THEN 10406 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN 10407 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_ABS THEN ASM_REWRITE_TAC[]] THEN 10408 MATCH_MP_TAC REAL_LE_TRANS THEN 10409 EXISTS_TAC 10410 ``sum d (\i. integral i (\x:real. abs(f x:real)))`` THEN 10411 CONJ_TAC THENL 10412 [FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 10413 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC SUM_LE THEN 10414 ASM_REWRITE_TAC[o_THM] THEN 10415 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 10416 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN DISCH_TAC THEN 10417 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_LE THEN 10418 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_ON_SUBINTERVAL THEN 10419 EXISTS_TAC ``s:real->bool`` THEN METIS_TAC[division_of, SUBSET_TRANS], 10420 MATCH_MP_TAC REAL_EQ_IMP_LE THEN 10421 CONV_TAC SYM_CONV THEN MATCH_MP_TAC INTEGRAL_COMBINE_DIVISION_TOPDOWN THEN 10422 CONJ_TAC THENL [ALL_TAC, ASM_MESON_TAC[DIVISION_OF_UNION_SELF]] THEN 10423 MATCH_MP_TAC INTEGRABLE_ON_SUBDIVISION THEN 10424 MAP_EVERY EXISTS_TAC [``s:real->bool``, ``d:(real->bool)->bool``] THEN 10425 CONJ_TAC THENL [ASM_MESON_TAC[DIVISION_OF_UNION_SELF], ALL_TAC] THEN 10426 ASM_REWRITE_TAC[] THEN 10427 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN 10428 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_ABS THEN ASM_SIMP_TAC real_ss []]); 10429 10430val lemma = prove ( 10431 ``!f:'a->real g s e. 10432 sum s (\x. abs(f x - g x)) < e 10433 ==> FINITE s 10434 ==> abs(sum s (\x. abs(f x)) - sum s (\x. abs(g x))) < e``, 10435 REPEAT GEN_TAC THEN SIMP_TAC std_ss [GSYM SUM_SUB] THEN 10436 DISCH_THEN(fn th => DISCH_TAC THEN MP_TAC th) THEN 10437 MATCH_MP_TAC(REAL_ARITH ``x <= y ==> y < e ==> x < e:real``) THEN 10438 W(MP_TAC o PART_MATCH (lhand o rand) SUM_ABS o lhand o snd) THEN 10439 ASM_SIMP_TAC std_ss [] THEN 10440 MATCH_MP_TAC(REAL_ARITH ``y <= z ==> x <= y ==> x <= z:real``) THEN 10441 MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [] THEN 10442 REPEAT STRIP_TAC THEN REAL_ARITH_TAC); 10443 10444Theorem BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE_INTERVAL : 10445 !f:real->real a b. 10446 f integrable_on interval[a,b] /\ 10447 (\k. integral k f) has_bounded_setvariation_on interval[a,b] 10448 ==> f absolutely_integrable_on interval[a,b] 10449Proof 10450 REWRITE_TAC[HAS_BOUNDED_SETVARIATION_ON_INTERVAL] THEN 10451 REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[absolutely_integrable_on] THEN 10452 MP_TAC(ISPEC ``IMAGE (\d. sum d (\k. abs(integral k (f:real->real)))) 10453 {d | d division_of interval[a,b] }`` 10454 SUP) THEN 10455 SIMP_TAC std_ss [FORALL_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 10456 SIMP_TAC std_ss [GSYM MEMBER_NOT_EMPTY, GSPECIFICATION] THEN 10457 ABBREV_TAC 10458 ``i = sup (IMAGE (\d. sum d (\k. abs(integral k (f:real->real)))) 10459 {d | d division_of interval[a,b] })`` THEN 10460 KNOW_TAC ``(?(x :(real -> bool) -> bool). 10461 x division_of interval [((a :real),(b :real))]) /\ 10462 (?(b' :real). !(d :(real -> bool) -> bool). 10463 d division_of interval [(a,b)] ==> 10464 sum d (\(k :real -> bool). abs (integral k (f :real -> real))) <= 10465 b')`` THENL 10466 [REWRITE_TAC[ELEMENTARY_INTERVAL] THEN ASM_MESON_TAC[], 10467 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 10468 STRIP_TAC THEN REWRITE_TAC[integrable_on] THEN EXISTS_TAC ``i:real`` THEN 10469 REWRITE_TAC[has_integral] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 10470 FIRST_X_ASSUM(MP_TAC o SPEC ``i - e / &2:real``) THEN 10471 ASM_SIMP_TAC std_ss [REAL_ARITH 10472 ``&0 < e / &2 ==> ~(i <= i - e / &2:real)``, REAL_HALF] THEN 10473 SIMP_TAC std_ss [NOT_FORALL_THM, NOT_IMP, REAL_NOT_LE, LEFT_IMP_EXISTS_THM] THEN 10474 X_GEN_TAC ``d:(real->bool)->bool`` THEN STRIP_TAC THEN 10475 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 10476 SUBGOAL_THEN 10477 ``!x. ?e. &0 < e /\ 10478 !i. i IN d /\ ~(x IN i) ==> (ball(x:real,e) INTER i = {})`` 10479 MP_TAC THENL 10480 [X_GEN_TAC ``x:real`` THEN MP_TAC(ISPECL 10481 [``BIGUNION {i:real->bool | i IN d /\ ~(x IN i)}``, ``x:real``] 10482 SEPARATE_POINT_CLOSED) THEN 10483 KNOW_TAC ``(closed 10484 (BIGUNION 10485 {i | i IN (d :(real -> bool) -> bool) /\ (x :real) NOTIN i}) : 10486 bool) /\ x NOTIN BIGUNION {i | i IN d /\ x NOTIN i}`` THENL 10487 [CONJ_TAC THENL [ALL_TAC, SET_TAC[]] THEN 10488 MATCH_MP_TAC CLOSED_BIGUNION THEN 10489 ASM_SIMP_TAC std_ss [FINITE_RESTRICT, GSPECIFICATION, IMP_CONJ] THEN 10490 FIRST_ASSUM(fn t => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION t]) THEN 10491 REWRITE_TAC[CLOSED_INTERVAL], 10492 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 10493 DISCH_THEN (X_CHOOSE_TAC ``k:real``) THEN EXISTS_TAC ``k:real`` THEN 10494 POP_ASSUM MP_TAC THEN 10495 SIMP_TAC std_ss [FORALL_IN_BIGUNION, EXTENSION, IN_INTER, NOT_IN_EMPTY, IN_BALL] THEN 10496 SIMP_TAC std_ss [GSPECIFICATION, DE_MORGAN_THM, REAL_NOT_LT] THEN MESON_TAC[], 10497 ALL_TAC] THEN 10498 SIMP_TAC std_ss [SKOLEM_THM, LEFT_IMP_EXISTS_THM, FORALL_AND_THM] THEN 10499 X_GEN_TAC ``k:real->real`` THEN STRIP_TAC THEN 10500 FIRST_ASSUM(MP_TAC o SPEC ``e / &2:real`` o MATCH_MP HENSTOCK_LEMMA) THEN 10501 ASM_REWRITE_TAC[REAL_HALF] THEN 10502 DISCH_THEN(X_CHOOSE_THEN ``g:real->real->bool`` STRIP_ASSUME_TAC) THEN 10503 EXISTS_TAC ``\x:real. g(x) INTER ball(x,k x)`` THEN CONJ_TAC THENL 10504 [ONCE_REWRITE_TAC [METIS [] ``(\x. g x INTER ball (x,k x)) = 10505 (\x. g x INTER (\x. ball (x,k x)) x)``] THEN 10506 MATCH_MP_TAC GAUGE_INTER THEN ASM_REWRITE_TAC[] THEN 10507 ASM_SIMP_TAC std_ss [gauge_def, CENTRE_IN_BALL, OPEN_BALL], 10508 ALL_TAC] THEN 10509 ONCE_REWRITE_TAC [METIS [] ``(\x. g x INTER ball (x,k x)) = 10510 (\x. g x INTER (\x. ball (x,k x)) x)``] THEN 10511 REWRITE_TAC[FINE_INTER] THEN X_GEN_TAC ``p:(real#(real->bool))->bool`` THEN 10512 STRIP_TAC THEN 10513 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 10514 ABBREV_TAC 10515 ``p' = {(x:real,k:real->bool) | 10516 ?i l. x IN i /\ i IN d /\ (x,l) IN p /\ (k = i INTER l)}`` THEN 10517 SUBGOAL_THEN ``g FINE (p':(real#(real->bool))->bool)`` ASSUME_TAC THENL 10518 [EXPAND_TAC "p'" THEN 10519 MP_TAC(ASSUME ``g FINE (p:(real#(real->bool))->bool)``) THEN 10520 SIMP_TAC std_ss [FINE, IN_ELIM_PAIR_THM] THEN 10521 MESON_TAC[SET_RULE ``k SUBSET l ==> (i INTER k) SUBSET l``], 10522 ALL_TAC] THEN 10523 SUBGOAL_THEN ``p' tagged_division_of interval[a:real,b]`` ASSUME_TAC THENL 10524 [ (* goal 1 (of 2) *) 10525 REWRITE_TAC[TAGGED_DIVISION_OF] THEN EXPAND_TAC "p'" THEN 10526 SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN 10527 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 10528 FIRST_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 10529 MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 10530 [DISCH_TAC THEN MATCH_MP_TAC FINITE_SUBSET THEN 10531 EXISTS_TAC 10532 ``IMAGE (\(k,(x,l)). x,k INTER l) 10533 {k,xl | k IN (d:(real->bool)->bool) /\ 10534 xl IN (p:(real#(real->bool))->bool)}`` THEN 10535 ASM_SIMP_TAC std_ss [IMAGE_FINITE, FINITE_PRODUCT] THEN 10536 EXPAND_TAC "p'" THEN SIMP_TAC std_ss [SUBSET_DEF, FORALL_PROD] THEN 10537 SIMP_TAC std_ss [IN_ELIM_PAIR_THM, IN_IMAGE, EXISTS_PROD, PAIR_EQ] THEN 10538 MESON_TAC[], 10539 ALL_TAC] THEN 10540 MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 10541 [DISCH_TAC THEN MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN 10542 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 10543 MAP_EVERY X_GEN_TAC [``i:real->bool``, ``l:real->bool``] THEN 10544 STRIP_TAC THEN FIRST_X_ASSUM SUBST_ALL_TAC THEN 10545 ASM_SIMP_TAC std_ss [IN_INTER] THEN CONJ_TAC THENL 10546 [MATCH_MP_TAC(SET_RULE ``l SUBSET s ==> (k INTER l) SUBSET s``) THEN 10547 ASM_MESON_TAC[], 10548 ALL_TAC] THEN 10549 FIRST_X_ASSUM(MP_TAC o SPECL [``x:real``, ``l:real->bool``]) THEN 10550 ASM_SIMP_TAC std_ss [] THEN STRIP_TAC THEN ASM_SIMP_TAC std_ss [] THEN 10551 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 10552 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 10553 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 10554 DISCH_THEN (CONJUNCTS_THEN2 (MP_TAC o SPEC ``i:real->bool``) ASSUME_TAC) THEN 10555 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN 10556 ASM_REWRITE_TAC[INTER_INTERVAL] THEN MESON_TAC[], 10557 ALL_TAC] THEN 10558 MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 10559 [DISCH_TAC THEN MAP_EVERY X_GEN_TAC 10560 [``x1:real``, ``k1:real->bool``, ``x2:real``, ``k2:real->bool``] THEN 10561 DISCH_THEN(CONJUNCTS_THEN2 10562 (X_CHOOSE_THEN ``i1:real->bool`` (X_CHOOSE_THEN ``l1:real->bool`` 10563 STRIP_ASSUME_TAC)) MP_TAC) THEN 10564 ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 10565 DISCH_THEN(CONJUNCTS_THEN2 10566 (X_CHOOSE_THEN ``i2:real->bool`` (X_CHOOSE_THEN ``l2:real->bool`` 10567 STRIP_ASSUME_TAC)) ASSUME_TAC) THEN 10568 ASM_REWRITE_TAC [] THEN 10569 RULE_ASSUM_TAC (REWRITE_RULE [GSYM DE_MORGAN_THM, GSYM PAIR_EQ]) THEN 10570 MATCH_MP_TAC(SET_RULE 10571 ``((interior(i1) INTER interior(i2) = {}) \/ 10572 (interior(l1) INTER interior(l2) = {})) /\ 10573 interior(i1 INTER l1) SUBSET interior(i1) /\ 10574 interior(i2 INTER l2) SUBSET interior(i2) /\ 10575 interior(i1 INTER l1) SUBSET interior(l1) /\ 10576 interior(i2 INTER l2) SUBSET interior(l2) 10577 ==> (interior(i1 INTER l1) INTER interior(i2 INTER l2) = {})``) THEN 10578 SIMP_TAC std_ss [SUBSET_INTERIOR, INTER_SUBSET] THEN 10579 FIRST_X_ASSUM(MP_TAC o SPECL 10580 [``x1:real``, ``l1:real->bool``, ``x2:real``, ``l2:real->bool``]) THEN 10581 ASM_SIMP_TAC std_ss [] THEN 10582 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 10583 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 10584 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 10585 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 10586 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 10587 DISCH_THEN(MP_TAC o SPECL [``i1:real->bool``, ``i2:real->bool``]) THEN 10588 ASM_REWRITE_TAC[] THEN 10589 UNDISCH_TAC ``((x1 :real),(i1 :real -> bool) INTER (l1 :real -> bool)) <> 10590 ((x2 :real),(k2 :real -> bool))`` THEN 10591 ASM_REWRITE_TAC[PAIR_EQ] THEN MESON_TAC[], 10592 ALL_TAC] THEN 10593 DISCH_TAC THEN MATCH_MP_TAC SUBSET_ANTISYM THEN CONJ_TAC THENL 10594 [SIMP_TAC std_ss [BIGUNION_SUBSET, GSPECIFICATION] THEN 10595 REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 10596 MATCH_MP_TAC(SET_RULE ``i SUBSET s ==> (i INTER k) SUBSET s``) THEN 10597 ASM_MESON_TAC[division_of], 10598 ALL_TAC] THEN 10599 REWRITE_TAC[SUBSET_DEF] THEN X_GEN_TAC ``y:real`` THEN DISCH_TAC THEN 10600 SIMP_TAC std_ss [IN_BIGUNION, GSPECIFICATION] THEN 10601 SIMP_TAC std_ss [GSYM LEFT_EXISTS_AND_THM, GSYM CONJ_ASSOC] THEN 10602 KNOW_TAC ``?(l :real -> bool) (x :real) (i :real -> bool) (s :real -> bool). 10603 (s = i INTER l) /\ x IN i /\ i IN (d :(real -> bool) -> bool) /\ 10604 (x,l) IN (p :real # (real -> bool) -> bool) /\ (y :real) IN (i INTER l)`` THENL 10605 [ALL_TAC, METIS_TAC []] THEN 10606 SIMP_TAC std_ss [IN_INTER, UNWIND_THM2] THEN 10607 UNDISCH_TAC ``BIGUNION {k | ?x. (x:real,k) IN p} = interval [(a,b)]`` THEN 10608 DISCH_TAC THEN 10609 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [EXTENSION]) THEN 10610 DISCH_THEN(MP_TAC o SPEC ``y:real``) THEN ASM_REWRITE_TAC[] THEN 10611 SIMP_TAC std_ss [IN_BIGUNION, GSPECIFICATION, GSYM RIGHT_EXISTS_AND_THM] THEN 10612 DISCH_THEN (X_CHOOSE_THEN ``l:real->bool`` (X_CHOOSE_TAC ``x:real``)) THEN 10613 EXISTS_TAC ``l:real->bool`` THEN EXISTS_TAC ``x:real`` THEN POP_ASSUM MP_TAC THEN 10614 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 10615 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 10616 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 10617 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 10618 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 10619 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 10620 REWRITE_TAC[EXTENSION] THEN DISCH_THEN(MP_TAC o SPEC ``y:real``) THEN 10621 ASM_REWRITE_TAC[IN_BIGUNION] THEN 10622 DISCH_THEN (X_CHOOSE_TAC ``k:real->bool``) THEN EXISTS_TAC ``k:real->bool`` THEN 10623 POP_ASSUM MP_TAC THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 10624 FIRST_X_ASSUM(MP_TAC o SPECL [``x:real``, ``k:real->bool``]) THEN 10625 GEN_REWR_TAC LAND_CONV [MONO_NOT_EQ] THEN 10626 ASM_REWRITE_TAC[] THEN DISCH_THEN MATCH_MP_TAC THEN 10627 REWRITE_TAC[GSYM MEMBER_NOT_EMPTY] THEN 10628 EXISTS_TAC ``y:real`` THEN ASM_SIMP_TAC std_ss [INTER_DEF, GSPECIFICATION] THEN 10629 UNDISCH_TAC ``(\x:real. ball (x,k x)) FINE p`` THEN 10630 REWRITE_TAC[FINE, SUBSET_DEF] THEN ASM_MESON_TAC[], 10631 ALL_TAC] THEN 10632 FIRST_X_ASSUM(MP_TAC o SPEC ``p':(real#(real->bool))->bool``) THEN 10633 ASM_REWRITE_TAC[] THEN 10634 KNOW_TAC ``p' tagged_partial_division_of interval [(a,b)]`` THENL 10635 [ASM_MESON_TAC[tagged_division_of], 10636 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 10637 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 10638 SIMP_TAC std_ss [LAMBDA_PAIR] THEN 10639 ONCE_REWRITE_TAC [METIS [] 10640 ``(\p. abs (content (SND p) * f (FST p) - integral (SND p) f)) = 10641 (\p. abs ((\p. content (SND p) * f (FST p)) p - (\p. integral (SND p) f) p))``] THEN 10642 DISCH_THEN(MP_TAC o MATCH_MP lemma) THEN 10643 ASM_SIMP_TAC std_ss [o_DEF, SUM_SUB] THEN 10644 SIMP_TAC std_ss [LAMBDA_PROD, ABS_MUL] THEN 10645 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 10646 MATCH_MP_TAC(REAL_ARITH 10647 ``!sni. i - e / &2 < sni /\ 10648 sni' <= i /\ sni <= sni' /\ (sf' = sf) 10649 ==> abs(sf' - sni') < e / &2 10650 ==> abs(sf - i) < e / 2 + e / 2:real``) THEN 10651 EXISTS_TAC ``sum d (\k. abs (integral k (f:real->real)))`` THEN 10652 ASM_REWRITE_TAC[] THEN CONJ_TAC THENL 10653 [MP_TAC(ISPECL [``\k. abs(integral k (f:real->real))``, 10654 ``p':(real#(real->bool))->bool``, 10655 ``interval[a:real,b]``] SUM_OVER_TAGGED_DIVISION_LEMMA) THEN 10656 ASM_SIMP_TAC std_ss [INTEGRAL_NULL, ABS_0] THEN DISCH_THEN SUBST1_TAC THEN 10657 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_MESON_TAC[DIVISION_OF_TAGGED_DIVISION], 10658 ALL_TAC] THEN 10659 SUBGOAL_THEN 10660 ``p' = {x:real,(i INTER l:real->bool) | 10661 (x,l) IN p /\ i IN d /\ ~(i INTER l = {})}`` 10662 (ASSUME_TAC) THENL 10663 [ EXPAND_TAC "p'" THEN GEN_REWR_TAC I [EXTENSION] THEN 10664 SIMP_TAC std_ss [FORALL_PROD, IN_ELIM_PAIR_THM] THEN 10665 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 10666 MAP_EVERY X_GEN_TAC [``x:real``, ``k':real->bool``] THEN 10667 SIMP_TAC std_ss [PAIR_EQ, GSYM CONJ_ASSOC] THEN 10668 AP_TERM_TAC THEN GEN_REWR_TAC I [FUN_EQ_THM] THEN 10669 X_GEN_TAC ``i':real->bool`` THEN SIMP_TAC std_ss [] THEN 10670 GEN_REWR_TAC (RAND_CONV o ONCE_DEPTH_CONV) 10671 [TAUT `A /\ B /\ C /\ D <=> B /\ C /\ D /\ A`] THEN 10672 AP_TERM_TAC THEN GEN_REWR_TAC I [FUN_EQ_THM] THEN 10673 X_GEN_TAC ``l:real->bool`` THEN SIMP_TAC std_ss [] THEN 10674 ASM_CASES_TAC ``k':real->bool = i' INTER l`` THEN ASM_SIMP_TAC real_ss [] THEN 10675 ASM_SIMP_TAC std_ss [IN_INTER, GSYM MEMBER_NOT_EMPTY] THEN 10676 EQ_TAC THENL [METIS_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 10677 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 10678 DISCH_THEN(X_CHOOSE_THEN ``y:real`` STRIP_ASSUME_TAC) THEN 10679 ASM_REWRITE_TAC[] THEN 10680 FIRST_X_ASSUM(MP_TAC o SPECL [``x:real``, ``i':real->bool``]) THEN 10681 GEN_REWR_TAC LAND_CONV [MONO_NOT_EQ] THEN 10682 ASM_REWRITE_TAC[] THEN DISCH_THEN MATCH_MP_TAC THEN 10683 REWRITE_TAC[GSYM MEMBER_NOT_EMPTY] THEN 10684 EXISTS_TAC ``y:real`` THEN ASM_SIMP_TAC std_ss [INTER_DEF, GSPECIFICATION] THEN 10685 UNDISCH_TAC ``(\x:real. ball (x,k x)) FINE p`` THEN 10686 REWRITE_TAC[FINE, SUBSET_DEF] THEN ASM_MESON_TAC[], 10687 ALL_TAC] THEN 10688 CONJ_TAC THENL 10689 [MP_TAC(ISPECL 10690 [``\y. abs(integral y (f:real->real))``, 10691 ``p':(real#(real->bool))->bool``, 10692 ``interval[a:real,b]``] 10693 SUM_OVER_TAGGED_DIVISION_LEMMA) THEN 10694 ASM_SIMP_TAC std_ss [INTEGRAL_NULL, ABS_0] THEN DISCH_THEN SUBST1_TAC THEN 10695 MATCH_MP_TAC REAL_LE_TRANS THEN 10696 EXISTS_TAC ``sum {i INTER l | i IN d /\ 10697 (l IN IMAGE SND (p:(real#(real->bool))->bool))} 10698 (\k. abs(integral k (f:real->real)))`` THEN 10699 CONJ_TAC THENL 10700 [ALL_TAC, 10701 MATCH_MP_TAC REAL_EQ_IMP_LE THEN MATCH_MP_TAC SUM_SUPERSET THEN 10702 CONJ_TAC THENL 10703 [SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_IMAGE] THEN 10704 SIMP_TAC std_ss [FORALL_PROD] THEN 10705 SIMP_TAC std_ss [GSPECIFICATION, IN_IMAGE, PAIR_EQ, EXISTS_PROD] THEN 10706 MESON_TAC[], 10707 ALL_TAC] THEN 10708 SIMP_TAC std_ss [GSPECIFICATION, GSYM LEFT_EXISTS_AND_THM, LEFT_IMP_EXISTS_THM, 10709 EXISTS_PROD] THEN MAP_EVERY X_GEN_TAC [``i:real->bool``, ``l:real->bool``] THEN 10710 SIMP_TAC std_ss [IN_IMAGE, EXISTS_PROD, UNWIND_THM1] THEN 10711 DISCH_THEN(CONJUNCTS_THEN2 10712 (CONJUNCTS_THEN2 ASSUME_TAC (X_CHOOSE_TAC ``x:real``)) MP_TAC) THEN 10713 SIMP_TAC std_ss [GSPECIFICATION, PAIR_EQ, NOT_EXISTS_THM, EXISTS_PROD] THEN 10714 DISCH_THEN(MP_TAC o SPECL 10715 [``x:real``, ``i:real->bool``, ``l:real->bool``]) THEN 10716 ASM_SIMP_TAC std_ss [INTEGRAL_EMPTY, ABS_0]] THEN 10717 SUBGOAL_THEN 10718 ``{k INTER l | k IN d /\ l IN IMAGE SND (p:(real#(real->bool))->bool)} = 10719 IMAGE (\(k,l). k INTER l) {k,l | k IN d /\ l IN IMAGE SND p}`` 10720 SUBST1_TAC THENL 10721 [GEN_REWR_TAC I [EXTENSION] THEN 10722 SIMP_TAC std_ss [GSPECIFICATION, IN_IMAGE, EXISTS_PROD, FORALL_PROD], 10723 ALL_TAC] THEN 10724 W(MP_TAC o PART_MATCH (lhand o rand) SUM_IMAGE_NONZERO o rand o snd) THEN 10725 KNOW_TAC ``FINITE 10726 {(k,l) | 10727 k IN (d :(real -> bool) -> bool) /\ 10728 l IN IMAGE (SND :real # (real -> bool) -> real -> bool) 10729 (p :real # (real -> bool) -> bool)} /\ (!(x :(real -> bool) # (real -> bool)) 10730 (y :(real -> bool) # (real -> bool)). x IN {(k,l) | k IN d /\ 10731 l IN IMAGE (SND :real # (real -> bool) -> real -> bool) p} /\ 10732 y IN {(k,l) | k IN d /\ 10733 l IN IMAGE (SND :real # (real -> bool) -> real -> bool) p} /\ x <> y /\ 10734 ((\((k :real -> bool),(l :real -> bool)). k INTER l) x = 10735 (\((k :real -> bool),(l :real -> bool)). k INTER l) y) ==> 10736 ((\(k :real -> bool). abs (integral k (f :real -> real))) 10737 ((\((k :real -> bool),(l :real -> bool)). k INTER l) x) = (0 : real)))`` THENL 10738 [ASSUME_TAC(MATCH_MP DIVISION_OF_TAGGED_DIVISION 10739 (ASSUME ``p tagged_division_of interval[a:real,b]``)) THEN 10740 ASM_SIMP_TAC std_ss [FINITE_PRODUCT, IMAGE_FINITE] THEN 10741 SIMP_TAC std_ss [FORALL_PROD, IN_ELIM_PAIR_THM] THEN 10742 MAP_EVERY X_GEN_TAC 10743 [``l1:real->bool``, ``k1:real->bool``, 10744 ``l2:real->bool``, ``k2:real->bool``] THEN 10745 REWRITE_TAC [GSYM DE_MORGAN_THM] THEN STRIP_TAC THEN 10746 SUBGOAL_THEN ``interior(l2 INTER k2:real->bool) = {}`` MP_TAC THENL 10747 [ALL_TAC, 10748 MP_TAC(ASSUME ``d division_of interval[a:real,b]``) THEN 10749 REWRITE_TAC[division_of] THEN 10750 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10751 DISCH_THEN (CONJUNCTS_THEN2 (MP_TAC o SPEC ``l2:real->bool``) K_TAC) THEN 10752 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 10753 MP_TAC(ASSUME 10754 ``(IMAGE SND (p:(real#(real->bool))->bool)) 10755 division_of interval[a:real,b]``) THEN 10756 REWRITE_TAC[division_of] THEN 10757 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10758 DISCH_THEN (CONJUNCTS_THEN2 (MP_TAC o SPEC ``k2:real->bool``) K_TAC) THEN 10759 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN 10760 ASM_REWRITE_TAC[INTER_INTERVAL] THEN DISCH_TAC THEN 10761 REWRITE_TAC[ABS_ZERO] THEN 10762 MATCH_MP_TAC INTEGRAL_NULL THEN 10763 ASM_REWRITE_TAC[CONTENT_EQ_0_INTERIOR]] THEN 10764 MATCH_MP_TAC(SET_RULE 10765 ``((interior(k1) INTER interior(k2) = {}) \/ 10766 (interior(l1) INTER interior(l2) = {})) /\ 10767 interior(l1 INTER k1) SUBSET interior(k1) /\ 10768 interior(l2 INTER k2) SUBSET interior(k2) /\ 10769 interior(l1 INTER k1) SUBSET interior(l1) /\ 10770 interior(l2 INTER k2) SUBSET interior(l2) /\ 10771 (interior(l1 INTER k1) = interior(l2 INTER k2)) 10772 ==> (interior(l2 INTER k2) = {})``) THEN 10773 SIMP_TAC std_ss [SUBSET_INTERIOR, INTER_SUBSET] THEN ASM_REWRITE_TAC[] THEN 10774 MP_TAC(ASSUME ``d division_of interval[a:real,b]``) THEN 10775 REWRITE_TAC[division_of] THEN 10776 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10777 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10778 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 10779 DISCH_THEN(MP_TAC o SPECL [``l1:real->bool``, ``l2:real->bool``]) THEN 10780 ASM_REWRITE_TAC[] THEN 10781 MP_TAC(ASSUME 10782 ``(IMAGE SND (p:(real#(real->bool))->bool)) 10783 division_of interval[a:real,b]``) THEN 10784 REWRITE_TAC[division_of] THEN 10785 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10786 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10787 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 10788 DISCH_THEN(MP_TAC o SPECL [``k1:real->bool``, ``k2:real->bool``]) THEN 10789 ASM_REWRITE_TAC[] THEN ASM_MESON_TAC[], 10790 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 10791 DISCH_THEN SUBST1_TAC THEN 10792 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [GSYM ETA_AX] THEN 10793 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [LAMBDA_PROD] THEN 10794 ASM_SIMP_TAC std_ss [GSYM SUM_SUM_PRODUCT, IMAGE_FINITE] THEN 10795 MATCH_MP_TAC SUM_LE THEN ASM_REWRITE_TAC[] THEN 10796 X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN REWRITE_TAC[o_DEF] THEN 10797 MATCH_MP_TAC REAL_LE_TRANS THEN 10798 EXISTS_TAC 10799 ``sum { k INTER l | 10800 l IN IMAGE SND (p:(real#(real->bool))->bool)} 10801 (\k. abs(integral k (f:real->real)))`` THEN 10802 CONJ_TAC THENL 10803 [ALL_TAC, 10804 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 10805 W(MP_TAC o PART_MATCH (lhs o rand) SUM_IMAGE_NONZERO o lhand o snd) THEN 10806 KNOW_TAC ``FINITE (IMAGE (SND :real # (real -> bool) -> real -> bool) 10807 (p :real # (real -> bool) -> bool)) /\ 10808 (!(x :real -> bool) (y :real -> bool). 10809 x IN IMAGE (SND :real # (real -> bool) -> real -> bool) p /\ 10810 y IN IMAGE (SND :real # (real -> bool) -> real -> bool) p /\ x <> y /\ 10811 ((\(l :real -> bool). (k :real -> bool) INTER l) x = 10812 (\(l :real -> bool). k INTER l) y) ==> 10813 ((\(k :real -> bool). abs (integral k (f :real -> real))) 10814 ((\(l :real -> bool). k INTER l) x) = (0 : real)))`` THENL 10815 [ALL_TAC, DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 10816 SIMP_TAC std_ss [o_DEF, REAL_LE_REFL]] THEN 10817 ASM_SIMP_TAC std_ss [IMAGE_FINITE] THEN 10818 MAP_EVERY X_GEN_TAC [``k1:real->bool``, ``k2:real->bool``] THEN 10819 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 10820 SUBGOAL_THEN ``interior(k INTER k2:real->bool) = {}`` MP_TAC THENL 10821 [ALL_TAC, 10822 MP_TAC(MATCH_MP DIVISION_OF_TAGGED_DIVISION 10823 (ASSUME ``p tagged_division_of interval[a:real,b]``)) THEN 10824 MP_TAC(ASSUME ``d division_of interval[a:real,b]``) THEN 10825 REWRITE_TAC[division_of] THEN 10826 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10827 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 10828 DISCH_THEN(MP_TAC o SPEC ``k:real->bool``) THEN 10829 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 10830 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10831 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 10832 DISCH_THEN(MP_TAC o SPEC ``k2:real->bool``) THEN 10833 ASM_SIMP_TAC std_ss [INTER_INTERVAL, GSYM CONTENT_EQ_0_INTERIOR] THEN 10834 STRIP_TAC THEN ASM_REWRITE_TAC[INTER_INTERVAL] THEN 10835 SIMP_TAC std_ss [GSYM CONTENT_EQ_0_INTERIOR, INTEGRAL_NULL, ABS_0]] THEN 10836 MATCH_MP_TAC(SET_RULE 10837 ``interior(k INTER k2) SUBSET interior(k1 INTER k2) /\ 10838 (interior(k1 INTER k2) = {}) 10839 ==> (interior(k INTER k2) = {})``) THEN 10840 CONJ_TAC THENL 10841 [MATCH_MP_TAC SUBSET_INTERIOR THEN ASM_SET_TAC[], ALL_TAC] THEN 10842 MP_TAC(MATCH_MP DIVISION_OF_TAGGED_DIVISION 10843 (ASSUME ``p tagged_division_of interval[a:real,b]``)) THEN 10844 REWRITE_TAC[division_of] THEN 10845 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10846 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10847 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 10848 REWRITE_TAC[INTERIOR_INTER] THEN DISCH_THEN MATCH_MP_TAC THEN 10849 ASM_REWRITE_TAC[]] THEN 10850 SUBGOAL_THEN ``?u v:real. k = interval[u,v]`` 10851 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 10852 THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 10853 SUBGOAL_THEN ``interval[u:real,v] SUBSET interval[a,b]`` ASSUME_TAC THENL 10854 [ASM_MESON_TAC[division_of], ALL_TAC] THEN SIMP_TAC std_ss [] THEN 10855 ABBREV_TAC ``d' = 10856 {interval[u,v] INTER l |l| 10857 l IN IMAGE SND (p:(real#(real->bool))->bool) /\ 10858 ~(interval[u,v] INTER l = {})}`` THEN 10859 MATCH_MP_TAC REAL_LE_TRANS THEN 10860 EXISTS_TAC 10861 ``sum d' (\k. abs (integral k (f:real->real)))`` THEN 10862 CONJ_TAC THENL 10863 [ALL_TAC, 10864 MATCH_MP_TAC REAL_EQ_IMP_LE THEN CONV_TAC SYM_CONV THEN 10865 MATCH_MP_TAC SUM_SUPERSET THEN 10866 EXPAND_TAC "d'" THEN REWRITE_TAC[SUBSET_DEF, SET_RULE 10867 ``a IN {f x |x| x IN s /\ ~(f x = b)} <=> 10868 a IN {f x | x IN s} /\ ~(a = b)``] THEN 10869 SIMP_TAC std_ss [IMP_CONJ, INTEGRAL_EMPTY, ABS_0]] THEN 10870 SIMP_TAC std_ss [] THEN 10871 SUBGOAL_THEN ``d' division_of interval[u:real,v]`` ASSUME_TAC THENL 10872 [EXPAND_TAC "d'" THEN MATCH_MP_TAC DIVISION_INTER_1 THEN 10873 EXISTS_TAC ``interval[a:real,b]`` THEN 10874 ASM_SIMP_TAC std_ss [DIVISION_OF_TAGGED_DIVISION], 10875 ALL_TAC] THEN 10876 MATCH_MP_TAC REAL_LE_TRANS THEN 10877 EXISTS_TAC ``abs(sum d' (\i. integral i (f:real->real)))`` THEN 10878 CONJ_TAC THENL 10879 [MATCH_MP_TAC REAL_EQ_IMP_LE THEN AP_TERM_TAC THEN 10880 MATCH_MP_TAC INTEGRAL_COMBINE_DIVISION_TOPDOWN THEN 10881 ASM_MESON_TAC[INTEGRABLE_ON_SUBINTERVAL], 10882 ALL_TAC] THEN 10883 MATCH_MP_TAC SUM_ABS_LE THEN 10884 SIMP_TAC std_ss [REAL_LE_REFL] THEN METIS_TAC[division_of], 10885 ALL_TAC] THEN 10886 FIRST_X_ASSUM SUBST_ALL_TAC THEN 10887 MATCH_MP_TAC EQ_TRANS THEN 10888 EXISTS_TAC ``sum {x,i INTER l | (x,l) IN p /\ i IN d} 10889 (\(x,k:real->bool). 10890 abs(content k) * abs((f:real->real) x))`` THEN 10891 CONJ_TAC THENL 10892 [CONV_TAC SYM_CONV THEN MATCH_MP_TAC SUM_SUPERSET THEN 10893 CONJ_TAC THENL [SET_TAC[], ALL_TAC] THEN 10894 SIMP_TAC std_ss [FORALL_PROD] THEN 10895 MAP_EVERY X_GEN_TAC [``x:real``, ``i:real->bool``] THEN 10896 ASM_CASES_TAC ``i:real->bool = {}`` THEN 10897 ASM_SIMP_TAC std_ss [CONTENT_EMPTY, ABS_N, REAL_MUL_LZERO] THEN 10898 MATCH_MP_TAC(TAUT `(a <=> b) ==> a /\ ~b ==> c`) THEN 10899 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 10900 REPEAT(AP_TERM_TAC THEN ABS_TAC) THEN 10901 SIMP_TAC std_ss [PAIR_EQ] THEN ASM_MESON_TAC[], 10902 ALL_TAC] THEN 10903 SUBGOAL_THEN 10904 ``{(x,i INTER l) | (x,l) IN (p:(real#(real->bool))->bool) /\ i IN d} = 10905 IMAGE (\((x,l),k). (x,k INTER l)) {(m,k) | m IN p /\ k IN d}`` 10906 SUBST1_TAC THENL 10907 [GEN_REWR_TAC I [EXTENSION] THEN 10908 SIMP_TAC std_ss [GSPECIFICATION, IN_IMAGE, EXISTS_PROD, FORALL_PROD] THEN 10909 SIMP_TAC std_ss [PAIR_EQ] THEN METIS_TAC [], 10910 ALL_TAC] THEN 10911 W(MP_TAC o PART_MATCH (lhand o rand) SUM_IMAGE_NONZERO o lhand o snd) THEN 10912 KNOW_TAC ``FINITE 10913 {(m,k) | m IN (p :real # (real -> bool) -> bool) /\ 10914 k IN (d :(real -> bool) -> bool)} /\ 10915 (!(x :(real # (real -> bool)) # (real -> bool)) 10916 (y :(real # (real -> bool)) # (real -> bool)). 10917 x IN {(m,k) | m IN p /\ k IN d} /\ 10918 y IN {(m,k) | m IN p /\ k IN d} /\ x <> y /\ 10919 ((\(((x :real),(l :real -> bool)),(k :real -> bool)). (x,k INTER l)) 10920 x = (\(((x :real),(l :real -> bool)),(k :real -> bool)). (x,k INTER l)) y) ==> 10921 ((\((x :real),(k :real -> bool)). 10922 abs (content k) * abs ((f :real -> real) x)) 10923 ((\(((x :real),(l :real -> bool)),(k :real -> bool)). 10924 (x,k INTER l)) x) = (0 : real)))`` THENL 10925 [ASM_SIMP_TAC std_ss [FINITE_PRODUCT] THEN 10926 SIMP_TAC std_ss [FORALL_PROD, IN_ELIM_PAIR_THM] THEN 10927 MAP_EVERY X_GEN_TAC 10928 [``x1:real``, ``l1:real->bool``, ``k1:real->bool``, 10929 ``l2:real->bool``, ``k2:real->bool``] THEN 10930 SIMP_TAC std_ss [PAIR_EQ] THEN REWRITE_TAC [GSYM DE_MORGAN_THM] THEN 10931 STRIP_TAC THEN 10932 REWRITE_TAC[REAL_ENTIRE] THEN DISJ1_TAC THEN 10933 REWRITE_TAC[ABS_ZERO] THEN 10934 SUBGOAL_THEN ``interior(k2 INTER l2:real->bool) = {}`` MP_TAC THENL 10935 [ALL_TAC, 10936 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 10937 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 10938 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10939 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 10940 DISCH_THEN(MP_TAC o SPEC ``k2:real->bool``) THEN 10941 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 10942 MP_TAC(ASSUME ``p tagged_division_of interval[a:real,b]``) THEN 10943 REWRITE_TAC[TAGGED_DIVISION_OF] THEN 10944 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10945 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 10946 DISCH_THEN(MP_TAC o SPECL [``x1:real``, ``l2:real->bool``]) THEN 10947 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN 10948 ASM_SIMP_TAC std_ss [INTER_INTERVAL, CONTENT_EQ_0_INTERIOR]] THEN 10949 MATCH_MP_TAC(SET_RULE 10950 ``((interior(k1) INTER interior(k2) = {}) \/ 10951 (interior(l1) INTER interior(l2) = {})) /\ 10952 interior(k1 INTER l1) SUBSET interior(k1) /\ 10953 interior(k2 INTER l2) SUBSET interior(k2) /\ 10954 interior(k1 INTER l1) SUBSET interior(l1) /\ 10955 interior(k2 INTER l2) SUBSET interior(l2) /\ 10956 (interior(k1 INTER l1) = interior(k2 INTER l2)) 10957 ==> (interior(k2 INTER l2) = {})``) THEN 10958 SIMP_TAC std_ss [SUBSET_INTERIOR, INTER_SUBSET] THEN ASM_REWRITE_TAC[] THEN 10959 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 10960 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 10961 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10962 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10963 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 10964 DISCH_THEN(MP_TAC o SPECL [``k1:real->bool``, ``k2:real->bool``]) THEN 10965 MP_TAC(ASSUME ``p tagged_division_of interval[a:real,b]``) THEN 10966 REWRITE_TAC[TAGGED_DIVISION_OF] THEN 10967 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10968 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 10969 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 10970 DISCH_THEN(MP_TAC o SPECL 10971 [``x1:real``, ``l1:real->bool``, ``x1:real``, ``l2:real->bool``]) THEN 10972 ASM_SIMP_TAC std_ss [PAIR_EQ] THEN ASM_MESON_TAC[], 10973 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 10974 DISCH_THEN SUBST1_TAC THEN 10975 GEN_REWR_TAC (LAND_CONV o RAND_CONV) [GSYM ETA_AX] THEN 10976 GEN_REWR_TAC (LAND_CONV o RAND_CONV) [LAMBDA_PROD] THEN 10977 ASM_SIMP_TAC std_ss [GSYM SUM_SUM_PRODUCT] THEN 10978 MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [FORALL_PROD] THEN 10979 MAP_EVERY X_GEN_TAC [``x:real``, ``l:real->bool``] THEN 10980 DISCH_TAC THEN SIMP_TAC std_ss [o_THM, SUM_RMUL] THEN 10981 AP_THM_TAC THEN AP_TERM_TAC THEN 10982 SUBGOAL_THEN ``?u v:real. l = interval[u,v]`` 10983 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 10984 THENL [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 10985 MATCH_MP_TAC EQ_TRANS THEN 10986 EXISTS_TAC ``sum d (\k. content(k INTER interval[u:real,v]))`` THEN 10987 CONJ_TAC THENL 10988 [MATCH_MP_TAC SUM_EQ THEN REWRITE_TAC[abs] THEN 10989 X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 10990 SUBGOAL_THEN ``?w z:real. k = interval[w,z]`` 10991 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 10992 THENL [ASM_MESON_TAC[division_of], ALL_TAC] THEN 10993 SIMP_TAC std_ss [INTER_INTERVAL, CONTENT_POS_LE], 10994 ALL_TAC] THEN 10995 MATCH_MP_TAC EQ_TRANS THEN 10996 EXISTS_TAC ``sum {k INTER interval[u:real,v] | k IN d} content`` THEN 10997 CONJ_TAC THENL 10998 [SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN SIMP_TAC std_ss [GSYM o_DEF] THEN 10999 CONV_TAC SYM_CONV THEN MATCH_MP_TAC SUM_IMAGE_NONZERO THEN 11000 ASM_SIMP_TAC std_ss [] THEN 11001 MAP_EVERY X_GEN_TAC [``k1:real->bool``, ``k2:real->bool``] THEN 11002 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 11003 SUBGOAL_THEN ``interior(k2 INTER interval[u:real,v]) = {}`` MP_TAC THENL 11004 [ALL_TAC, 11005 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 11006 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 11007 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 11008 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 11009 DISCH_THEN(MP_TAC o SPEC ``k2:real->bool``) THEN 11010 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 11011 ASM_REWRITE_TAC[INTER_INTERVAL, CONTENT_EQ_0_INTERIOR]] THEN 11012 MATCH_MP_TAC(SET_RULE 11013 ``interior(k2 INTER i) SUBSET interior(k1 INTER k2) /\ 11014 (interior(k1 INTER k2) = {}) 11015 ==> (interior(k2 INTER i) = {})``) THEN 11016 CONJ_TAC THENL 11017 [MATCH_MP_TAC SUBSET_INTERIOR THEN ASM_SET_TAC[], ALL_TAC] THEN 11018 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 11019 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 11020 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 11021 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 11022 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 11023 SIMP_TAC std_ss [INTERIOR_INTER] THEN DISCH_THEN MATCH_MP_TAC THEN 11024 ASM_REWRITE_TAC[], 11025 ALL_TAC] THEN 11026 SUBGOAL_THEN ``interval[u:real,v] SUBSET interval[a,b]`` ASSUME_TAC THENL 11027 [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 11028 MATCH_MP_TAC EQ_TRANS THEN 11029 EXISTS_TAC ``sum {k INTER interval[u:real,v] |k| 11030 k IN d /\ ~(k INTER interval[u,v] = {})} content`` THEN 11031 CONJ_TAC THENL 11032 [MATCH_MP_TAC SUM_SUPERSET THEN 11033 SIMP_TAC std_ss [SUBSET_DEF, SET_RULE 11034 ``a IN {f x |x| x IN s /\ ~(f x = b)} <=> 11035 a IN {f x | x IN s} /\ ~(a = b)``] THEN 11036 SIMP_TAC std_ss [IMP_CONJ, CONTENT_EMPTY], 11037 ALL_TAC] THEN 11038 MATCH_MP_TAC ADDITIVE_CONTENT_DIVISION THEN 11039 ONCE_REWRITE_TAC[INTER_COMM] THEN MATCH_MP_TAC DIVISION_INTER_1 THEN 11040 EXISTS_TAC ``interval[a:real,b]`` THEN ASM_REWRITE_TAC[] 11041QED 11042 11043val BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE = store_thm ("BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE", 11044 ``!f:real->real. 11045 f integrable_on UNIV /\ 11046 (\k. integral k f) has_bounded_setvariation_on univ(:real) 11047 ==> f absolutely_integrable_on UNIV``, 11048 REWRITE_TAC[HAS_BOUNDED_SETVARIATION_ON_UNIV] THEN 11049 REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[absolutely_integrable_on] THEN 11050 MP_TAC(ISPEC ``IMAGE (\d. sum d (\k. abs(integral k (f:real->real)))) 11051 {d | d division_of (BIGUNION d) }`` 11052 SUP) THEN 11053 SIMP_TAC std_ss [FORALL_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 11054 SIMP_TAC std_ss [GSYM MEMBER_NOT_EMPTY, GSPECIFICATION] THEN 11055 ABBREV_TAC 11056 ``i = sup (IMAGE (\d. sum d (\k. abs(integral k (f:real->real)))) 11057 {d | d division_of (BIGUNION d) })`` THEN 11058 KNOW_TAC ``(?(x :(real -> bool) -> bool). x division_of BIGUNION x) /\ 11059 (?(b :real). !(d :(real -> bool) -> bool). 11060 d division_of BIGUNION d ==> 11061 sum d (\(k :real -> bool). abs (integral k (f :real -> real))) <= b)`` THENL 11062 [CONJ_TAC THENL [ALL_TAC, ASM_MESON_TAC[]] THEN 11063 EXISTS_TAC ``{}:(real->bool)->bool`` THEN 11064 REWRITE_TAC[BIGUNION_EMPTY, DIVISION_OF_TRIVIAL], 11065 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 11066 STRIP_TAC THEN REWRITE_TAC[integrable_on] THEN EXISTS_TAC ``i:real`` THEN 11067 REWRITE_TAC[HAS_INTEGRAL_ALT, IN_UNIV] THEN 11068 MATCH_MP_TAC(TAUT `a /\ (a ==> b) ==> a /\ b`) THEN CONJ_TAC THENL 11069 [MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 11070 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``] 11071 (REWRITE_RULE[HAS_BOUNDED_SETVARIATION_ON_INTERVAL] 11072 BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE_INTERVAL)) THEN 11073 KNOW_TAC ``(f :real -> real) integrable_on interval [((a :real),(b :real))] /\ 11074 (?(B :real). !(d :(real -> bool) -> bool). 11075 d division_of interval [(a,b)] ==> 11076 sum d (\(k :real -> bool). 11077 abs ((\(k :real -> bool). integral k f) k)) <= B)`` THENL 11078 [ALL_TAC, DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 11079 SIMP_TAC std_ss [absolutely_integrable_on]] THEN 11080 CONJ_TAC THENL 11081 [MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN EXISTS_TAC ``univ(:real)`` THEN 11082 ASM_REWRITE_TAC[SUBSET_UNIV], 11083 ALL_TAC] THEN 11084 EXISTS_TAC ``B:real`` THEN REPEAT STRIP_TAC THEN 11085 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_MESON_TAC[DIVISION_OF_UNION_SELF], 11086 ALL_TAC] THEN 11087 SIMP_TAC std_ss [] THEN 11088 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 11089 UNDISCH_TAC ``!b. 11090 (!d. d division_of BIGUNION d ==> 11091 sum d (\k. abs (integral k f)) <= b) ==> 11092 i <= b`` THEN DISCH_TAC THEN 11093 FIRST_X_ASSUM(MP_TAC o SPEC ``i - e:real``) THEN 11094 ASM_SIMP_TAC std_ss [REAL_ARITH ``&0 < e ==> ~(i <= i - e:real)``] THEN 11095 SIMP_TAC std_ss [NOT_FORALL_THM, NOT_IMP, REAL_NOT_LE, LEFT_IMP_EXISTS_THM] THEN 11096 X_GEN_TAC ``d:(real->bool)->bool`` THEN STRIP_TAC THEN 11097 SUBGOAL_THEN ``bounded(BIGUNION d:real->bool)`` MP_TAC THENL 11098 [ASM_MESON_TAC[ELEMENTARY_BOUNDED], ALL_TAC] THEN 11099 REWRITE_TAC[BOUNDED_POS] THEN 11100 DISCH_THEN(X_CHOOSE_THEN ``kk:real`` STRIP_ASSUME_TAC) THEN 11101 EXISTS_TAC ``kk + &1:real`` THEN ASM_SIMP_TAC std_ss [REAL_LT_ADD, REAL_LT_01] THEN 11102 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN DISCH_TAC THEN 11103 SIMP_TAC std_ss [] THEN 11104 MATCH_MP_TAC(REAL_ARITH 11105 ``!s1. i - e < s1 /\ s1 <= s /\ s < i + e ==> abs(s - i) < e:real``) THEN 11106 EXISTS_TAC ``sum (d:(real->bool)->bool) (\k. abs (integral k 11107 (f:real->real)))`` THEN 11108 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 11109 ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THENL 11110 [MATCH_MP_TAC REAL_LE_TRANS THEN 11111 EXISTS_TAC ``sum d 11112 (\k. integral k (\x. abs((f:real->real) x)))`` THEN 11113 CONJ_TAC THENL 11114 [MATCH_MP_TAC SUM_LE THEN 11115 UNDISCH_TAC ``d division_of BIGUNION d`` THEN DISCH_TAC THEN 11116 FIRST_ASSUM(fn t => ASM_SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION t]) THEN 11117 REPEAT STRIP_TAC THEN SIMP_TAC std_ss [] THEN 11118 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_LE THEN 11119 ASM_SIMP_TAC std_ss [absolutely_integrable_on] THEN 11120 MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 11121 EXISTS_TAC ``univ(:real)`` THEN ASM_REWRITE_TAC[SUBSET_UNIV], 11122 ALL_TAC] THEN 11123 MATCH_MP_TAC REAL_LE_TRANS THEN 11124 EXISTS_TAC ``integral (BIGUNION d) 11125 (\x. abs((f:real->real) x))`` THEN 11126 CONJ_TAC THENL 11127 [MATCH_MP_TAC(METIS[REAL_LE_LT] 11128 ``(x = y) ==> x <= y:real``) THEN 11129 ASM_SIMP_TAC std_ss [o_DEF] THEN CONV_TAC SYM_CONV THEN 11130 MATCH_MP_TAC INTEGRAL_COMBINE_DIVISION_BOTTOMUP THEN 11131 FIRST_ASSUM(fn t => ASM_REWRITE_TAC[MATCH_MP FORALL_IN_DIVISION t]), 11132 ALL_TAC] THEN 11133 MATCH_MP_TAC INTEGRAL_SUBSET_DROP_LE THEN 11134 ASM_SIMP_TAC std_ss [ABS_POS] THEN 11135 MATCH_MP_TAC(TAUT `a /\ (a ==> b) ==> a /\ b`) THEN CONJ_TAC THENL 11136 [MATCH_MP_TAC SUBSET_TRANS THEN 11137 EXISTS_TAC ``ball(0:real,kk + &1)`` THEN 11138 ASM_REWRITE_TAC[] THEN REWRITE_TAC[SUBSET_DEF, IN_BALL, dist] THEN 11139 ASM_SIMP_TAC std_ss [REAL_ARITH ``abs(x) <= kk ==> abs(0 - x) < kk + &1:real``], 11140 ALL_TAC] THEN 11141 DISCH_TAC THEN SIMP_TAC std_ss [] THEN 11142 MATCH_MP_TAC INTEGRABLE_ON_SUBDIVISION THEN 11143 EXISTS_TAC ``interval[a:real,b]`` THEN 11144 EXISTS_TAC ``d:(real->bool)->bool`` THEN ASM_REWRITE_TAC[], 11145 ALL_TAC] THEN 11146 FIRST_X_ASSUM(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 11147 REWRITE_TAC[HAS_INTEGRAL_INTEGRAL, has_integral] THEN 11148 DISCH_THEN(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 11149 DISCH_THEN(X_CHOOSE_THEN ``d1:real->real->bool`` MP_TAC) THEN 11150 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC) THEN 11151 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``] 11152 HENSTOCK_LEMMA) THEN 11153 KNOW_TAC ``(f :real -> real) integrable_on interval [((a :real),(b :real))]`` THENL 11154 [MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 11155 EXISTS_TAC ``univ(:real)`` THEN ASM_SIMP_TAC std_ss [SUBSET_UNIV], 11156 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 11157 DISCH_THEN(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 11158 DISCH_THEN(X_CHOOSE_THEN ``d2:real->real->bool`` MP_TAC) THEN 11159 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC) THEN 11160 SUBGOAL_THEN ``?p. p tagged_division_of interval[a:real,b] /\ 11161 d1 FINE p /\ d2 FINE p`` 11162 STRIP_ASSUME_TAC THENL 11163 [REWRITE_TAC[GSYM FINE_INTER] THEN MATCH_MP_TAC FINE_DIVISION_EXISTS THEN 11164 ASM_SIMP_TAC std_ss [GAUGE_INTER], 11165 ALL_TAC] THEN FULL_SIMP_TAC std_ss [] THEN 11166 UNDISCH_TAC `` !p'. p' tagged_division_of interval [(a,b)] /\ d1 FINE p' ==> 11167 abs (sum p' (\(x,k). content k * abs (f x)) - 11168 integral (interval [(a,b)]) (\x. abs (f x))) < e / 2`` THEN DISCH_TAC THEN 11169 FIRST_X_ASSUM (MP_TAC o SPEC ``p:(real#(real->bool)->bool)``) THEN 11170 FIRST_X_ASSUM (MP_TAC o SPEC ``p:(real#(real->bool)->bool)``) THEN 11171 ASM_SIMP_TAC std_ss [] THEN 11172 KNOW_TAC ``p tagged_partial_division_of interval [(a,b)]`` THENL 11173 [METIS_TAC[tagged_division_of], 11174 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 11175 SIMP_TAC std_ss [LAMBDA_PAIR] THEN 11176 ONCE_REWRITE_TAC [METIS [] 11177 ``(\p. abs (content (SND p) * f (FST p) - integral (SND p) f)) = 11178 (\p. abs ((\p. content (SND p) * f (FST p)) p - (\p. integral (SND p) f) p))``] THEN 11179 DISCH_THEN(MP_TAC o MATCH_MP lemma) THEN 11180 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 11181 ASM_SIMP_TAC std_ss [o_DEF, SUM_SUB] THEN 11182 SIMP_TAC std_ss [LAMBDA_PROD, ABS_MUL] THEN 11183 GEN_REWR_TAC (RAND_CONV o RAND_CONV o RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 11184 MATCH_MP_TAC(REAL_ARITH 11185 ``(sf' = sf) /\ si <= i 11186 ==> abs(sf - si) < e / &2 11187 ==> abs(sf' - di) < e / &2 11188 ==> di < i + (e / 2 + e / 2:real)``) THEN 11189 CONJ_TAC THENL 11190 [MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [FORALL_PROD, abs] THEN 11191 METIS_TAC[CONTENT_POS_LE, TAGGED_DIVISION_OF], 11192 ALL_TAC] THEN 11193 SUBGOAL_THEN 11194 ``sum p (\(x:real,k). abs(integral k f)) = 11195 sum (IMAGE SND p) (\k. abs(integral k (f:real->real)))`` 11196 SUBST1_TAC THENL 11197 [ONCE_REWRITE_TAC [METIS [] ``(\(x,k). abs (integral k f)) = 11198 (\(x,k).(\k. abs(integral k (f:real->real))) k)``] THEN 11199 MATCH_MP_TAC SUM_OVER_TAGGED_DIVISION_LEMMA THEN 11200 EXISTS_TAC ``interval[a:real,b]`` THEN ASM_SIMP_TAC std_ss [] THEN 11201 SIMP_TAC std_ss [INTEGRAL_NULL, ABS_0], 11202 ALL_TAC] THEN 11203 FIRST_X_ASSUM MATCH_MP_TAC THEN 11204 MATCH_MP_TAC PARTIAL_DIVISION_OF_TAGGED_DIVISION THEN 11205 EXISTS_TAC ``interval[a:real,b]`` THEN ASM_MESON_TAC[tagged_division_of]); 11206 11207val ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION_UNIV_EQ = store_thm ("ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION_UNIV_EQ", 11208 ``!f:real->real. 11209 f absolutely_integrable_on univ(:real) <=> 11210 f integrable_on univ(:real) /\ 11211 (\k. integral k f) has_bounded_setvariation_on univ(:real)``, 11212 GEN_TAC THEN EQ_TAC THEN 11213 SIMP_TAC std_ss [ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION, 11214 BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE, 11215 ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE]); 11216 11217val ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION_EQ = store_thm ("ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION_EQ", 11218 ``!f:real->real a b. 11219 f absolutely_integrable_on interval[a,b] <=> 11220 f integrable_on interval[a,b] /\ 11221 (\k. integral k f) has_bounded_setvariation_on interval[a,b]``, 11222 REPEAT GEN_TAC THEN EQ_TAC THEN 11223 SIMP_TAC std_ss [ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION, 11224 BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE_INTERVAL, 11225 ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE]); 11226 11227val ABSOLUTELY_INTEGRABLE_SET_VARIATION = store_thm ("ABSOLUTELY_INTEGRABLE_SET_VARIATION", 11228 ``!f:real->real a b. 11229 f absolutely_integrable_on interval[a,b] 11230 ==> (set_variation (interval[a,b]) (\k. integral k f) = 11231 integral (interval[a,b]) (\x. abs(f x)))``, 11232 REPEAT STRIP_TAC THEN REWRITE_TAC[set_variation] THEN 11233 MATCH_MP_TAC REAL_SUP_UNIQUE THEN 11234 SIMP_TAC std_ss [FORALL_IN_GSPEC, EXISTS_IN_GSPEC] THEN CONJ_TAC THENL 11235 [X_GEN_TAC ``d:(real->bool)->bool`` THEN 11236 DISCH_THEN(X_CHOOSE_THEN ``s:real->bool`` STRIP_ASSUME_TAC) THEN 11237 MATCH_MP_TAC REAL_LE_TRANS THEN 11238 EXISTS_TAC ``integral s (\x. abs((f:real->real) x))`` THEN 11239 CONJ_TAC THENL 11240 [MP_TAC(ISPECL [``\x. abs((f:real->real) x)``, 11241 ``d:(real->bool)->bool``, ``s:real->bool``] 11242 INTEGRAL_COMBINE_DIVISION_TOPDOWN) THEN 11243 ASM_SIMP_TAC std_ss [] THEN 11244 KNOW_TAC ``(\(x :real). abs ((f :real -> real) x)) integrable_on 11245 (s :real -> bool)`` THENL 11246 [RULE_ASSUM_TAC(REWRITE_RULE[absolutely_integrable_on]) THEN 11247 ASM_REWRITE_TAC[] THEN 11248 MATCH_MP_TAC INTEGRABLE_ON_SUBDIVISION THEN 11249 EXISTS_TAC ``interval[a:real,b]`` THEN ASM_MESON_TAC[], 11250 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 11251 DISCH_THEN SUBST1_TAC] THEN 11252 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 11253 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC SUM_LE THEN 11254 ASM_REWRITE_TAC[o_THM] THEN 11255 REPEAT STRIP_TAC THEN BETA_TAC THEN MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 11256 SIMP_TAC std_ss [REAL_LE_REFL, GSYM absolutely_integrable_on] THEN 11257 RULE_ASSUM_TAC(REWRITE_RULE[division_of]) THEN 11258 ASM_MESON_TAC[ABSOLUTELY_INTEGRABLE_ON_SUBINTERVAL, SUBSET_TRANS], 11259 MATCH_MP_TAC INTEGRAL_SUBSET_DROP_LE THEN 11260 ASM_SIMP_TAC std_ss [ABS_POS] THEN 11261 RULE_ASSUM_TAC(REWRITE_RULE[absolutely_integrable_on]) THEN 11262 ASM_REWRITE_TAC[] THEN 11263 MATCH_MP_TAC INTEGRABLE_ON_SUBDIVISION THEN 11264 EXISTS_TAC ``interval[a:real,b]`` THEN ASM_MESON_TAC[]], 11265 X_GEN_TAC ``B:real`` THEN ONCE_REWRITE_TAC[GSYM REAL_SUB_LT] THEN 11266 ABBREV_TAC ``e = integral (interval [a,b]) (\x. abs((f:real->real) x)) - B`` THEN 11267 DISCH_TAC THEN 11268 FIRST_ASSUM(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE) THEN 11269 DISCH_THEN(MP_TAC o SPEC ``e / &2:real`` o MATCH_MP HENSTOCK_LEMMA) THEN 11270 ASM_REWRITE_TAC[REAL_HALF] THEN 11271 DISCH_THEN(X_CHOOSE_THEN ``d1:real->real->bool`` 11272 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 11273 UNDISCH_TAC ``f absolutely_integrable_on interval [(a,b)]`` THEN DISCH_TAC THEN 11274 FIRST_ASSUM(MP_TAC o REWRITE_RULE [absolutely_integrable_on]) THEN 11275 DISCH_THEN(MP_TAC o CONJUNCT2) THEN 11276 REWRITE_TAC[HAS_INTEGRAL_INTEGRAL, has_integral] THEN 11277 DISCH_THEN(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 11278 DISCH_THEN(X_CHOOSE_THEN ``d2:real->real->bool`` 11279 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 11280 MP_TAC(ISPECL 11281 [``\x. (d1:real->real->bool) x INTER d2 x``, 11282 ``a:real``, ``b:real``] 11283 FINE_DIVISION_EXISTS) THEN 11284 ASM_SIMP_TAC std_ss [GAUGE_INTER, FINE_INTER] THEN 11285 DISCH_THEN(X_CHOOSE_THEN ``p:real#(real->bool)->bool`` 11286 STRIP_ASSUME_TAC) THEN 11287 FIRST_X_ASSUM (MP_TAC o SPEC ``p:real#(real->bool)->bool``) THEN 11288 FIRST_X_ASSUM (MP_TAC o SPEC ``p:real#(real->bool)->bool``) THEN 11289 ASM_SIMP_TAC std_ss [] THEN 11290 KNOW_TAC ``p tagged_partial_division_of interval [(a,b)]`` THENL 11291 [ASM_MESON_TAC[tagged_division_of], 11292 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 11293 MP_TAC(ISPECL 11294 [``\x. abs((f:real->real) x)``, 11295 ``a:real``, ``b:real``, ``p:real#(real->bool)->bool``] 11296 INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN) THEN 11297 KNOW_TAC ``(\(x :real). abs ((f :real -> real) x)) integrable_on 11298 interval [((a :real),(b :real))] /\ 11299 (p :real # (real -> bool) -> bool) tagged_division_of 11300 interval [(a,b)]`` THENL 11301 [RULE_ASSUM_TAC(SIMP_RULE std_ss [absolutely_integrable_on]) THEN 11302 ASM_REWRITE_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 11303 POP_ASSUM K_TAC THEN DISCH_THEN SUBST_ALL_TAC] THEN 11304 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 11305 DISCH_TAC THEN 11306 SUBGOAL_THEN 11307 ``abs(sum p (\(x,k). content k * abs((f:real->real) x)) - 11308 sum p (\(x,k:real->bool). abs(integral k f))) < e / &2`` 11309 MP_TAC THENL 11310 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ_ALT] 11311 REAL_LET_TRANS)) THEN 11312 ASM_SIMP_TAC std_ss [GSYM SUM_SUB] THEN MATCH_MP_TAC SUM_ABS_LE THEN 11313 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN REPEAT STRIP_TAC THEN 11314 MATCH_MP_TAC(REAL_ARITH 11315 ``(x = abs u) ==> abs(x - abs v) <= abs(u - v:real)``) THEN 11316 SIMP_TAC std_ss [ABS_MUL, abs] THEN 11317 METIS_TAC[CONTENT_POS_LE, TAGGED_DIVISION_OF], 11318 ALL_TAC] THEN 11319 ASM_SIMP_TAC std_ss [] THEN 11320 SIMP_TAC std_ss [LAMBDA_PROD, o_DEF, AND_IMP_INTRO] THEN 11321 DISCH_THEN(MP_TAC o MATCH_MP (REAL_ARITH 11322 ``abs(x - y:real) < e / &2 /\ abs(x - z) < e / &2 11323 ==> abs(y - z) < e / 2 + e / 2``)) THEN 11324 REWRITE_TAC[REAL_HALF] THEN 11325 DISCH_THEN(MP_TAC o SPEC ``B:real`` o MATCH_MP 11326 (REAL_ARITH ``!B. abs(x - y) < e ==> (y - B = e) ==> &0 < x - B:real``)) THEN 11327 ASM_REWRITE_TAC[] THEN ASM_SIMP_TAC std_ss [REAL_SUB_LT] THEN 11328 SIMP_TAC std_ss [o_DEF, LAMBDA_PROD] THEN DISCH_TAC THEN 11329 EXISTS_TAC ``IMAGE SND (p:real#(real->bool)->bool)`` THEN CONJ_TAC THENL 11330 [EXISTS_TAC ``interval[a:real,b]`` THEN 11331 ASM_SIMP_TAC std_ss [DIVISION_OF_TAGGED_DIVISION, SUBSET_REFL], 11332 FIRST_ASSUM(MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 11333 SUM_OVER_TAGGED_DIVISION_LEMMA)) THEN 11334 DISCH_THEN(fn th => 11335 W(MP_TAC o PART_MATCH (rand o rand) th o rand o snd)) THEN 11336 SIMP_TAC std_ss [INTEGRAL_NULL, ABS_0] THEN 11337 DISCH_THEN(SUBST1_TAC o SYM) THEN ASM_REWRITE_TAC[]]]); 11338 11339val ABSOLUTELY_INTEGRABLE_RESTRICT_UNIV = store_thm ("ABSOLUTELY_INTEGRABLE_RESTRICT_UNIV", 11340 ``!f s. (\x. if x IN s then f x else 0) 11341 absolutely_integrable_on univ(:real) <=> 11342 f absolutely_integrable_on s``, 11343 SIMP_TAC std_ss [absolutely_integrable_on, INTEGRABLE_RESTRICT_UNIV, 11344 COND_RAND, ABS_0]); 11345 11346val ABSOLUTELY_INTEGRABLE_CONST = store_thm ("ABSOLUTELY_INTEGRABLE_CONST", 11347 ``!a b c. (\x. c) absolutely_integrable_on interval[a,b]``, 11348 REWRITE_TAC[absolutely_integrable_on, INTEGRABLE_CONST]); 11349 11350val ABSOLUTELY_INTEGRABLE_ADD = store_thm ("ABSOLUTELY_INTEGRABLE_ADD", 11351 ``!f:real->real g s. 11352 f absolutely_integrable_on s /\ 11353 g absolutely_integrable_on s 11354 ==> (\x. f(x) + g(x)) absolutely_integrable_on s``, 11355 SUBGOAL_THEN 11356 ``!f:real->real g. 11357 f absolutely_integrable_on univ(:real) /\ 11358 g absolutely_integrable_on univ(:real) 11359 ==> (\x. f(x) + g(x)) absolutely_integrable_on univ(:real)`` 11360 ASSUME_TAC THENL 11361 [ALL_TAC, 11362 ONCE_REWRITE_TAC[GSYM ABSOLUTELY_INTEGRABLE_RESTRICT_UNIV] THEN 11363 REPEAT GEN_TAC THEN DISCH_THEN(ANTE_RES_THEN MP_TAC) THEN 11364 SIMP_TAC std_ss [] THEN MATCH_MP_TAC EQ_IMPLIES THEN 11365 AP_THM_TAC THEN AP_TERM_TAC THEN REWRITE_TAC[FUN_EQ_THM] THEN 11366 GEN_TAC THEN SIMP_TAC std_ss [] THEN 11367 COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [REAL_ADD_LID]] THEN 11368 REPEAT STRIP_TAC THEN 11369 EVERY_ASSUM(STRIP_ASSUME_TAC o 11370 REWRITE_RULE [absolutely_integrable_on]) THEN 11371 MATCH_MP_TAC BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE THEN 11372 ASM_SIMP_TAC std_ss [INTEGRABLE_ADD] THEN 11373 MP_TAC(ISPECL [``g:real->real``, ``univ(:real)``] 11374 ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION) THEN 11375 MP_TAC(ISPECL [``f:real->real``, ``univ(:real)``] 11376 ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION) THEN 11377 ASM_SIMP_TAC std_ss [HAS_BOUNDED_SETVARIATION_ON_UNIV] THEN 11378 DISCH_THEN(X_CHOOSE_TAC ``B1:real``) THEN 11379 DISCH_THEN(X_CHOOSE_TAC ``B2:real``) THEN EXISTS_TAC ``B1 + B2:real`` THEN 11380 X_GEN_TAC ``d:(real->bool)->bool`` THEN DISCH_TAC THEN 11381 REPEAT(FIRST_X_ASSUM(MP_TAC o SPEC ``d:(real->bool)->bool``)) THEN 11382 ASM_REWRITE_TAC[] THEN REPEAT STRIP_TAC THEN 11383 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 11384 ``a <= B1 ==> x <= a + B2 ==> x <= B1 + B2:real``)) THEN 11385 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 11386 ``b <= B2 ==> x <= a + b ==> x <= a + B2:real``)) THEN 11387 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 11388 ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN MATCH_MP_TAC SUM_LE THEN 11389 UNDISCH_TAC ``d division_of BIGUNION d`` THEN DISCH_TAC THEN 11390 FIRST_ASSUM(fn t => ASM_SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION t]) THEN 11391 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN STRIP_TAC THEN 11392 MATCH_MP_TAC(REAL_ARITH ``(x = y + z) ==> abs(x) <= abs(y) + abs(z:real)``) THEN 11393 MATCH_MP_TAC INTEGRAL_ADD THEN CONJ_TAC THEN 11394 MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 11395 EXISTS_TAC ``univ(:real)`` THEN ASM_REWRITE_TAC[SUBSET_UNIV]); 11396 11397val ABSOLUTELY_INTEGRABLE_SUB = store_thm ("ABSOLUTELY_INTEGRABLE_SUB", 11398 ``!f:real->real g s. 11399 f absolutely_integrable_on s /\ 11400 g absolutely_integrable_on s 11401 ==> (\x. f(x) - g(x)) absolutely_integrable_on s``, 11402 REWRITE_TAC[real_sub] THEN 11403 SIMP_TAC std_ss [ABSOLUTELY_INTEGRABLE_ADD, ABSOLUTELY_INTEGRABLE_NEG]); 11404 11405val ABSOLUTELY_INTEGRABLE_LINEAR = store_thm ("ABSOLUTELY_INTEGRABLE_LINEAR", 11406 ``!f:real->real h:real->real s. 11407 f absolutely_integrable_on s /\ linear h 11408 ==> (h o f) absolutely_integrable_on s``, 11409 SUBGOAL_THEN 11410 ``!f:real->real h:real->real. 11411 f absolutely_integrable_on univ(:real) /\ linear h 11412 ==> (h o f) absolutely_integrable_on univ(:real)`` 11413 ASSUME_TAC THENL 11414 [ALL_TAC, 11415 ONCE_REWRITE_TAC[GSYM ABSOLUTELY_INTEGRABLE_RESTRICT_UNIV] THEN 11416 REPEAT GEN_TAC THEN DISCH_THEN(fn th => 11417 ANTE_RES_THEN MP_TAC th THEN 11418 ASSUME_TAC(MATCH_MP LINEAR_0 (CONJUNCT2 th))) THEN 11419 ASM_SIMP_TAC std_ss [o_DEF, COND_RAND]] THEN 11420 REPEAT STRIP_TAC THEN 11421 MATCH_MP_TAC BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE THEN 11422 FIRST_ASSUM(MP_TAC o 11423 MATCH_MP ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION) THEN 11424 RULE_ASSUM_TAC(REWRITE_RULE[absolutely_integrable_on]) THEN 11425 ASM_SIMP_TAC std_ss [INTEGRABLE_LINEAR, HAS_BOUNDED_SETVARIATION_ON_UNIV] THEN 11426 FIRST_ASSUM(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC o MATCH_MP 11427 LINEAR_BOUNDED_POS) THEN 11428 DISCH_THEN(X_CHOOSE_TAC ``b:real``) THEN EXISTS_TAC ``B * b:real`` THEN 11429 X_GEN_TAC ``d:(real->bool)->bool`` THEN DISCH_TAC THEN 11430 MATCH_MP_TAC REAL_LE_TRANS THEN 11431 EXISTS_TAC ``B * sum d (\k. abs(integral k (f:real->real)))`` THEN 11432 ASM_SIMP_TAC std_ss [REAL_LE_LMUL] THEN SIMP_TAC std_ss [GSYM SUM_LMUL] THEN 11433 MATCH_MP_TAC SUM_LE THEN 11434 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 11435 FIRST_ASSUM(fn t => ASM_SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION t]) THEN 11436 MAP_EVERY X_GEN_TAC [``a:real``, ``b':real``] THEN DISCH_TAC THEN 11437 MATCH_MP_TAC REAL_LE_TRANS THEN 11438 EXISTS_TAC ``abs(h(integral (interval[a,b']) (f:real->real)):real)`` THEN 11439 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC REAL_EQ_IMP_LE THEN AP_TERM_TAC THEN 11440 MATCH_MP_TAC INTEGRAL_UNIQUE THEN MATCH_MP_TAC HAS_INTEGRAL_LINEAR THEN 11441 ASM_REWRITE_TAC[GSYM HAS_INTEGRAL_INTEGRAL] THEN 11442 MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 11443 EXISTS_TAC ``univ(:real)`` THEN ASM_REWRITE_TAC[SUBSET_UNIV]); 11444 11445val ABSOLUTELY_INTEGRABLE_SUM = store_thm ("ABSOLUTELY_INTEGRABLE_SUM", 11446 ``!f:'a->real->real s t. 11447 FINITE t /\ 11448 (!a. a IN t ==> (f a) absolutely_integrable_on s) 11449 ==> (\x. sum t (\a. f a x)) absolutely_integrable_on s``, 11450 GEN_TAC THEN GEN_TAC THEN REWRITE_TAC[IMP_CONJ] THEN 11451 ONCE_REWRITE_TAC [METIS [] 11452 ``( (!a. a IN t ==> f a absolutely_integrable_on s) ==> 11453 (\x. sum t (\a. f a x)) absolutely_integrable_on s) = 11454 (\t. (!a. a IN t ==> f a absolutely_integrable_on s) ==> 11455 ( \x. sum t (\a. f a x)) absolutely_integrable_on s) t``] THEN 11456 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 11457 SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM] THEN 11458 SIMP_TAC std_ss [SUM_CLAUSES, ABSOLUTELY_INTEGRABLE_0, IN_INSERT] THEN 11459 REPEAT STRIP_TAC THEN 11460 ONCE_REWRITE_TAC [METIS [] ``(\x. f e x + sum s' (\a. f a x)) = 11461 (\x. (\x. f e x) x + (\x. sum s' (\a. f a x)) x)``] THEN 11462 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_ADD THEN METIS_TAC [ETA_AX]); 11463 11464Theorem ABSOLUTELY_INTEGRABLE_MAX : 11465 !f:real->real g:real->real s. 11466 f absolutely_integrable_on s /\ g absolutely_integrable_on s 11467 ==> (\x. (max (f(x)) (g(x))):real) 11468 absolutely_integrable_on s 11469Proof 11470 REPEAT GEN_TAC THEN DISCH_TAC THEN 11471 FIRST_ASSUM(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_SUB) THEN 11472 DISCH_THEN(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_ABS) THEN 11473 FIRST_ASSUM(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_ADD) THEN 11474 REWRITE_TAC[AND_IMP_INTRO] THEN 11475 DISCH_THEN(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_ADD) THEN 11476 DISCH_THEN(MP_TAC o SPEC ``inv(&2:real)`` o 11477 MATCH_MP ABSOLUTELY_INTEGRABLE_CMUL) THEN 11478 MATCH_MP_TAC EQ_IMPLIES THEN SIMP_TAC std_ss [] THEN 11479 AP_THM_TAC THEN AP_TERM_TAC THEN 11480 REWRITE_TAC[FUN_EQ_THM] THEN 11481 SIMP_TAC std_ss [max_def] THEN REPEAT STRIP_TAC THEN 11482 ONCE_REWRITE_TAC [REAL_MUL_SYM] THEN REWRITE_TAC [GSYM real_div] THEN 11483 SIMP_TAC std_ss [REAL_EQ_LDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 11484 Cases_on `f x <= g x` >> rw [] >> REAL_ASM_ARITH_TAC 11485QED 11486 11487Theorem ABSOLUTELY_INTEGRABLE_MIN : 11488 !f:real->real g:real->real s. 11489 f absolutely_integrable_on s /\ g absolutely_integrable_on s 11490 ==> (\x. (min (f(x)) (g(x))):real) 11491 absolutely_integrable_on s 11492Proof 11493 REPEAT GEN_TAC THEN DISCH_TAC THEN 11494 FIRST_ASSUM(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_SUB) THEN 11495 DISCH_THEN(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_ABS) THEN 11496 FIRST_ASSUM(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_ADD) THEN 11497 REWRITE_TAC[AND_IMP_INTRO] THEN 11498 DISCH_THEN(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_SUB) THEN 11499 DISCH_THEN(MP_TAC o SPEC ``inv(&2:real)`` o 11500 MATCH_MP ABSOLUTELY_INTEGRABLE_CMUL) THEN 11501 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_TERM_TAC THEN 11502 REWRITE_TAC[FUN_EQ_THM] THEN 11503 SIMP_TAC std_ss [min_def] THEN REPEAT STRIP_TAC THEN 11504 ONCE_REWRITE_TAC [REAL_MUL_SYM] THEN REWRITE_TAC [GSYM real_div] THEN 11505 SIMP_TAC std_ss [REAL_EQ_LDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 11506 Cases_on `f x <= g x` >> rw [] >> REAL_ASM_ARITH_TAC 11507QED 11508 11509val ABSOLUTELY_INTEGRABLE_ABS_EQ = store_thm ("ABSOLUTELY_INTEGRABLE_ABS_EQ", 11510 ``!f:real->real s. 11511 f absolutely_integrable_on s <=> 11512 f integrable_on s /\ 11513 (\x. (abs(f(x))):real) integrable_on s``, 11514 REPEAT GEN_TAC THEN EQ_TAC THEN 11515 SIMP_TAC std_ss [ABSOLUTELY_INTEGRABLE_ABS, 11516 ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE] THEN 11517 SUBGOAL_THEN 11518 ``!f:real->real. 11519 f integrable_on univ(:real) /\ 11520 (\x. (abs(f(x))):real) integrable_on univ(:real) 11521 ==> f absolutely_integrable_on univ(:real)`` 11522 ASSUME_TAC THENL 11523 [ALL_TAC, 11524 ONCE_REWRITE_TAC[GSYM ABSOLUTELY_INTEGRABLE_RESTRICT_UNIV, 11525 GSYM INTEGRABLE_RESTRICT_UNIV] THEN 11526 DISCH_THEN(fn th => FIRST_X_ASSUM MATCH_MP_TAC THEN MP_TAC th) THEN 11527 MATCH_MP_TAC MONO_AND THEN REWRITE_TAC[] THEN MATCH_MP_TAC EQ_IMPLIES THEN 11528 AP_THM_TAC THEN AP_TERM_TAC THEN REWRITE_TAC[FUN_EQ_THM] THEN 11529 SIMP_TAC std_ss [] THEN REPEAT STRIP_TAC THEN 11530 ASM_SIMP_TAC std_ss [] THEN 11531 COND_CASES_TAC THEN ASM_REWRITE_TAC[ABS_0]] THEN 11532 REPEAT STRIP_TAC THEN 11533 MATCH_MP_TAC BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE THEN 11534 ASM_REWRITE_TAC[HAS_BOUNDED_SETVARIATION_ON_UNIV] THEN 11535 EXISTS_TAC 11536 ``sum ((1:num)..(1:num)) 11537 (\i. integral univ(:real) 11538 (\x. (abs ((f:real->real) x)):real))`` THEN 11539 X_GEN_TAC ``d:(real->bool)->bool`` THEN DISCH_TAC THEN 11540 MATCH_MP_TAC REAL_LE_TRANS THEN 11541 EXISTS_TAC ``sum d (\k. sum ((1:num)..(1:num)) 11542 (\i. integral k 11543 (\x. (abs ((f:real->real) x)):real)))`` THEN 11544 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN CONJ_TAC THENL 11545 [MATCH_MP_TAC SUM_LE THEN 11546 UNDISCH_TAC ``d division_of BIGUNION d`` THEN DISCH_TAC THEN 11547 FIRST_ASSUM(fn t => ASM_SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION t]) THEN 11548 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN DISCH_TAC THEN 11549 MATCH_MP_TAC REAL_LE_TRANS THEN 11550 EXISTS_TAC ``sum ((1:num)..(1:num)) 11551 (\i. abs((integral (interval[a,b]) (f:real->real))))`` THEN 11552 REWRITE_TAC[ABS_LE_L1] THEN MATCH_MP_TAC SUM_LE_NUMSEG THEN 11553 X_GEN_TAC ``k:num`` THEN STRIP_TAC THEN SIMP_TAC std_ss [] THEN 11554 MATCH_MP_TAC(REAL_ARITH ``x <= y /\ -x <= y ==> abs(x) <= y:real``) THEN 11555 ASM_SIMP_TAC std_ss [] THEN 11556 SUBGOAL_THEN ``(f:real->real) integrable_on interval[a,b] /\ 11557 (\x. (abs (f x)):real) integrable_on interval[a,b]`` 11558 STRIP_ASSUME_TAC THENL 11559 [CONJ_TAC THEN MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 11560 EXISTS_TAC ``univ(:real)`` THEN ASM_REWRITE_TAC[SUBSET_UNIV], 11561 ALL_TAC] THEN 11562 ASM_SIMP_TAC std_ss [GSYM INTEGRAL_NEG] THEN 11563 CONJ_TAC THEN MATCH_MP_TAC INTEGRAL_COMPONENT_LE THEN 11564 ASM_SIMP_TAC std_ss [INTEGRABLE_NEG] THEN 11565 REPEAT STRIP_TAC THEN REAL_ARITH_TAC, 11566 ALL_TAC] THEN 11567 ONCE_REWRITE_TAC [METIS [] ``(\i. integral k (\x. abs (f x))) = 11568 (\k. (\i. integral k (\x. abs (f x)))) k``] THEN 11569 W(MP_TAC o PART_MATCH (lhs o rand) SUM_SWAP o lhand o snd) THEN 11570 ASM_REWRITE_TAC[FINITE_NUMSEG] THEN DISCH_THEN SUBST_ALL_TAC THEN 11571 MATCH_MP_TAC SUM_LE_NUMSEG THEN X_GEN_TAC ``k:num`` THEN STRIP_TAC THEN 11572 SIMP_TAC std_ss [] THEN 11573 MATCH_MP_TAC REAL_LE_TRANS THEN 11574 EXISTS_TAC 11575 ``(integral (BIGUNION d) (\x. (abs ((f:real->real) x)):real))`` THEN 11576 CONJ_TAC THENL 11577 [ASM_SIMP_TAC std_ss [] THEN 11578 MATCH_MP_TAC REAL_EQ_IMP_LE THEN 11579 CONV_TAC SYM_CONV THEN MATCH_MP_TAC INTEGRAL_COMBINE_DIVISION_TOPDOWN THEN 11580 ASM_REWRITE_TAC[], 11581 MATCH_MP_TAC INTEGRAL_SUBSET_COMPONENT_LE THEN 11582 ASM_SIMP_TAC std_ss [SUBSET_UNIV, ABS_POS]] THEN 11583 MATCH_MP_TAC INTEGRABLE_ON_SUBDIVISION THEN 11584 MAP_EVERY EXISTS_TAC [``univ(:real)``, ``d:(real->bool)->bool``] THEN 11585 ASM_REWRITE_TAC[SUBSET_UNIV]); 11586 11587val NONNEGATIVE_ABSOLUTELY_INTEGRABLE = store_thm ("NONNEGATIVE_ABSOLUTELY_INTEGRABLE", 11588 ``!f:real->real s. 11589 (!x i. x IN s ==> &0 <= f(x)) /\ 11590 f integrable_on s 11591 ==> f absolutely_integrable_on s``, 11592 SIMP_TAC std_ss [ABSOLUTELY_INTEGRABLE_ABS_EQ] THEN 11593 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRABLE_EQ THEN 11594 EXISTS_TAC ``f:real->real`` THEN 11595 ASM_SIMP_TAC std_ss [abs]); 11596 11597val ABSOLUTELY_INTEGRABLE_INTEGRABLE_BOUND = store_thm ("ABSOLUTELY_INTEGRABLE_INTEGRABLE_BOUND", 11598 ``!f:real->real g s. 11599 (!x. x IN s ==> abs(f x) <= (g x)) /\ 11600 f integrable_on s /\ g integrable_on s 11601 ==> f absolutely_integrable_on s``, 11602 SUBGOAL_THEN 11603 ``!f:real->real g. 11604 (!x. abs(f x) <= (g x)) /\ 11605 f integrable_on univ(:real) /\ g integrable_on univ(:real) 11606 ==> f absolutely_integrable_on univ(:real)`` 11607 ASSUME_TAC THENL 11608 [ALL_TAC, 11609 ONCE_REWRITE_TAC[GSYM INTEGRABLE_RESTRICT_UNIV, GSYM 11610 ABSOLUTELY_INTEGRABLE_RESTRICT_UNIV] THEN 11611 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 11612 EXISTS_TAC ``(\x. if x IN s then g x else 0):real->real`` THEN 11613 ASM_SIMP_TAC std_ss [] THEN GEN_TAC THEN COND_CASES_TAC THEN 11614 ASM_SIMP_TAC std_ss [REAL_LE_REFL, ABS_0]] THEN 11615 REPEAT STRIP_TAC THEN 11616 MATCH_MP_TAC BOUNDED_SETVARIATION_ABSOLUTELY_INTEGRABLE THEN 11617 ASM_REWRITE_TAC[HAS_BOUNDED_SETVARIATION_ON_UNIV] THEN 11618 EXISTS_TAC ``integral univ(:real) g`` THEN 11619 X_GEN_TAC ``d:(real->bool)->bool`` THEN DISCH_TAC THEN 11620 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 11621 MATCH_MP_TAC REAL_LE_TRANS THEN 11622 EXISTS_TAC ``sum d (\k. (integral k (g:real->real)))`` THEN 11623 CONJ_TAC THENL 11624 [MATCH_MP_TAC SUM_LE THEN ASM_REWRITE_TAC[] THEN 11625 UNDISCH_TAC ``d division_of BIGUNION d`` THEN DISCH_TAC THEN 11626 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 11627 REPEAT STRIP_TAC THEN 11628 MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN ASM_REWRITE_TAC[] THEN 11629 CONJ_TAC THEN MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 11630 EXISTS_TAC ``univ(:real)`` THEN ASM_REWRITE_TAC[SUBSET_UNIV], 11631 ALL_TAC] THEN 11632 MATCH_MP_TAC REAL_LE_TRANS THEN 11633 EXISTS_TAC ``(integral (BIGUNION d:real->bool) g)`` THEN CONJ_TAC THENL 11634 [MATCH_MP_TAC(REAL_ARITH ``(x = y:real) ==> y <= x``) THEN 11635 ASM_SIMP_TAC std_ss [o_DEF] THEN 11636 MATCH_MP_TAC INTEGRAL_COMBINE_DIVISION_BOTTOMUP THEN 11637 FIRST_ASSUM(fn th => ASM_REWRITE_TAC[MATCH_MP FORALL_IN_DIVISION th]) THEN 11638 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 11639 EXISTS_TAC ``univ(:real)`` THEN ASM_REWRITE_TAC[SUBSET_UNIV], 11640 MATCH_MP_TAC INTEGRAL_SUBSET_DROP_LE THEN 11641 ASM_REWRITE_TAC[SUBSET_UNIV, IN_UNIV] THEN CONJ_TAC THENL 11642 [ALL_TAC, ASM_MESON_TAC[REAL_ARITH ``abs(x) <= y ==> &0 <= y:real``]] THEN 11643 MATCH_MP_TAC INTEGRABLE_ON_SUBDIVISION THEN 11644 MAP_EVERY EXISTS_TAC [``univ(:real)``, ``d:(real->bool)->bool``] THEN 11645 ASM_REWRITE_TAC[SUBSET_UNIV]]); 11646 11647val ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_BOUND = store_thm ("ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_BOUND", 11648 ``!f:real->real g:real->real s. 11649 (!x. x IN s ==> abs(f x) <= abs(g x)) /\ 11650 f integrable_on s /\ g absolutely_integrable_on s 11651 ==> f absolutely_integrable_on s``, 11652 REPEAT STRIP_TAC THEN 11653 FIRST_X_ASSUM(STRIP_ASSUME_TAC o REWRITE_RULE 11654 [absolutely_integrable_on]) THEN 11655 MP_TAC(ISPECL 11656 [``f:real->real``, ``(\x. abs((g:real->real) x))``, 11657 ``s:real->bool``] ABSOLUTELY_INTEGRABLE_INTEGRABLE_BOUND) THEN 11658 ASM_SIMP_TAC std_ss []); 11659 11660val ABSOLUTELY_INTEGRABLE_INF = store_thm ("ABSOLUTELY_INTEGRABLE_INF", 11661 ``!fs s:real->bool k:'a->bool. 11662 FINITE k /\ ~(k = {}) /\ 11663 (!i. i IN k ==> (\x. (fs x i)) absolutely_integrable_on s) 11664 ==> (\x. (inf (IMAGE (fs x) k))) absolutely_integrable_on s``, 11665 GEN_TAC THEN GEN_TAC THEN REWRITE_TAC[IMP_CONJ] THEN 11666 ONCE_REWRITE_TAC [METIS [] 11667 ``!k. (k <> {} ==> 11668 (!i. i IN k ==> (\x. fs x i) absolutely_integrable_on s) ==> 11669 (\x. inf (IMAGE (fs x) k)) absolutely_integrable_on s) = 11670 (\k. k <> {} ==> 11671 (!i. i IN k ==> (\x. fs x i) absolutely_integrable_on s) ==> 11672 (\x. inf (IMAGE (fs x) k)) absolutely_integrable_on s) k``] THEN 11673 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 11674 SIMP_TAC std_ss [IMAGE_EMPTY, IMAGE_INSERT] THEN 11675 SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM] THEN 11676 SIMP_TAC std_ss [INF_INSERT_FINITE, IMAGE_FINITE, IMAGE_EQ_EMPTY] THEN 11677 MAP_EVERY X_GEN_TAC [``k:'a->bool``, ``a:'a``] THEN 11678 ASM_CASES_TAC ``k:'a->bool = {}`` THEN ASM_REWRITE_TAC[] THEN 11679 SIMP_TAC std_ss [IN_SING, LEFT_FORALL_IMP_THM, EXISTS_REFL] THEN 11680 REWRITE_TAC[AND_IMP_INTRO, GSYM CONJ_ASSOC] THEN REPEAT STRIP_TAC THEN 11681 ONCE_REWRITE_TAC [METIS [] ``(\(x :real). 11682 min ((fs :real -> 'a -> real) x (a :'a)) 11683 (inf (IMAGE (fs x) (k :'a -> bool)))) = 11684 (\x. min ((\x. fs x a) x) ((\x. inf (IMAGE (fs x) k)) x))``] THEN 11685 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_MIN THEN 11686 CONJ_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INSERT] THEN 11687 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 11688 ASM_REWRITE_TAC[IN_INSERT]); 11689 11690val ABSOLUTELY_INTEGRABLE_SUP = store_thm ("ABSOLUTELY_INTEGRABLE_SUP", 11691 ``!fs s:real->bool k:'a->bool. 11692 FINITE k /\ ~(k = {}) /\ 11693 (!i. i IN k ==> (\x. (fs x i)) absolutely_integrable_on s) 11694 ==> (\x. (sup (IMAGE (fs x) k))) absolutely_integrable_on s``, 11695 GEN_TAC THEN GEN_TAC THEN REWRITE_TAC[IMP_CONJ] THEN 11696 ONCE_REWRITE_TAC [METIS [] 11697 ``!k. (k <> {} ==> 11698 (!i. i IN k ==> (\x. fs x i) absolutely_integrable_on s) ==> 11699 (\x. sup (IMAGE (fs x) k)) absolutely_integrable_on s) = 11700 (\k. k <> {} ==> 11701 (!i. i IN k ==> (\x. fs x i) absolutely_integrable_on s) ==> 11702 (\x. sup (IMAGE (fs x) k)) absolutely_integrable_on s) k``] THEN 11703 MATCH_MP_TAC FINITE_INDUCT THEN SIMP_TAC std_ss [IMAGE_EMPTY, IMAGE_INSERT] THEN 11704 SIMP_TAC std_ss [GSYM RIGHT_FORALL_IMP_THM] THEN 11705 SIMP_TAC std_ss [SUP_INSERT_FINITE, IMAGE_FINITE, IMAGE_EQ_EMPTY] THEN 11706 MAP_EVERY X_GEN_TAC [``k:'a->bool``, ``a:'a``] THEN 11707 ASM_CASES_TAC ``k:'a->bool = {}`` THEN ASM_REWRITE_TAC[] THEN 11708 SIMP_TAC std_ss [IN_SING, LEFT_FORALL_IMP_THM, EXISTS_REFL] THEN 11709 REWRITE_TAC[AND_IMP_INTRO, GSYM CONJ_ASSOC] THEN REPEAT STRIP_TAC THEN 11710 ONCE_REWRITE_TAC [METIS [] 11711 ``(\x. max ((fs :real -> 'a -> real) x a) (sup (IMAGE (fs x) k))) = 11712 (\x. max ((\x. fs x a) x) ((\x. sup (IMAGE (fs x) k)) x))``] THEN 11713 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_MAX THEN 11714 CONJ_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INSERT] THEN 11715 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 11716 ASM_REWRITE_TAC[IN_INSERT]); 11717 11718val ABSOLUTELY_INTEGRABLE_CONTINUOUS = store_thm ("ABSOLUTELY_INTEGRABLE_CONTINUOUS", 11719 ``!f:real->real a b. 11720 f continuous_on interval[a,b] 11721 ==> f absolutely_integrable_on interval[a,b]``, 11722 REPEAT STRIP_TAC THEN 11723 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INTEGRABLE_BOUND THEN 11724 SUBGOAL_THEN ``compact(IMAGE (f:real->real) (interval[a,b]))`` MP_TAC THENL 11725 [ASM_SIMP_TAC std_ss [COMPACT_CONTINUOUS_IMAGE, COMPACT_INTERVAL], ALL_TAC] THEN 11726 DISCH_THEN(MP_TAC o MATCH_MP COMPACT_IMP_BOUNDED) THEN 11727 SIMP_TAC std_ss [BOUNDED_POS, FORALL_IN_IMAGE] THEN 11728 DISCH_THEN(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) THEN 11729 EXISTS_TAC ``\x:real. (B:real)`` THEN 11730 ASM_SIMP_TAC std_ss [INTEGRABLE_CONST, INTEGRABLE_CONTINUOUS]); 11731 11732Theorem INTEGRABLE_MIN_CONST : 11733 !f s t. 11734 &0 <= t /\ (!x. x IN s ==> &0 <= f x) /\ 11735 (\x:real. (f x)) integrable_on s 11736 ==> (\x. (min (f x) t)) integrable_on s 11737Proof 11738 REPEAT STRIP_TAC THEN 11739 MATCH_MP_TAC INTEGRABLE_ON_ALL_INTERVALS_INTEGRABLE_BOUND THEN 11740 EXISTS_TAC ``\x:real. (f x):real`` THEN ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THENL 11741 [ (* goal 1 (of 2) *) 11742 REPEAT GEN_TAC THEN 11743 MP_TAC(ISPECL 11744 [``\x:real. if x IN s then f x else &0:real``, 11745 ``(\x. t):real->real``, 11746 ``interval[a:real,b]``] ABSOLUTELY_INTEGRABLE_MIN) THEN 11747 SIMP_TAC std_ss [] THEN 11748 KNOW_TAC ``(\(x :real). 11749 if x IN (s :real -> bool) then (f :real -> real) x 11750 else (0 :real)) absolutely_integrable_on 11751 interval [((a :real),(b :real))] /\ 11752 (\(x :real). (t :real)) absolutely_integrable_on interval [(a,b)]`` THENL 11753 [ (* goal 1.1 (of 2) *) 11754 SIMP_TAC std_ss [ABSOLUTELY_INTEGRABLE_CONTINUOUS, CONTINUOUS_ON_CONST] THEN 11755 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_ON_SUBINTERVAL THEN 11756 EXISTS_TAC ``univ(:real)`` THEN SIMP_TAC std_ss [SUBSET_UNIV] THEN 11757 SIMP_TAC std_ss [COND_RAND] THEN 11758 REWRITE_TAC[ABSOLUTELY_INTEGRABLE_RESTRICT_UNIV] THEN 11759 MATCH_MP_TAC NONNEGATIVE_ABSOLUTELY_INTEGRABLE THEN 11760 ASM_SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 11761 METIS_TAC[AND_IMP_INTRO, ETA_AX], 11762 (* goal 1.2 (of 2) *) 11763 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 11764 DISCH_THEN(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE) THEN 11765 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_TERM_TAC THEN 11766 REWRITE_TAC[FUN_EQ_THM] THEN GEN_TAC THEN SIMP_TAC std_ss [] THEN 11767 COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [] THEN 11768 REWRITE_TAC [min_def] THEN fs [] ], 11769 (* goal 2 (of 2) *) 11770 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 11771 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN 11772 RW_TAC real_ss [min_def] >> ASM_REAL_ARITH_TAC ] 11773QED 11774 11775val ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_COMPONENT_UBOUND = store_thm ("ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_COMPONENT_UBOUND", 11776 ``!f:real->real g:real->real s. 11777 (!x i. x IN s ==> f(x) <= g(x)) /\ 11778 f integrable_on s /\ g absolutely_integrable_on s 11779 ==> f absolutely_integrable_on s``, 11780 REPEAT STRIP_TAC THEN SUBGOAL_THEN 11781 ``(\x. (g:real->real)(x) - (g(x) - f(x))) absolutely_integrable_on s`` 11782 MP_TAC THENL 11783 [ONCE_REWRITE_TAC [METIS [] ``(\x. g x - (g x - f x:real)) = 11784 (\x. g x - (\x. (g x - f x)) x)``] THEN 11785 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_SUB THEN 11786 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC NONNEGATIVE_ABSOLUTELY_INTEGRABLE THEN 11787 ASM_SIMP_TAC std_ss [REAL_SUB_LE] THEN 11788 MATCH_MP_TAC INTEGRABLE_SUB THEN 11789 ASM_SIMP_TAC std_ss [ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE], 11790 SIMP_TAC std_ss[REAL_ARITH ``x - (x - y):real = y``, ETA_AX]]); 11791 11792val ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_COMPONENT_LBOUND = store_thm ("ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_COMPONENT_LBOUND", 11793 ``!f:real->real g:real->real s. 11794 (!x i. x IN s ==> f(x) <= g(x)) /\ 11795 f absolutely_integrable_on s /\ g integrable_on s 11796 ==> g absolutely_integrable_on s``, 11797 REPEAT STRIP_TAC THEN SUBGOAL_THEN 11798 ``(\x. (f:real->real)(x) + (g(x) - f(x))) absolutely_integrable_on s`` 11799 MP_TAC THENL 11800 [ONCE_REWRITE_TAC [METIS [] ``(\x. f x + (g x - f x:real)) = 11801 (\x. f x + (\x. (g x - f x)) x)``] THEN 11802 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_ADD THEN 11803 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC NONNEGATIVE_ABSOLUTELY_INTEGRABLE THEN 11804 ASM_SIMP_TAC std_ss [REAL_SUB_LE] THEN 11805 MATCH_MP_TAC INTEGRABLE_SUB THEN 11806 ASM_SIMP_TAC std_ss [ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE], 11807 SIMP_TAC std_ss [REAL_ARITH ``y + (x - y):real = x``, ETA_AX]]); 11808 11809val ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_UBOUND = store_thm ("ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_UBOUND", 11810 ``!f:real->real g:real->real s. 11811 (!x. x IN s ==> f(x) <= g(x)) /\ 11812 f integrable_on s /\ g absolutely_integrable_on s 11813 ==> f absolutely_integrable_on s``, 11814 REPEAT STRIP_TAC THEN MATCH_MP_TAC 11815 ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_COMPONENT_UBOUND THEN 11816 EXISTS_TAC ``g:real->real`` THEN 11817 ASM_SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 11818 ASM_SIMP_TAC std_ss [AND_IMP_INTRO]); 11819 11820val ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_LBOUND = store_thm ("ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_LBOUND", 11821 ``!f:real->real g:real->real s. 11822 (!x. x IN s ==> f(x) <= g(x)) /\ 11823 f absolutely_integrable_on s /\ g integrable_on s 11824 ==> g absolutely_integrable_on s``, 11825 REPEAT STRIP_TAC THEN MATCH_MP_TAC 11826 ABSOLUTELY_INTEGRABLE_ABSOLUTELY_INTEGRABLE_COMPONENT_LBOUND THEN 11827 EXISTS_TAC ``f:real->real`` THEN 11828 ASM_SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 11829 ASM_SIMP_TAC std_ss [AND_IMP_INTRO]); 11830 11831(* ------------------------------------------------------------------------- *) 11832(* Relating vector integrals to integrals of components. *) 11833(* ------------------------------------------------------------------------- *) 11834 11835val HAS_INTEGRAL_COMPONENTWISE = store_thm ("HAS_INTEGRAL_COMPONENTWISE", 11836 ``!f:real->real s y. 11837 (f has_integral y) s <=> ((\x. (f x)) has_integral (y)) s``, 11838 METIS_TAC [ETA_AX]); 11839 11840val INTEGRABLE_COMPONENTWISE = store_thm ("INTEGRABLE_COMPONENTWISE", 11841 ``!f:real->real s. 11842 f integrable_on s <=> 11843 (\x. (f x)) integrable_on s``, 11844 METIS_TAC [ETA_AX]); 11845 11846val INTEGRAL_COMPONENT = store_thm ("INTEGRAL_COMPONENT", 11847 ``!f:real->real s. 11848 f integrable_on s 11849 ==> ((integral s f) = integral s (\x. (f x)))``, 11850 METIS_TAC [ETA_AX]); 11851 11852val ABSOLUTELY_INTEGRABLE_COMPONENTWISE = store_thm ("ABSOLUTELY_INTEGRABLE_COMPONENTWISE", 11853 ``!f:real->real s. 11854 f absolutely_integrable_on s <=> 11855 ((\x. (f x)) absolutely_integrable_on s)``, 11856 METIS_TAC [ETA_AX]); 11857 11858(* ------------------------------------------------------------------------- *) 11859(* Dominated convergence. *) 11860(* ------------------------------------------------------------------------- *) 11861 11862val DOMINATED_CONVERGENCE = store_thm ("DOMINATED_CONVERGENCE", 11863 ``!f:num->real->real g h s. 11864 (!k. (f k) integrable_on s) /\ h integrable_on s /\ 11865 (!k x. x IN s ==> abs(f k x) <= (h x)) /\ 11866 (!x. x IN s ==> ((\k. f k x) --> g x) sequentially) 11867 ==> g integrable_on s /\ 11868 ((\k. integral s (f k)) --> integral s g) sequentially``, 11869 REPEAT GEN_TAC THEN STRIP_TAC THEN 11870 MP_TAC(GEN ``m:num`` 11871 (ISPECL [``\k:num x:real. inf {(f j x) | j IN (m..(m+k))}``, 11872 ``\x:real. inf {(f j x) | m:num <= j}``, 11873 ``s:real->bool``] 11874 MONOTONE_CONVERGENCE_DECREASING)) THEN SIMP_TAC std_ss [] THEN 11875 KNOW_TAC ``!m. ((!(k :num). 11876 (\(x :real). 11877 inf 11878 {(f :num -> real -> real) j x | 11879 j IN (m :num) .. m + k}) integrable_on (s :real -> bool)) /\ 11880 (!(k :num) (x :real). 11881 x IN s ==> 11882 inf {f j x | j IN m .. m + SUC k} <= 11883 inf {f j x | j IN m .. m + k}) /\ 11884 (!(x :real). 11885 x IN s ==> 11886 (((\(k :num). inf {f j x | j IN m .. m + k}) --> 11887 inf {f j x | m <= j}) sequentially :bool)) /\ 11888 (bounded 11889 {integral s (\(x :real). inf {f j x | j IN m .. m + k}) | 11890 k IN univ((:num) :num itself)} :bool))`` THENL (* 2 goals *) 11891 [X_GEN_TAC ``m:num`` THEN REPEAT CONJ_TAC THENL (* 4 goals *) 11892 [GEN_TAC THEN MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN 11893 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 11894 ONCE_REWRITE_TAC [METIS [] ``(\j. f j x) = (\x. (\j. f j x)) x``] THEN 11895 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INF THEN 11896 SIMP_TAC std_ss [FINITE_NUMSEG, NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 11897 ASM_SIMP_TAC std_ss [METIS [ETA_AX] ``(\x. f i x) = f i``] THEN 11898 REPEAT STRIP_TAC THEN 11899 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INTEGRABLE_BOUND THEN 11900 EXISTS_TAC ``h:real->real`` THEN ASM_REWRITE_TAC[], 11901 11902 REPEAT STRIP_TAC THEN SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 11903 MATCH_MP_TAC REAL_LE_INF_SUBSET THEN 11904 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 11905 CONJ_TAC THENL 11906 [MATCH_MP_TAC IMAGE_SUBSET THEN 11907 REWRITE_TAC[SUBSET_NUMSEG] THEN ARITH_TAC, 11908 ALL_TAC] THEN 11909 SIMP_TAC std_ss [FORALL_IN_IMAGE] THEN 11910 ONCE_REWRITE_TAC [METIS [] 11911 ``(b <= (f:num->real->real) j x) <=> b <= (\j. f j x) j``] THEN 11912 MATCH_MP_TAC LOWER_BOUND_FINITE_SET_REAL THEN 11913 REWRITE_TAC[FINITE_NUMSEG], 11914 11915 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 11916 REWRITE_TAC[LIM_SEQUENTIALLY] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 11917 REWRITE_TAC[dist] THEN 11918 MP_TAC(SPEC ``{((f:num->real->real) j x) | m <= j}`` INF) THEN 11919 ABBREV_TAC ``i = inf {(f:num->real->real) j x | m <= j}`` THEN 11920 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 11921 IMAGE (\j. f j x) {j | m <= j}``] THEN 11922 SIMP_TAC std_ss [FORALL_IN_IMAGE, EXISTS_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 11923 SIMP_TAC std_ss [GSPECIFICATION, EXTENSION, NOT_IN_EMPTY] THEN 11924 KNOW_TAC ``(?(x :num). (m :num) <= x) /\ (?(b :real). 11925 !(j :num). m <= j ==> b <= (f :num -> real -> real) j (x :real))`` THENL 11926 [CONJ_TAC THENL [METIS_TAC[LESS_EQ_REFL], ALL_TAC] THEN 11927 EXISTS_TAC ``-(h(x:real)):real`` THEN X_GEN_TAC ``j:num`` THEN 11928 FIRST_X_ASSUM(MP_TAC o SPECL [``j:num``, ``x:real``]) THEN 11929 ASM_SIMP_TAC std_ss [] THEN REAL_ARITH_TAC, 11930 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 11931 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o SPEC ``i + e:real``)) THEN 11932 ASM_SIMP_TAC std_ss [REAL_ARITH ``&0 < e ==> ~(i + e <= i:real)``] THEN 11933 SIMP_TAC std_ss [NOT_FORALL_THM, NOT_IMP, REAL_NOT_LE] THEN 11934 DISCH_THEN (X_CHOOSE_TAC ``M:num``) THEN EXISTS_TAC ``M:num`` THEN 11935 X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 11936 UNDISCH_TAC ``m <= M /\ (f:num->real->real) M x < i + e`` THEN STRIP_TAC THEN 11937 FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 11938 ``y < i + e ==> i <= ix /\ ix <= y ==> abs(ix - i) < e:real``)) THEN 11939 CONJ_TAC THENL 11940 [EXPAND_TAC "i" THEN MATCH_MP_TAC REAL_LE_INF_SUBSET THEN 11941 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 11942 ``{(f:num->real->real) j x | j IN t} = 11943 IMAGE (\j. f j x) {j | j IN t}``] THEN 11944 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, SET_RULE ``{x | x IN s} = s``] THEN 11945 SIMP_TAC std_ss [NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 11946 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 11947 ``{(f:num->real->real) j x | m <= j} = 11948 IMAGE (\j. f j x) {j | m <= j}``] THEN 11949 CONJ_TAC THENL 11950 [MATCH_MP_TAC IMAGE_SUBSET THEN 11951 SIMP_TAC std_ss [SUBSET_DEF, IN_NUMSEG, GSPECIFICATION] THEN ARITH_TAC, 11952 SIMP_TAC std_ss [FORALL_IN_IMAGE, GSPECIFICATION] THEN ASM_MESON_TAC[]], 11953 ALL_TAC] THEN 11954 W(MP_TAC o C SPEC INF o rand o lhand o snd) THEN 11955 KNOW_TAC ``{(f :num -> real -> real) j (x :real) | 11956 j IN (m :num) .. m + (n :num)} <> ({} :real -> bool) /\ 11957 (?(b :real). !(x' :real). x' IN {f j x | j IN m .. m + n} ==> b <= x')`` THENL 11958 [ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 11959 ``{(f:num->real->real) j x | j IN t} = 11960 IMAGE (\j. f j x) {j | j IN t}``] THEN 11961 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, SET_RULE ``{x | x IN s} = s``] THEN 11962 REWRITE_TAC[NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 11963 SIMP_TAC std_ss [FORALL_IN_IMAGE, GSPECIFICATION] THEN 11964 EXISTS_TAC ``i:real`` THEN GEN_TAC THEN REWRITE_TAC[IN_NUMSEG] THEN 11965 DISCH_THEN(fn th => FIRST_ASSUM MATCH_MP_TAC THEN MP_TAC th) THEN 11966 ARITH_TAC, 11967 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 11968 SIMP_TAC std_ss [FORALL_IN_IMAGE] THEN 11969 DISCH_THEN(MATCH_MP_TAC o CONJUNCT1) THEN 11970 SIMP_TAC std_ss [GSPECIFICATION, IN_NUMSEG] THEN 11971 EXISTS_TAC ``M:num`` THEN ASM_SIMP_TAC arith_ss [], 11972 11973 REWRITE_TAC[bounded_def] THEN 11974 EXISTS_TAC ``integral s (h:real->real)`` THEN 11975 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 11976 SIMP_TAC std_ss [FORALL_IN_IMAGE, IN_UNIV] THEN 11977 X_GEN_TAC ``p:num`` THEN MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 11978 ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THENL 11979 [MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN 11980 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 11981 ONCE_REWRITE_TAC [METIS [] ``(\j. f j x) = (\x. (\j. f j x)) x``] THEN 11982 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INF THEN 11983 SIMP_TAC std_ss [FINITE_NUMSEG, NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 11984 ASM_REWRITE_TAC[METIS [ETA_AX] ``(\x. f i x) = f i``] THEN REPEAT STRIP_TAC THEN 11985 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INTEGRABLE_BOUND THEN 11986 EXISTS_TAC ``h:real->real`` THEN ASM_SIMP_TAC std_ss [], 11987 ALL_TAC] THEN 11988 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 11989 SIMP_TAC std_ss [] THEN 11990 MATCH_MP_TAC REAL_ABS_INF_LE THEN SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 11991 SIMP_TAC std_ss [FORALL_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 11992 ASM_SIMP_TAC std_ss [NUMSEG_EMPTY, NOT_LESS, LE_ADD] ], 11993 11994 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 11995 SIMP_TAC std_ss [FORALL_AND_THM] THEN STRIP_TAC ] THEN 11996 MP_TAC(GEN ``m:num`` 11997 (ISPECL [``\k:num x:real. sup {(f j x) | j IN (m..(m+k))}``, 11998 ``\x:real. sup {(f j x) | m:num <= j}``, 11999 ``s:real->bool``] 12000 MONOTONE_CONVERGENCE_INCREASING)) THEN 12001 SIMP_TAC std_ss [] THEN 12002 KNOW_TAC ``!m. ((!(k :num). 12003 (\(x :real). 12004 sup 12005 {(f :num -> real -> real) j x | 12006 j IN (m :num) .. m + k}) integrable_on (s :real -> bool)) /\ 12007 (!(k :num) (x :real). x IN s ==> 12008 sup {f j x | j IN m .. m + k} <= 12009 sup {f j x | j IN m .. m + SUC k}) /\ 12010 (!(x :real). x IN s ==> 12011 (((\(k :num). sup {f j x | j IN m .. m + k}) --> 12012 sup {f j x | m <= j}) sequentially :bool)) /\ 12013 (bounded {integral s (\(x :real). sup {f j x | j IN m .. m + k}) | 12014 k IN univ((:num) :num itself)} :bool))`` THENL 12015 [POP_ASSUM K_TAC THEN POP_ASSUM K_TAC THEN GEN_TAC THEN REPEAT CONJ_TAC THENL 12016 [GEN_TAC THEN MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN 12017 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 12018 ONCE_REWRITE_TAC [METIS [] ``(\j. f j x) = (\x. (\j. f j x)) x``] THEN 12019 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_SUP THEN 12020 SIMP_TAC std_ss [FINITE_NUMSEG, NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 12021 ASM_REWRITE_TAC[METIS [ETA_AX] ``(\x. f i x) = f i``] THEN 12022 REPEAT STRIP_TAC THEN 12023 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INTEGRABLE_BOUND THEN 12024 EXISTS_TAC ``h:real->real`` THEN ASM_REWRITE_TAC[], 12025 REPEAT STRIP_TAC THEN SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 12026 MATCH_MP_TAC REAL_SUP_LE_SUBSET THEN 12027 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 12028 CONJ_TAC THENL 12029 [MATCH_MP_TAC IMAGE_SUBSET THEN 12030 REWRITE_TAC[SUBSET_NUMSEG] THEN ARITH_TAC, 12031 ALL_TAC] THEN 12032 SIMP_TAC std_ss [FORALL_IN_IMAGE] THEN 12033 ONCE_REWRITE_TAC [METIS [] ``(((f:num->real->real) j x) <= b) = 12034 (((\j. f j x) j) <= b)``] THEN 12035 MATCH_MP_TAC UPPER_BOUND_FINITE_SET_REAL THEN 12036 REWRITE_TAC[FINITE_NUMSEG], 12037 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 12038 REWRITE_TAC[LIM_SEQUENTIALLY] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 12039 REWRITE_TAC[dist] THEN 12040 MP_TAC(SPEC ``{(f:num->real->real) j x | m <= j}`` SUP) THEN 12041 ABBREV_TAC ``i = sup {(f:num->real->real) j x | m <= j}`` THEN 12042 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 12043 ``{(f:num->real->real) j x | m <= j} = 12044 IMAGE (\j. (f:num->real->real) j x) {j | m <= j}``] THEN 12045 SIMP_TAC std_ss [FORALL_IN_IMAGE, EXISTS_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 12046 SIMP_TAC std_ss [GSPECIFICATION, EXTENSION, NOT_IN_EMPTY] THEN 12047 KNOW_TAC ``(?(x :num). (m :num) <= x) /\ (?(b :real). 12048 !(j :num). m <= j ==> (f :num -> real -> real) j (x :real) <= b)`` THENL 12049 [CONJ_TAC THENL [MESON_TAC[LESS_EQ_REFL], ALL_TAC] THEN 12050 EXISTS_TAC ``(h (x:real)):real`` THEN X_GEN_TAC ``j:num`` THEN 12051 FIRST_X_ASSUM(MP_TAC o SPECL [``j:num``, ``x:real``]) THEN 12052 ASM_SIMP_TAC std_ss [] THEN REAL_ARITH_TAC, 12053 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 12054 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o SPEC ``i - e:real``)) THEN 12055 ASM_SIMP_TAC std_ss [REAL_ARITH ``&0:real < e ==> ~(i <= i - e)``] THEN 12056 SIMP_TAC std_ss [NOT_FORALL_THM, NOT_IMP, REAL_NOT_LE] THEN 12057 DISCH_THEN (X_CHOOSE_TAC ``M:num``) THEN EXISTS_TAC ``M:num`` THEN 12058 X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 12059 UNDISCH_TAC `` m <= M /\ i - e < (f:num->real->real) M x`` THEN STRIP_TAC THEN 12060 FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 12061 ``i - e < y ==> ix <= i /\ y <= ix ==> abs(ix - i) < e:real``)) THEN 12062 CONJ_TAC THENL 12063 [EXPAND_TAC "i" THEN MATCH_MP_TAC REAL_SUP_LE_SUBSET THEN 12064 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 12065 ``{(f:num->real->real) j x | j IN t} = 12066 IMAGE (\j. f j x) {j | j IN t}``] THEN 12067 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, SET_RULE ``{x | x IN s} = s``] THEN 12068 REWRITE_TAC[NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 12069 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 12070 ``{(f:num->real->real) j x | m <= j} = 12071 IMAGE (\j. f j x) {j | m <= j}``] THEN CONJ_TAC THENL 12072 [MATCH_MP_TAC IMAGE_SUBSET THEN 12073 SIMP_TAC std_ss [SUBSET_DEF, IN_NUMSEG, GSPECIFICATION] THEN ARITH_TAC, 12074 SIMP_TAC std_ss [FORALL_IN_IMAGE, GSPECIFICATION] THEN ASM_MESON_TAC[]], 12075 ALL_TAC] THEN 12076 W(MP_TAC o C SPEC SUP o rand o rand o snd) THEN 12077 KNOW_TAC ``{(f:num->real->real) j x | j IN m .. m + n} <> {} /\ 12078 (?b. !x'. x' IN {f j x | j IN m .. m + n} ==> x' <= b)`` THENL 12079 [ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 12080 ``{(f:num->real->real) j x | j IN t} = 12081 IMAGE (\j. f j x) {j | j IN t}``] THEN 12082 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, SET_RULE ``{x | x IN s} = s``] THEN 12083 REWRITE_TAC[NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 12084 SIMP_TAC std_ss [FORALL_IN_IMAGE, GSPECIFICATION] THEN 12085 EXISTS_TAC ``i:real`` THEN GEN_TAC THEN REWRITE_TAC[IN_NUMSEG] THEN 12086 DISCH_THEN(fn th => FIRST_ASSUM MATCH_MP_TAC THEN MP_TAC th) THEN 12087 ARITH_TAC, DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 12088 SIMP_TAC std_ss [FORALL_IN_IMAGE] THEN 12089 DISCH_THEN(MATCH_MP_TAC o CONJUNCT1) THEN 12090 SIMP_TAC std_ss [GSPECIFICATION, IN_NUMSEG] THEN 12091 EXISTS_TAC ``M:num`` THEN ASM_SIMP_TAC arith_ss [], 12092 REWRITE_TAC[bounded_def] THEN 12093 EXISTS_TAC ``integral s (h:real->real)`` THEN 12094 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 12095 SIMP_TAC std_ss [FORALL_IN_IMAGE, IN_UNIV] THEN 12096 X_GEN_TAC ``p:num`` THEN MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 12097 ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THENL 12098 [MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN 12099 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 12100 ONCE_REWRITE_TAC [METIS [] ``(\j. f j x) = (\x. (\j. f j x)) x``] THEN 12101 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_SUP THEN 12102 SIMP_TAC std_ss [FINITE_NUMSEG, NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 12103 ASM_REWRITE_TAC[METIS [ETA_AX] ``(\x. f i x) = f i``] THEN REPEAT STRIP_TAC THEN 12104 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INTEGRABLE_BOUND THEN 12105 EXISTS_TAC ``h:real->real`` THEN ASM_REWRITE_TAC[], 12106 ALL_TAC] THEN 12107 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 12108 MATCH_MP_TAC REAL_ABS_SUP_LE THEN SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 12109 SIMP_TAC std_ss [FORALL_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 12110 ASM_SIMP_TAC std_ss [NUMSEG_EMPTY, NOT_LESS, LE_ADD]], 12111 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12112 SIMP_TAC std_ss [FORALL_AND_THM] THEN STRIP_TAC] THEN 12113 MP_TAC(ISPECL 12114 [``\k:num x:real. inf {(f j x) | k <= j}``, 12115 ``g:real->real``, 12116 ``s:real->bool``] 12117 MONOTONE_CONVERGENCE_INCREASING) THEN 12118 ASM_SIMP_TAC std_ss [] THEN 12119 KNOW_TAC ``(!(k :num) (x :real). x IN s ==> 12120 inf {(f:num->real->real) j x | k <= j} <= inf {f j x | SUC k <= j}) /\ 12121 (!(x :real). x IN s ==> 12122 (((\(k :num). inf {f j x | k <= j}) --> (g :real -> real) x) 12123 sequentially :bool)) /\ 12124 (bounded {integral s (\(x :real). inf {f j x | k <= j}) | 12125 k IN univ((:num) :num itself)} :bool)`` THENL 12126 12127 [ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 12128 IMAGE (\j. f j x) {j | m <= j}``] THEN 12129 CONJ_TAC THENL 12130 [REPEAT STRIP_TAC THEN MATCH_MP_TAC REAL_LE_INF_SUBSET THEN 12131 SIMP_TAC real_ss [IMAGE_EQ_EMPTY, SET_RULE ``{x | x IN s} = s``] THEN 12132 SIMP_TAC std_ss [EXTENSION, GSPECIFICATION, NOT_IN_EMPTY, NOT_LESS_EQUAL] THEN 12133 CONJ_TAC THENL [EXISTS_TAC ``k + 1:num`` THEN ARITH_TAC, ALL_TAC] THEN 12134 CONJ_TAC THENL 12135 [MATCH_MP_TAC IMAGE_SUBSET THEN 12136 SIMP_TAC std_ss [SUBSET_DEF, IN_NUMSEG, GSPECIFICATION] THEN ARITH_TAC, 12137 ALL_TAC] THEN 12138 SIMP_TAC std_ss [FORALL_IN_IMAGE, GSPECIFICATION] THEN 12139 EXISTS_TAC ``-(h(x:real)):real`` THEN REPEAT STRIP_TAC THEN 12140 MATCH_MP_TAC(REAL_ARITH ``abs(x) <= a ==> -a <= x:real``) THEN 12141 ASM_SIMP_TAC std_ss [], 12142 ALL_TAC] THEN 12143 CONJ_TAC THENL 12144 [X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 12145 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN ASM_SIMP_TAC std_ss [] THEN 12146 SIMP_TAC std_ss [LIM_SEQUENTIALLY] THEN 12147 DISCH_THEN(fn th => X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 12148 MP_TAC(SPEC ``e / &2:real`` th)) THEN 12149 ASM_REWRITE_TAC[REAL_HALF] THEN 12150 DISCH_THEN (X_CHOOSE_TAC ``M:num``) THEN EXISTS_TAC ``M:num`` THEN 12151 POP_ASSUM MP_TAC THEN REWRITE_TAC[dist] THEN 12152 STRIP_TAC THEN X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 12153 GEN_REWR_TAC RAND_CONV [GSYM REAL_HALF] THEN 12154 MATCH_MP_TAC(REAL_ARITH 12155 ``&0 < e / 2 /\ x <= e / &2 ==> x < e / 2 + e / 2:real``) THEN 12156 ASM_REWRITE_TAC[REAL_HALF] THEN MATCH_MP_TAC REAL_INF_ASCLOSE THEN 12157 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, FORALL_IN_IMAGE, GSPECIFICATION] THEN 12158 CONJ_TAC THENL [ALL_TAC, METIS_TAC[LESS_EQ_TRANS, REAL_LT_IMP_LE]] THEN 12159 SIMP_TAC std_ss [EXTENSION, NOT_IN_EMPTY, GSPECIFICATION, NOT_FORALL_THM] THEN 12160 MESON_TAC[LESS_EQ_REFL], 12161 ALL_TAC] THEN 12162 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 12163 ``{integral s (\x. inf (IMAGE (\j. (f:num->real->real) j x) 12164 {j | k <= j})) | k IN t} = 12165 IMAGE (\k. integral s (\x. inf (IMAGE (\j. (f:num->real->real) j x) 12166 {j | k <= j}))) {k | k IN t}``] THEN 12167 SIMP_TAC std_ss [bounded_def, FORALL_IN_IMAGE, GSPECIFICATION, IN_UNIV] THEN 12168 EXISTS_TAC ``(integral s (h:real->real))`` THEN 12169 X_GEN_TAC ``p:num`` THEN MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 12170 ASM_SIMP_TAC real_ss [GSYM SIMPLE_IMAGE_GEN] THEN X_GEN_TAC ``x:real`` THEN 12171 DISCH_TAC THEN MATCH_MP_TAC REAL_ABS_INF_LE THEN 12172 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 12173 IMAGE (\j. f j x) {j | m <= j}``] THEN 12174 SIMP_TAC std_ss [FORALL_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 12175 ASM_SIMP_TAC std_ss [GSPECIFICATION] THEN 12176 SIMP_TAC std_ss [EXTENSION, NOT_IN_EMPTY, GSPECIFICATION, NOT_FORALL_THM] THEN 12177 MESON_TAC[LESS_EQ_REFL], 12178 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12179 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)] THEN 12180 MP_TAC(ISPECL 12181 [``\k:num x:real. sup {(f j x) | k <= j}``, 12182 ``g:real->real``, 12183 ``s:real->bool``] MONOTONE_CONVERGENCE_DECREASING) THEN 12184 ASM_SIMP_TAC std_ss [] THEN 12185 KNOW_TAC ``(!(k :num) (x :real). 12186 x IN (s :real -> bool) ==> 12187 sup {(f :num -> real -> real) j x | SUC k <= j} <= 12188 sup {f j x | k <= j}) /\ 12189 (!(x :real). x IN s ==> 12190 (((\(k :num). sup {f j x | k <= j}) --> (g :real -> real) x) 12191 sequentially :bool)) /\ 12192 (bounded {integral s (\(x :real). sup {f j x | k <= j}) | 12193 k IN univ((:num) :num itself)} :bool)`` THENL 12194 [ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 12195 IMAGE (\j. f j x) {j | m <= j}``] THEN CONJ_TAC THENL 12196 [REPEAT STRIP_TAC THEN MATCH_MP_TAC REAL_SUP_LE_SUBSET THEN 12197 SIMP_TAC real_ss [IMAGE_EQ_EMPTY, SET_RULE ``{x | x IN s} = s``] THEN 12198 SIMP_TAC std_ss [EXTENSION, GSPECIFICATION, NOT_IN_EMPTY, NOT_LESS_EQUAL] THEN 12199 CONJ_TAC THENL [EXISTS_TAC ``k + 1:num`` THEN 12200 ASM_SIMP_TAC arith_ss [], ALL_TAC] THEN 12201 CONJ_TAC THENL 12202 [MATCH_MP_TAC IMAGE_SUBSET THEN 12203 SIMP_TAC std_ss [SUBSET_DEF, IN_NUMSEG, GSPECIFICATION] THEN ARITH_TAC, 12204 ALL_TAC] THEN 12205 SIMP_TAC std_ss [FORALL_IN_IMAGE, GSPECIFICATION] THEN 12206 EXISTS_TAC ``(h(x:real)):real`` THEN REPEAT STRIP_TAC THEN 12207 MATCH_MP_TAC(REAL_ARITH ``abs(x) <= a ==> x <= a:real``) THEN 12208 ASM_SIMP_TAC std_ss [], 12209 ALL_TAC] THEN 12210 CONJ_TAC THENL 12211 [X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 12212 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN ASM_SIMP_TAC std_ss [] THEN 12213 SIMP_TAC std_ss [LIM_SEQUENTIALLY] THEN 12214 DISCH_THEN(fn th => X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 12215 MP_TAC(SPEC ``e / &2:real`` th)) THEN 12216 ASM_REWRITE_TAC[REAL_HALF] THEN 12217 DISCH_THEN (X_CHOOSE_TAC ``M:num``) THEN EXISTS_TAC ``M:num`` THEN 12218 POP_ASSUM MP_TAC THEN REWRITE_TAC[dist] THEN 12219 STRIP_TAC THEN X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 12220 GEN_REWR_TAC RAND_CONV [GSYM REAL_HALF] THEN 12221 MATCH_MP_TAC(REAL_ARITH 12222 ``&0 < e / 2 /\ x <= e / &2 ==> x < e / 2 + e / 2:real``) THEN 12223 ASM_REWRITE_TAC[REAL_HALF] THEN MATCH_MP_TAC REAL_SUP_ASCLOSE THEN 12224 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, FORALL_IN_IMAGE, GSPECIFICATION] THEN 12225 CONJ_TAC THENL [ALL_TAC, METIS_TAC[LESS_EQ_TRANS, REAL_LT_IMP_LE]] THEN 12226 SIMP_TAC std_ss [EXTENSION, NOT_IN_EMPTY, GSPECIFICATION, NOT_FORALL_THM] THEN 12227 MESON_TAC[LESS_EQ_REFL], 12228 ALL_TAC] THEN 12229 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 12230 ``{integral s (\x. sup (IMAGE (\j. (f:num->real->real) j x) 12231 {j | k <= j})) | k IN t} = 12232 IMAGE (\k. integral s (\x. sup (IMAGE (\j. (f:num->real->real) j x) 12233 {j | k <= j}))) {k | k IN t}``] THEN 12234 SIMP_TAC std_ss [bounded_def, FORALL_IN_IMAGE, GSPECIFICATION, IN_UNIV] THEN 12235 EXISTS_TAC ``(integral s (h:real->real))`` THEN 12236 X_GEN_TAC ``p:num`` THEN MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 12237 ASM_SIMP_TAC real_ss [GSYM SIMPLE_IMAGE_GEN] THEN X_GEN_TAC ``x:real`` THEN 12238 DISCH_TAC THEN 12239 MATCH_MP_TAC REAL_ABS_SUP_LE THEN 12240 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 12241 IMAGE (\j. f j x) {j | m <= j}``] THEN 12242 SIMP_TAC std_ss [FORALL_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 12243 ASM_SIMP_TAC std_ss [GSPECIFICATION] THEN 12244 SIMP_TAC std_ss [EXTENSION, NOT_IN_EMPTY, GSPECIFICATION, NOT_FORALL_THM] THEN 12245 MESON_TAC[LESS_EQ_REFL], 12246 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12247 DISCH_THEN(ASSUME_TAC)] THEN 12248 ASM_REWRITE_TAC[LIM_SEQUENTIALLY] THEN 12249 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 12250 UNDISCH_TAC ``((\k. integral s (\x. inf {f j x | k <= j})) --> integral s g) 12251 sequentially`` THEN DISCH_TAC THEN 12252 FIRST_X_ASSUM (MP_TAC o REWRITE_RULE [LIM_SEQUENTIALLY]) THEN 12253 DISCH_THEN(MP_TAC o SPECL [``e:real``]) THEN ASM_REWRITE_TAC[] THEN 12254 DISCH_THEN(X_CHOOSE_TAC ``N1:num``) THEN 12255 UNDISCH_TAC ``((\k. integral s (\x. sup {f j x | k <= j})) --> integral s g) 12256 sequentially`` THEN DISCH_TAC THEN 12257 FIRST_X_ASSUM (MP_TAC o REWRITE_RULE[LIM_SEQUENTIALLY]) THEN 12258 DISCH_THEN(MP_TAC o SPECL [``e:real``]) THEN ASM_REWRITE_TAC[] THEN 12259 DISCH_THEN(X_CHOOSE_TAC ``N2:num``) THEN 12260 EXISTS_TAC ``N1 + N2:num`` THEN X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 12261 UNDISCH_TAC ``!n. N1 <= n ==> dist 12262 ((\k. integral s (\x. inf {(f:num->real->real) j x | k <= j})) n, 12263 integral s g) < e`` THEN DISCH_TAC THEN 12264 FIRST_X_ASSUM (MP_TAC o SPEC ``n:num``) THEN ASM_SIMP_TAC arith_ss [] THEN 12265 UNDISCH_TAC ``!n. N2 <= n ==> dist 12266 ((\k. integral s (\x. sup {(f:num->real->real) j x | k <= j})) n, 12267 integral s g) < e`` THEN DISCH_TAC THEN 12268 FIRST_X_ASSUM (MP_TAC o SPEC ``n:num``) THEN ASM_SIMP_TAC arith_ss [] THEN 12269 REWRITE_TAC[dist] THEN 12270 MATCH_MP_TAC(REAL_ARITH 12271 ``i0 <= i /\ i <= i1 12272 ==> abs(i1 - g) < e ==> abs(i0 - g) < e ==> abs(i - g) < e:real``) THEN 12273 CONJ_TAC THEN MATCH_MP_TAC INTEGRAL_DROP_LE THEN 12274 ASM_SIMP_TAC std_ss [] THEN X_GEN_TAC ``x:real`` THEN DISCH_TAC THENL 12275 [W(MP_TAC o C SPEC INF o rand o lhand o snd) THEN 12276 SIMP_TAC std_ss [] THEN 12277 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 12278 IMAGE (\j. f j x) {j | m <= j}``] THEN 12279 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, FORALL_IN_IMAGE, GSPECIFICATION] THEN 12280 KNOW_TAC ``{j | (n :num) <= j} <> ({} :num -> bool) /\ (?(b :real). 12281 !(j :num). n <= j ==> b <= (f :num -> real -> real) j (x :real))`` THENL 12282 [SIMP_TAC std_ss [EXTENSION, NOT_IN_EMPTY, GSPECIFICATION, NOT_FORALL_THM] THEN 12283 CONJ_TAC THENL [MESON_TAC[LESS_EQ_REFL], ALL_TAC] THEN 12284 EXISTS_TAC ``-(h(x:real)):real`` THEN GEN_TAC THEN DISCH_TAC THEN 12285 MATCH_MP_TAC(REAL_ARITH ``abs(x) <= a ==> -a <= x:real``) THEN 12286 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[], 12287 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12288 DISCH_THEN(MATCH_MP_TAC o CONJUNCT1) THEN REWRITE_TAC[LESS_EQ_REFL]], 12289 W(MP_TAC o C SPEC SUP o rand o rand o snd) THEN 12290 SIMP_TAC std_ss [] THEN 12291 ONCE_REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 12292 IMAGE (\j. f j x) {j | m <= j}``] THEN 12293 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, FORALL_IN_IMAGE, GSPECIFICATION] THEN 12294 KNOW_TAC ``{j | (n :num) <= j} <> ({} :num -> bool) /\ (?(b :real). 12295 !(j :num). n <= j ==> (f :num -> real -> real) j (x :real) <= b)`` THENL 12296 [SIMP_TAC std_ss [EXTENSION, NOT_IN_EMPTY, GSPECIFICATION, NOT_FORALL_THM] THEN 12297 CONJ_TAC THENL [MESON_TAC[LESS_EQ_REFL], ALL_TAC] THEN 12298 EXISTS_TAC ``(h(x:real)):real`` THEN GEN_TAC THEN DISCH_TAC THEN 12299 MATCH_MP_TAC(REAL_ARITH ``abs(x) <= a ==> x <= a:real``) THEN 12300 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[], 12301 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12302 DISCH_THEN(MATCH_MP_TAC o CONJUNCT1) THEN REWRITE_TAC[LESS_EQ_REFL]]]); 12303 12304val lemma = prove ( 12305 ``!f:num->real->real g h s. 12306 (!k. f k absolutely_integrable_on s) /\ 12307 h integrable_on s /\ 12308 (!x. x IN s ==> abs(g x) <= (h x)) /\ 12309 (!x. x IN s ==> ((\k. f k x) --> g x) sequentially) 12310 ==> g integrable_on s``, 12311 REPEAT STRIP_TAC THEN 12312 SUBGOAL_THEN ``(h:real->real) absolutely_integrable_on s`` 12313 ASSUME_TAC THENL 12314 [MATCH_MP_TAC NONNEGATIVE_ABSOLUTELY_INTEGRABLE THEN 12315 ASM_SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 12316 REWRITE_TAC[AND_IMP_INTRO] THEN 12317 METIS_TAC[REAL_LE_TRANS, ABS_POS], 12318 ALL_TAC] THEN 12319 MP_TAC(ISPECL 12320 [``\n:num x:real. 12321 (min (max (-((h x):real)) ((f n x))) ((h x)))``, 12322 ``g:real->real``, 12323 ``h:real->real``, 12324 ``s:real->bool``] DOMINATED_CONVERGENCE) THEN 12325 KNOW_TAC ``(!(k :num). 12326 (\(n :num) (x :real). 12327 min (max (-(h :real -> real) x) ((f :num -> real -> real) n x)) 12328 (h x)) k integrable_on (s :real -> bool)) /\ h integrable_on s /\ 12329 (!(k :num) (x :real). x IN s ==> 12330 abs ((\(n :num) (x :real). min (max (-h x) (f n x)) (h x)) k x) <= 12331 h x) /\ (!(x :real). x IN s ==> 12332 (((\(k :num). (\(n :num) (x :real). min (max (-h x) (f n x)) (h x)) k x) --> 12333 (g :real -> real) x) sequentially :bool))`` THENL 12334 [ASM_SIMP_TAC std_ss [], SIMP_TAC std_ss []] THEN REPEAT CONJ_TAC THENL 12335 [ (* goal 1 (of 3) *) 12336 X_GEN_TAC ``n:num`` THEN 12337 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN 12338 ONCE_REWRITE_TAC [METIS [] ``(\x. min (max (-h x) (f n x)) (h x):real) = 12339 (\x. min ((\x. max (-h x) (f n x)) x) (h x))``] THEN 12340 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_MIN THEN 12341 ASM_SIMP_TAC std_ss [ETA_AX] THEN 12342 ONCE_REWRITE_TAC [METIS [] ``(\x. max (-h x) ((f:num->real->real) n x)) = 12343 (\x. max ((\x. (-h x)) x) ((\x. (f n x)) x))``] THEN 12344 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_MAX THEN 12345 METIS_TAC [ETA_AX, ABSOLUTELY_INTEGRABLE_NEG], 12346 (* goal 2 (of 3) *) 12347 MAP_EVERY X_GEN_TAC [``n:num``, ``x:real``] THEN DISCH_TAC THEN 12348 SIMP_TAC std_ss [] THEN 12349 Know `&0 <= ((h:real->real) x)` 12350 >- METIS_TAC[REAL_LE_TRANS, ABS_POS] \\ 12351 RW_TAC real_ss [min_def, max_def] >> fs [] 12352 >- (Cases_on `0 <= f n x` >> rw [abs] \\ 12353 Q.PAT_X_ASSUM `-h x <= f n x` MP_TAC >> REAL_ARITH_TAC) 12354 >> rw [abs], 12355 (* goal 3 (of 3) *) 12356 X_GEN_TAC ``x:real`` THEN REWRITE_TAC[IN_DIFF] THEN STRIP_TAC THEN 12357 UNDISCH_TAC 12358 ``!x. x IN s ==> ((\n. (f:num->real->real) n x) --> g x) 12359 sequentially`` THEN 12360 DISCH_THEN(MP_TAC o SPEC ``x:real``) THEN ASM_REWRITE_TAC[] THEN 12361 REWRITE_TAC[tendsto] THEN DISCH_TAC THEN GEN_TAC THEN 12362 POP_ASSUM (MP_TAC o SPEC ``e:real``) THEN ASM_CASES_TAC ``&0 < e:real`` THEN 12363 ASM_REWRITE_TAC[] THEN 12364 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] EVENTUALLY_MONO) THEN 12365 X_GEN_TAC ``n:num`` THEN SIMP_TAC std_ss [] THEN 12366 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN 12367 ASM_REWRITE_TAC[dist] THEN KILL_TAC THEN 12368 REWRITE_TAC [min_def, max_def] THEN 12369 RW_TAC real_ss [] (* 2 subgoals *) 12370 >- ASM_REAL_ARITH_TAC \\ 12371 Cases_on `-h x <= f n x` >> fs [] \\ 12372 ASM_REAL_ARITH_TAC ]); 12373 12374val DOMINATED_CONVERGENCE_INTEGRABLE = store_thm ("DOMINATED_CONVERGENCE_INTEGRABLE", 12375 ``!f:num->real->real g h s. 12376 (!k. f k absolutely_integrable_on s) /\ 12377 h integrable_on s /\ 12378 (!k x. x IN s ==> abs(g x) <= (h x)) /\ 12379 (!x. x IN s ==> ((\k. f k x) --> g x) sequentially) 12380 ==> g integrable_on s``, 12381 REWRITE_TAC [lemma] ); 12382 12383val DOMINATED_CONVERGENCE_ABSOLUTELY_INTEGRABLE = store_thm ("DOMINATED_CONVERGENCE_ABSOLUTELY_INTEGRABLE", 12384 ``!f:num->real->real g h s. 12385 (!k. f k absolutely_integrable_on s) /\ 12386 h integrable_on s /\ 12387 (!k x. x IN s ==> abs(g x) <= (h x)) /\ 12388 (!x. x IN s ==> ((\k. f k x) --> g x) sequentially) 12389 ==> g absolutely_integrable_on s``, 12390 REPEAT STRIP_TAC THEN 12391 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INTEGRABLE_BOUND THEN 12392 EXISTS_TAC ``h:real->real`` THEN ASM_SIMP_TAC std_ss [] THEN 12393 MATCH_MP_TAC DOMINATED_CONVERGENCE_INTEGRABLE THEN 12394 EXISTS_TAC ``f:num->real->real`` THEN 12395 EXISTS_TAC ``h:real->real`` THEN ASM_REWRITE_TAC[]); 12396 12397val DOMINATED_CONVERGENCE_AE = store_thm ("DOMINATED_CONVERGENCE_AE", 12398 ``!f:num->real->real g h s t. 12399 (!k. (f k) integrable_on s) /\ h integrable_on s /\ negligible t /\ 12400 (!k x. x IN s DIFF t ==> abs(f k x) <= (h x)) /\ 12401 (!x. x IN s DIFF t ==> ((\k. f k x) --> g x) sequentially) 12402 ==> g integrable_on s /\ 12403 ((\k. integral s (f k)) --> integral s g) sequentially``, 12404 REPEAT GEN_TAC THEN STRIP_TAC THEN 12405 MP_TAC(ISPECL [``f:num->real->real``, ``g:real->real``, 12406 ``h:real->real``, ``s DIFF t:real->bool``] 12407 DOMINATED_CONVERGENCE) THEN 12408 ASM_SIMP_TAC std_ss [] THEN 12409 KNOW_TAC ``(!(k :num). 12410 (f :num -> real -> real) k integrable_on 12411 (s :real -> bool) DIFF (t :real -> bool)) /\ 12412 (h :real -> real) integrable_on s DIFF t`` THENL 12413 [REPEAT STRIP_TAC THEN 12414 MATCH_MP_TAC(REWRITE_RULE[AND_IMP_INTRO] INTEGRABLE_SPIKE_SET) THEN 12415 EXISTS_TAC ``s:real->bool`` THEN ASM_SIMP_TAC std_ss [], 12416 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12417 MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 12418 [MATCH_MP_TAC INTEGRABLE_SPIKE_SET, 12419 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN BINOP_TAC THEN 12420 TRY ABS_TAC THEN MATCH_MP_TAC INTEGRAL_SPIKE_SET]] THEN 12421 FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 12422 NEGLIGIBLE_SUBSET)) THEN 12423 SET_TAC[]); 12424 12425(* ------------------------------------------------------------------------- *) 12426(* A few more properties of negligible sets. *) 12427(* ------------------------------------------------------------------------- *) 12428 12429val NEGLIGIBLE_ON_UNIV = store_thm ("NEGLIGIBLE_ON_UNIV", 12430 ``!s. negligible s <=> (indicator s has_integral 0) univ(:real)``, 12431 GEN_TAC THEN EQ_TAC THENL [SIMP_TAC std_ss [NEGLIGIBLE], ALL_TAC] THEN 12432 DISCH_TAC THEN REWRITE_TAC[negligible] THEN 12433 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN 12434 SUBGOAL_THEN ``indicator s integrable_on interval[a:real,b]`` 12435 ASSUME_TAC THENL 12436 [MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 12437 EXISTS_TAC ``univ(:real)`` THEN ASM_MESON_TAC[SUBSET_UNIV, integrable_on], 12438 ASM_SIMP_TAC std_ss [GSYM INTEGRAL_EQ_HAS_INTEGRAL] THEN 12439 REWRITE_TAC[GSYM REAL_LE_ANTISYM] THEN 12440 CONJ_TAC THENL 12441 [FIRST_ASSUM(SUBST1_TAC o SYM o MATCH_MP INTEGRAL_UNIQUE) THEN 12442 MATCH_MP_TAC INTEGRAL_SUBSET_DROP_LE, 12443 MATCH_MP_TAC INTEGRAL_DROP_POS] THEN 12444 ASM_REWRITE_TAC[SUBSET_UNIV, DROP_INDICATOR_POS_LE] THEN 12445 ASM_MESON_TAC[integrable_on]]); 12446 12447val NEGLIGIBLE_COUNTABLE_BIGUNION = store_thm ("NEGLIGIBLE_COUNTABLE_BIGUNION", 12448 ``!s:num->real->bool. 12449 (!n. negligible(s n)) ==> negligible(BIGUNION {s(n) | n IN univ(:num)})``, 12450 REPEAT STRIP_TAC THEN 12451 MP_TAC(ISPECL [``\n. indicator(BIGUNION {(s:num->real->bool)(m) | m <= n})``, 12452 ``indicator(BIGUNION {(s:num->real->bool)(m) | m IN univ(:num)})``, 12453 ``univ(:real)``] MONOTONE_CONVERGENCE_INCREASING) THEN 12454 SUBGOAL_THEN 12455 ``!n. negligible(BIGUNION {(s:num->real->bool)(m) | m <= n})`` 12456 ASSUME_TAC THENL 12457 [GEN_TAC THEN MATCH_MP_TAC NEGLIGIBLE_BIGUNION THEN 12458 ONCE_REWRITE_TAC [METIS [] ``!n:num. m <= n <=> (\m. m <= n) m``] THEN 12459 ONCE_REWRITE_TAC[SIMPLE_IMAGE_GEN] THEN 12460 ASM_SIMP_TAC std_ss [IMAGE_FINITE, FINITE_NUMSEG_LE, FORALL_IN_IMAGE], 12461 ALL_TAC] THEN 12462 SUBGOAL_THEN 12463 ``!n:num. (indicator (BIGUNION {s m | m <= n})) integrable_on univ(:real)`` 12464 ASSUME_TAC THENL 12465 [METIS_TAC[NEGLIGIBLE_ON_UNIV, integrable_on], ALL_TAC] THEN 12466 SUBGOAL_THEN 12467 ``!n:num. integral univ(:real) (indicator (BIGUNION {s m | m <= n})) = 0`` 12468 ASSUME_TAC THENL 12469 [METIS_TAC[NEGLIGIBLE_ON_UNIV, INTEGRAL_UNIQUE], ALL_TAC] THEN 12470 ASM_SIMP_TAC std_ss [NEGLIGIBLE_ON_UNIV, LIM_CONST_EQ, 12471 TRIVIAL_LIMIT_SEQUENTIALLY] THEN 12472 KNOW_TAC ``(!(k :num) (x :real). 12473 x IN univ((:real) :real itself) ==> 12474 indicator (BIGUNION {(s :num -> real -> bool) m | m <= k}) x <= 12475 indicator (BIGUNION {s m | m <= SUC k}) x) /\ 12476 (!(x :real). 12477 x IN univ((:real) :real itself) ==> 12478 (((\(k :num). indicator (BIGUNION {s m | m <= k}) x) --> 12479 indicator (BIGUNION {s m | m IN univ((:num) :num itself)}) x) 12480 sequentially :bool)) /\ 12481 (bounded {(0 :real) | k IN univ((:num) :num itself)} :bool)`` THENL 12482 [ALL_TAC, DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 12483 METIS_TAC[INTEGRAL_EQ_HAS_INTEGRAL]] THEN 12484 REPEAT CONJ_TAC THENL 12485 [MAP_EVERY X_GEN_TAC [``k:num``, ``x:real``] THEN DISCH_TAC THEN 12486 REWRITE_TAC[indicator] THEN 12487 SUBGOAL_THEN 12488 ``x IN BIGUNION {(s:num->real->bool) m | m <= k} 12489 ==> x IN BIGUNION {s m | m <= SUC k}`` 12490 MP_TAC THENL 12491 [SPEC_TAC(``x:real``,``x:real``) THEN 12492 REWRITE_TAC[GSYM SUBSET_DEF] THEN MATCH_MP_TAC SUBSET_BIGUNION THEN 12493 ONCE_REWRITE_TAC [METIS [] ``!n:num. m <= n <=> (\m. m <= n) m``] THEN 12494 ONCE_REWRITE_TAC[SIMPLE_IMAGE_GEN] THEN MATCH_MP_TAC IMAGE_SUBSET THEN 12495 SIMP_TAC std_ss [SUBSET_DEF, GSPECIFICATION] THEN ARITH_TAC, 12496 BETA_TAC THEN 12497 REPEAT(COND_CASES_TAC THEN ASM_SIMP_TAC std_ss []) THEN 12498 SIMP_TAC std_ss [REAL_LE_REFL, REAL_POS]], 12499 X_GEN_TAC ``x:real`` THEN DISCH_THEN(K ALL_TAC) THEN 12500 MATCH_MP_TAC LIM_EVENTUALLY THEN 12501 REWRITE_TAC[EVENTUALLY_SEQUENTIALLY, indicator] THEN 12502 ASM_CASES_TAC ``x IN BIGUNION {(s:num->real->bool) m | m IN univ(:num)}`` THENL 12503 [FIRST_X_ASSUM(MP_TAC o SIMP_RULE std_ss [BIGUNION_GSPEC, 12504 METIS [] ``!n:num. m <= n <=> (\m. m <= n) m``]) THEN 12505 SIMP_TAC std_ss [GSPECIFICATION, IN_UNIV] THEN 12506 STRIP_TAC THEN EXISTS_TAC ``m:num`` THEN 12507 X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 12508 SIMP_TAC std_ss [BIGUNION_GSPEC, GSPECIFICATION] THEN METIS_TAC[], 12509 EXISTS_TAC ``0:num`` THEN X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 12510 ASM_SIMP_TAC std_ss [] THEN 12511 UNDISCH_TAC `` (x :real) NOTIN 12512 BIGUNION 12513 {(s :num -> real -> bool) m | m IN univ((:num) :num itself)}`` THEN 12514 DISCH_TAC THEN 12515 POP_ASSUM (MP_TAC o SIMP_RULE std_ss [BIGUNION_GSPEC]) THEN 12516 SIMP_TAC std_ss [BIGUNION_GSPEC, GSPECIFICATION, IN_UNIV]], 12517 REWRITE_TAC[SET_RULE ``{c | x | x IN UNIV} = {c}``, 12518 BOUNDED_INSERT, BOUNDED_EMPTY]]); 12519 12520val lemma = prove ( 12521 ``!f:real->real s. 12522 (!x. x IN s ==> &0 <= (f x)) /\ (f has_integral 0) s 12523 ==> negligible {x | x IN s /\ ~(f x = 0)}``, 12524 REPEAT STRIP_TAC THEN MATCH_MP_TAC NEGLIGIBLE_SUBSET THEN EXISTS_TAC 12525 ``BIGUNION {{x | x IN s /\ abs((f:real->real) x) >= &1 / (&n + &1:real)} | 12526 n IN univ(:num)}`` THEN 12527 CONJ_TAC THENL 12528 [ONCE_REWRITE_TAC [METIS [] 12529 ``{x | x IN s /\ abs (f x) >= 1 / (&n + 1)} = 12530 (\n. {x | x IN s /\ abs (f x) >= 1 / (&n + 1)}) n``] THEN 12531 MATCH_MP_TAC NEGLIGIBLE_COUNTABLE_BIGUNION THEN 12532 X_GEN_TAC ``n:num`` THEN SIMP_TAC std_ss [NEGLIGIBLE_ON_UNIV, indicator] THEN 12533 MATCH_MP_TAC HAS_INTEGRAL_STRADDLE_NULL THEN 12534 EXISTS_TAC ``(\x. if x IN s then (&n + &1) * f(x) else 0):real->real`` THEN 12535 CONJ_TAC THENL 12536 [SIMP_TAC std_ss [IN_UNIV, GSPECIFICATION, real_ge] THEN 12537 X_GEN_TAC ``x:real`` THEN COND_CASES_TAC THEN 12538 ASM_SIMP_TAC std_ss [REAL_POS] THENL 12539 [ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 12540 ASM_SIMP_TAC std_ss [GSYM REAL_LE_LDIV_EQ, 12541 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] 12542 ``&0 < &n + &1:real``] THEN 12543 MATCH_MP_TAC(REAL_ARITH ``&0 <= x /\ a <= abs x ==> a <= x:real``) THEN 12544 ASM_SIMP_TAC std_ss [], 12545 COND_CASES_TAC THEN REWRITE_TAC[REAL_POS] THEN 12546 ASM_SIMP_TAC std_ss [REAL_POS, REAL_LE_MUL, REAL_LE_ADD]], 12547 SIMP_TAC std_ss [HAS_INTEGRAL_RESTRICT_UNIV] THEN 12548 SUBST1_TAC(REAL_ARITH ``0:real = (&n + &1) * 0``) THEN 12549 MATCH_MP_TAC HAS_INTEGRAL_CMUL THEN ASM_REWRITE_TAC[]], 12550 SIMP_TAC std_ss [SUBSET_DEF, GSPECIFICATION] THEN X_GEN_TAC ``x:real`` THEN 12551 REWRITE_TAC[ABS_NZ] THEN ONCE_REWRITE_TAC[REAL_ARCH_INV] THEN 12552 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (X_CHOOSE_THEN ``n:num`` 12553 STRIP_ASSUME_TAC)) THEN 12554 SIMP_TAC std_ss [IN_BIGUNION, EXISTS_IN_GSPEC] THEN 12555 ASM_SIMP_TAC std_ss [IN_UNIV, GSPECIFICATION, real_ge] THEN 12556 EXISTS_TAC ``{x' | x' IN (s :real -> bool) /\ 12557 (1 :real) / (((&n) :real) + (1 :real)) <= 12558 abs ((f :real -> real) x')}`` THEN CONJ_TAC THENL 12559 [ASM_SIMP_TAC std_ss [GSPECIFICATION, REAL_LE_LT] THEN DISJ1_TAC THEN 12560 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC ``inv (&n):real`` THEN 12561 ASM_REWRITE_TAC [GSYM REAL_INV_1OVER] THEN MATCH_MP_TAC REAL_LE_INV2 THEN 12562 SIMP_TAC std_ss [REAL_LT, REAL_OF_NUM_ADD, REAL_OF_NUM_LE] THEN 12563 UNDISCH_TAC ``n <> 0:num`` THEN ARITH_TAC, 12564 EXISTS_TAC ``n:num`` THEN ASM_SIMP_TAC std_ss []]]); 12565 12566val HAS_INTEGRAL_NEGLIGIBLE_EQ = store_thm ("HAS_INTEGRAL_NEGLIGIBLE_EQ", 12567 ``!f:real->real s. 12568 (!x i. x IN s ==> &0 <= f(x)) 12569 ==> ((f has_integral 0) s <=> 12570 negligible {x | x IN s /\ ~(f x = 0)})``, 12571 REPEAT STRIP_TAC THEN EQ_TAC THEN DISCH_TAC THENL 12572 [ALL_TAC, 12573 MATCH_MP_TAC HAS_INTEGRAL_NEGLIGIBLE THEN 12574 EXISTS_TAC ``{x | x IN s /\ ~((f:real->real) x = 0)}`` THEN 12575 ASM_SIMP_TAC std_ss [IN_DIFF, GSPECIFICATION] THEN MESON_TAC[]] THEN 12576 MATCH_MP_TAC NEGLIGIBLE_SUBSET THEN 12577 EXISTS_TAC ``BIGUNION {{x | x IN s /\ ~(((f:real->real) x) = &0)}}`` THEN 12578 CONJ_TAC THENL 12579 [MATCH_MP_TAC NEGLIGIBLE_BIGUNION THEN 12580 SIMP_TAC real_ss [GSYM IMAGE_DEF, IMAGE_FINITE, FINITE_NUMSEG, FORALL_IN_IMAGE, 12581 IN_SING, FINITE_SING] THEN MATCH_MP_TAC lemma THEN 12582 ASM_SIMP_TAC std_ss [], 12583 SIMP_TAC std_ss [SUBSET_DEF, IN_BIGUNION, EXISTS_IN_GSPEC, IN_NUMSEG] THEN 12584 SIMP_TAC std_ss [GSPECIFICATION, IN_SING] THEN MESON_TAC[]]); 12585 12586val lemma = prove ( 12587 ``IMAGE f s = BIGUNION {(\x. {f x}) x | x IN s}``, 12588 SIMP_TAC std_ss [EXTENSION, IN_IMAGE, IN_BIGUNION, IN_SING, GSPECIFICATION] THEN 12589 MESON_TAC[IN_SING]); 12590 12591val NEGLIGIBLE_COUNTABLE = store_thm ("NEGLIGIBLE_COUNTABLE", 12592 ``!s:real->bool. COUNTABLE s ==> negligible s``, 12593 GEN_TAC THEN ASM_CASES_TAC ``s:real->bool = {}`` THEN 12594 ASM_REWRITE_TAC[NEGLIGIBLE_EMPTY] THEN 12595 POP_ASSUM MP_TAC THEN REWRITE_TAC[GSYM IMP_CONJ_ALT] THEN 12596 DISCH_THEN(X_CHOOSE_THEN ``f:num->real`` SUBST1_TAC o 12597 MATCH_MP COUNTABLE_AS_IMAGE) THEN 12598 ONCE_REWRITE_TAC[lemma] THEN 12599 MATCH_MP_TAC NEGLIGIBLE_COUNTABLE_BIGUNION THEN 12600 SIMP_TAC std_ss [NEGLIGIBLE_SING]); 12601 12602(* ------------------------------------------------------------------------- *) 12603(* More basic "almost everywhere" variants of other theorems. *) 12604(* ------------------------------------------------------------------------- *) 12605 12606val HAS_INTEGRAL_COMPONENT_LE_AE = store_thm ("HAS_INTEGRAL_COMPONENT_LE_AE", 12607 ``!f:real->real g:real->real s i j k t. 12608 negligible t /\ 12609 (f has_integral i) s /\ (g has_integral j) s /\ 12610 (!x. x IN s DIFF t ==> (f x) <= (g x)) 12611 ==> i <= j``, 12612 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_COMPONENT_LE THEN 12613 EXISTS_TAC ``\x. if x IN t then 0 else (f:real->real) x`` THEN 12614 EXISTS_TAC ``\x. if x IN t then 0 else (g:real->real) x`` THEN 12615 EXISTS_TAC ``s:real->bool`` THEN ASM_REWRITE_TAC[] THEN 12616 REPEAT STRIP_TAC THENL 12617 [MATCH_MP_TAC HAS_INTEGRAL_SPIKE THEN EXISTS_TAC ``f:real->real`` THEN 12618 EXISTS_TAC ``t:real->bool`` THEN ASM_SIMP_TAC std_ss [IN_DIFF], 12619 MATCH_MP_TAC HAS_INTEGRAL_SPIKE THEN EXISTS_TAC ``g:real->real`` THEN 12620 EXISTS_TAC ``t:real->bool`` THEN ASM_SIMP_TAC std_ss [IN_DIFF], 12621 SIMP_TAC std_ss [] THEN COND_CASES_TAC THEN 12622 ASM_SIMP_TAC std_ss [IN_DIFF, REAL_LE_REFL]]); 12623 12624val INTEGRAL_COMPONENT_LE_AE = store_thm ("INTEGRAL_COMPONENT_LE_AE", 12625 ``!f:real->real g:real->real s k t. 12626 negligible t /\ 12627 f integrable_on s /\ g integrable_on s /\ 12628 (!x. x IN s DIFF t ==> (f x) <= (g x)) 12629 ==> (integral s f) <= (integral s g)``, 12630 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_COMPONENT_LE_AE THEN 12631 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]); 12632 12633val HAS_INTEGRAL_LE_AE = store_thm ("HAS_INTEGRAL_LE_AE", 12634 ``!f:real->real g:real->real s i j t. 12635 (f has_integral i) s /\ (g has_integral j) s /\ 12636 negligible t /\ (!x. x IN s DIFF t ==> (f x) <= (g x)) 12637 ==> i <= j``, 12638 REPEAT STRIP_TAC THEN 12639 MATCH_MP_TAC HAS_INTEGRAL_COMPONENT_LE_AE THEN 12640 REWRITE_TAC[LESS_EQ_REFL] THEN ASM_MESON_TAC[]); 12641 12642val INTEGRAL_LE_AE = store_thm ("INTEGRAL_LE_AE", 12643 ``!f:real->real g:real->real s t. 12644 f integrable_on s /\ g integrable_on s /\ 12645 negligible t /\ (!x. x IN s DIFF t ==> (f x) <= (g x)) 12646 ==> (integral s f) <= (integral s g)``, 12647 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_INTEGRAL_LE_AE THEN 12648 ASM_MESON_TAC[INTEGRABLE_INTEGRAL]); 12649 12650val NONNEGATIVE_ABSOLUTELY_INTEGRABLE_AE = store_thm ("NONNEGATIVE_ABSOLUTELY_INTEGRABLE_AE", 12651 ``!f:real->real s t. 12652 negligible t /\ 12653 (!x i. x IN s DIFF t 12654 ==> &0 <= f(x)) /\ 12655 f integrable_on s 12656 ==> f absolutely_integrable_on s``, 12657 REPEAT STRIP_TAC THEN 12658 MATCH_MP_TAC(REWRITE_RULE[AND_IMP_INTRO] ABSOLUTELY_INTEGRABLE_SPIKE) THEN 12659 EXISTS_TAC ``\x. if x IN s DIFF t then (f:real->real) x else 0`` THEN 12660 EXISTS_TAC ``t:real->bool`` THEN ASM_SIMP_TAC std_ss [] THEN 12661 MATCH_MP_TAC NONNEGATIVE_ABSOLUTELY_INTEGRABLE THEN 12662 SIMP_TAC std_ss [] THEN CONJ_TAC THENL 12663 [METIS_TAC[REAL_LE_REFL], ALL_TAC] THEN 12664 MATCH_MP_TAC(REWRITE_RULE[AND_IMP_INTRO] INTEGRABLE_SPIKE) THEN 12665 MAP_EVERY EXISTS_TAC [``f:real->real``, ``t:real->bool``] THEN 12666 ASM_SIMP_TAC std_ss []); 12667 12668val INTEGRAL_ABS_BOUND_INTEGRAL_AE = store_thm ("INTEGRAL_ABS_BOUND_INTEGRAL_AE", 12669 ``!f:real->real g s t. 12670 f integrable_on s /\ g integrable_on s /\ 12671 negligible t /\ (!x. x IN s DIFF t ==> abs(f x) <= (g x)) 12672 ==> abs(integral s f) <= (integral s g)``, 12673 REPEAT STRIP_TAC THEN 12674 MP_TAC(ISPECL 12675 [``\x. if x IN s DIFF t then (f:real->real) x else 0``, 12676 ``\x. if x IN s DIFF t then (g:real->real) x else 0``, 12677 ``s:real->bool``] 12678 INTEGRAL_ABS_BOUND_INTEGRAL) THEN 12679 SIMP_TAC std_ss [] THEN 12680 KNOW_TAC ``(\(x :real). 12681 if x IN (s :real -> bool) DIFF (t :real -> bool) then 12682 (f :real -> real) x 12683 else (0 :real)) integrable_on s /\ 12684 (\(x :real). 12685 if x IN s DIFF t then (g :real -> real) x 12686 else (0 :real)) integrable_on s /\ 12687 (!(x :real). x IN s ==> 12688 abs (if x IN s DIFF t then f x else (0 :real)) <= 12689 if x IN s DIFF t then g x else (0 :real))`` THENL 12690 [REPEAT CONJ_TAC THENL 12691 [MATCH_MP_TAC(REWRITE_RULE[AND_IMP_INTRO] INTEGRABLE_SPIKE) THEN 12692 EXISTS_TAC ``f:real->real``, 12693 MATCH_MP_TAC(REWRITE_RULE[AND_IMP_INTRO] INTEGRABLE_SPIKE) THEN 12694 EXISTS_TAC ``g:real->real``, 12695 METIS_TAC[REAL_LE_REFL, ABS_0]] THEN 12696 EXISTS_TAC ``t:real->bool`` THEN ASM_SIMP_TAC std_ss [], 12697 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12698 MATCH_MP_TAC EQ_IMPLIES THEN BINOP_TAC THENL 12699 [AP_TERM_TAC, ALL_TAC] THEN 12700 MATCH_MP_TAC INTEGRAL_SPIKE THEN EXISTS_TAC ``t:real->bool`` THEN 12701 ASM_SIMP_TAC std_ss []]); 12702 12703(* ------------------------------------------------------------------------- *) 12704(* Beppo Levi theorem. *) 12705(* ------------------------------------------------------------------------- *) 12706 12707Theorem BEPPO_LEVI_INCREASING : 12708 !f:num->real->real s. 12709 (!k. (f k) integrable_on s) /\ 12710 (!k x. x IN s ==> (f k x) <= (f (SUC k) x)) /\ 12711 bounded {integral s (f k) | k IN univ(:num)} 12712 ==> ?g k. negligible k /\ 12713 !x. x IN (s DIFF k) ==> ((\k. f k x) --> g x) sequentially 12714Proof 12715 SUBGOAL_THEN 12716 ``!f:num->real->real s. 12717 (!k x. x IN s ==> &0 <= (f k x)) /\ 12718 (!k. (f k) integrable_on s) /\ 12719 (!k x. x IN s ==> (f k x) <= (f (SUC k) x)) /\ 12720 bounded {integral s (f k) | k IN univ(:num)} 12721 ==> ?g k. negligible k /\ 12722 !x. x IN (s DIFF k) ==> ((\k. f k x) --> g x) sequentially`` 12723 ASSUME_TAC THENL 12724 [ ALL_TAC, 12725 REPEAT GEN_TAC THEN STRIP_TAC THEN 12726 FIRST_X_ASSUM(MP_TAC o ISPECL 12727 [``\n x:real. f(n:num) x - (f 0 x):real``, ``s:real->bool``]) THEN 12728 SIMP_TAC std_ss [] THEN 12729 KNOW_TAC ``(!(k :num) (x :real). 12730 x IN (s :real -> bool) ==> 12731 (0 :real) <= (f :num -> real -> real) k x - f (0 :num) x) /\ 12732 (!(k :num). (\(x :real). f k x - f (0 :num) x) integrable_on s) /\ 12733 (!(k :num) (x :real). x IN s ==> 12734 (f k x - f (0 :num) x) <= 12735 f (SUC k) x - f (0 :num) x) /\ 12736 (bounded {integral s (\(x :real). f k x - f (0 :num) x) | 12737 k IN univ((:num) :num itself)} :bool)`` THEN 12738 REPEAT CONJ_TAC THENL (* 5 goals *) 12739 [(* goal 1 (of 5) *) 12740 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_SUB_LE] THEN 12741 MP_TAC(ISPEC 12742 ``\m n:num. (f m (x:real)) <= (f n x):real`` 12743 TRANSITIVE_STEPWISE_LE) THEN SIMP_TAC real_ss [REAL_LE_REFL] THEN 12744 KNOW_TAC ``(!(x' :num) (y :num) (z :num). 12745 (f :num -> real -> real) x' (x :real) <= f y x /\ f y x <= f z x ==> 12746 f x' x <= f z x) `` THENL 12747 [REPEAT GEN_TAC THEN STRIP_TAC THEN METIS_TAC [REAL_LE_TRANS], 12748 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 12749 ASM_MESON_TAC[LE_0], 12750 (* goal 2 (of 5) *) 12751 GEN_TAC THEN MATCH_MP_TAC INTEGRABLE_SUB THEN METIS_TAC[ETA_AX], 12752 (* goal 3 (of 5) *) 12753 REPEAT STRIP_TAC THEN 12754 ASM_SIMP_TAC std_ss [REAL_ARITH ``x - a <= y - a <=> x <= y:real``], 12755 (* goal 4 (of 5) *) 12756 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [bounded_def]) THEN 12757 KNOW_TAC ``!k. (\x. (f:num->real->real) k x) integrable_on s`` THENL 12758 [METIS_TAC [ETA_AX], DISCH_TAC] THEN 12759 ASM_SIMP_TAC std_ss [INTEGRAL_SUB, bounded_def] THEN 12760 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 12761 SIMP_TAC std_ss [FORALL_IN_IMAGE, IN_UNIV] THEN 12762 DISCH_THEN(X_CHOOSE_THEN ``B:real`` 12763 (fn th => EXISTS_TAC ``B + abs(integral s (f (0:num):real->real))`` THEN 12764 X_GEN_TAC ``k:num`` THEN MP_TAC(SPEC ``k:num`` th))) THEN 12765 REWRITE_TAC [METIS [ETA_AX] ``(\x. f k x) = f k``] THEN 12766 REAL_ARITH_TAC, 12767 (* goal 5 (of 5) *) 12768 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12769 KNOW_TAC ``(?(k :real -> bool) (g :real -> real). 12770 negligible k /\ !(x :real). x IN (s :real -> bool) DIFF k ==> 12771 (((\(k :num). (f :num -> real -> real) k x - f (0 :num) x) --> g x) 12772 sequentially :bool)) ==> 12773 ?(k :real -> bool) (g :real -> real). 12774 negligible k /\ !(x :real). 12775 x IN s DIFF k ==> (((\(k :num). f k x) --> g x) sequentially :bool)`` THENL 12776 [ALL_TAC, METIS_TAC [SWAP_EXISTS_THM]] THEN 12777 DISCH_THEN (X_CHOOSE_TAC ``k:real->bool``) THEN EXISTS_TAC ``k:real->bool`` THEN 12778 POP_ASSUM MP_TAC THEN 12779 DISCH_THEN(X_CHOOSE_THEN ``g:real->real`` STRIP_ASSUME_TAC) THEN 12780 EXISTS_TAC ``(\x. g x + f (0:num) x):real->real`` THEN 12781 ASM_SIMP_TAC std_ss [] THEN X_GEN_TAC ``x:real`` THEN 12782 DISCH_TAC THEN FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN 12783 ASM_SIMP_TAC std_ss [LIM_SEQUENTIALLY, dist] THEN 12784 REWRITE_TAC[REAL_ARITH ``a - b - c:real = a - (c + b)``] ] ] THEN 12785 REPEAT STRIP_TAC THEN 12786 ABBREV_TAC 12787 ``g = \i n:num x:real. min (((f:num->real->real) n x) / (&i + &1)) (&1)`` THEN 12788 SUBGOAL_THEN 12789 ``!i n. ((g:num->num->real->real) i n) integrable_on s`` 12790 ASSUME_TAC THENL 12791 [REPEAT GEN_TAC THEN EXPAND_TAC "g" THEN 12792 ONCE_REWRITE_TAC [METIS [] ``(\x. min ((f:num->real->real) n x / (&i + 1)) 1) = 12793 (\x. min ((\x. (f n x / (&i + 1))) x) 1)``] THEN 12794 MATCH_MP_TAC INTEGRABLE_MIN_CONST THEN 12795 ASM_SIMP_TAC std_ss [REAL_POS, REAL_LE_DIV, REAL_LE_ADD] THEN 12796 REWRITE_TAC[ONCE_REWRITE_RULE[REAL_MUL_SYM] real_div] THEN 12797 METIS_TAC [INTEGRABLE_CMUL, ETA_AX], 12798 ALL_TAC] THEN 12799 SUBGOAL_THEN 12800 ``!i:num k:num x:real. x IN s ==> (g i k x):real <= (g i (SUC k) x)`` 12801 ASSUME_TAC THENL 12802 [REPEAT STRIP_TAC THEN EXPAND_TAC "g" THEN 12803 KNOW_TAC ``!x y a:real. x <= y ==> min x a <= min y a`` THENL 12804 [RW_TAC real_ss [min_def] THEN 12805 `a < x'` by PROVE_TAC [real_lte] \\ 12806 `a < y` by PROVE_TAC [REAL_LTE_TRANS] \\ 12807 PROVE_TAC [REAL_LTE_ANTISYM], DISCH_TAC] THEN 12808 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC [real_div] THEN 12809 MATCH_MP_TAC REAL_LE_MUL2 THEN ASM_SIMP_TAC real_ss [REAL_POS, REAL_LE_REFL] THEN 12810 MATCH_MP_TAC REAL_LE_INV THEN 12811 ASM_SIMP_TAC std_ss [REAL_LE_LT, GSYM REAL_OF_NUM_ADD, 12812 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``], 12813 ALL_TAC] THEN 12814 SUBGOAL_THEN ``!i:num k:num x:real. x IN s ==> abs(g i k x:real) <= &1:real`` 12815 ASSUME_TAC THENL 12816 [REPEAT STRIP_TAC THEN EXPAND_TAC "g" THEN 12817 KNOW_TAC ``0 <= ((f :num -> real -> real) (k :num) (x :real) / 12818 (((&(i :num)) :real) + (1 :real)))`` THENL 12819 [REWRITE_TAC [real_div] THEN MATCH_MP_TAC REAL_LE_MUL THEN 12820 ASM_SIMP_TAC real_ss [] THEN MATCH_MP_TAC REAL_LE_INV THEN 12821 ASM_SIMP_TAC std_ss [REAL_LE_LT, GSYM REAL_OF_NUM_ADD, 12822 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``], 12823 ALL_TAC] THEN REWRITE_TAC [min_def] THEN 12824 Cases_on `f k x / (&i + 1) <= 1` >> fs [abs], 12825 ALL_TAC] THEN 12826 SUBGOAL_THEN 12827 ``!i:num x:real. x IN s ==> ?h:real. ((\n. (g i n x):real) --> h) sequentially`` 12828 MP_TAC THENL (* subgoals *) 12829 [ (* goal 1 (of 2) *) 12830 REPEAT STRIP_TAC THEN 12831 MP_TAC(ISPECL 12832 [``\n. (g (i:num) (n:num) (x:real)):real``, ``&1:real``] 12833 CONVERGENT_BOUNDED_MONOTONE) THEN 12834 SIMP_TAC std_ss [] THEN 12835 KNOW_TAC ``(!(n :num). 12836 abs ((g :num -> num -> real -> real) (i :num) n (x :real)) <= (1:real)) /\ 12837 ((!(m :num) (n :num). m <= n ==> g i m x <= g i n x) \/ 12838 !(m :num) (n :num). m <= n ==> g i n x <= g i m x)`` THENL 12839 [ASM_SIMP_TAC std_ss [] THEN DISJ1_TAC THEN 12840 ONCE_REWRITE_TAC [METIS [] ``g i m x <= (g:num->num->real->real) i n x <=> 12841 (\m n:num. g i m x <= g i n x) m n``] THEN 12842 MATCH_MP_TAC TRANSITIVE_STEPWISE_LE THEN 12843 METIS_TAC [REAL_LE_REFL, REAL_LE_TRANS], 12844 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12845 DISCH_THEN(X_CHOOSE_THEN ``l:real`` (fn th => 12846 EXISTS_TAC ``l:real`` THEN MP_TAC th)) THEN 12847 SIMP_TAC std_ss [LIM_SEQUENTIALLY, dist]], 12848 (* goal 2 (of 2) *) 12849 DISCH_THEN (MP_TAC o SIMP_RULE std_ss [RIGHT_IMP_EXISTS_THM]) THEN 12850 SIMP_TAC std_ss [SKOLEM_THM, LEFT_IMP_EXISTS_THM] ] THEN 12851 X_GEN_TAC ``h:num->real->real`` THEN STRIP_TAC THEN 12852 MP_TAC(GEN ``i:num`` (ISPECL 12853 [``g(i:num):num->real->real``, ``h(i:num):real->real``, 12854 ``s:real->bool``] MONOTONE_CONVERGENCE_INCREASING)) THEN 12855 DISCH_TAC THEN 12856 KNOW_TAC ``(!(i :num). 12857 (!(k :num). 12858 (g :num -> num -> real -> real) i k integrable_on 12859 (s :real -> bool)) /\ 12860 (!(k :num) (x :real). x IN s ==> g i k x <= g i (SUC k) x) /\ 12861 (!(x :real). 12862 x IN s ==> 12863 (((\(k :num). g i k x) --> (h :num -> real -> real) i x) 12864 sequentially :bool)) /\ 12865 (bounded {integral s (g i k) | k IN univ((:num) :num itself)} : 12866 bool)) ==> (!(i :num). 12867 h i integrable_on s /\ 12868 (((\(k :num). integral s (g i k)) --> integral s (h i)) 12869 sequentially :bool))`` THENL 12870 [METIS_TAC [MONO_ALL], POP_ASSUM K_TAC] THEN 12871 ASM_SIMP_TAC std_ss [] THEN 12872 (* stage work *) 12873 KNOW_TAC ``(!(i :num). 12874 (bounded 12875 {integral (s :real -> bool) 12876 ((g :num -> num -> real -> real) i k) | 12877 k IN univ((:num) :num itself)} :bool))`` THENL 12878 [ (* goal 1 (of 2): 12879 !i. bounded {integral s (g i k) | k IN univ(:num)} *) 12880 GEN_TAC THEN REWRITE_TAC[bounded_def] THEN 12881 UNDISCH_TAC ``bounded {integral s (f k) | k IN univ(:num)}`` THEN DISCH_TAC THEN 12882 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [bounded_def]) THEN 12883 DISCH_THEN (X_CHOOSE_TAC ``kk:real``) THEN EXISTS_TAC ``kk:real`` THEN 12884 POP_ASSUM MP_TAC THEN 12885 SIMP_TAC std_ss [FORALL_IN_GSPEC] THEN REWRITE_TAC[IN_UNIV] THEN 12886 DISCH_TAC THEN X_GEN_TAC ``k:num`` THEN POP_ASSUM (MP_TAC o SPEC ``k:num``) THEN 12887 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LE_TRANS) THEN 12888 MATCH_MP_TAC(REAL_ARITH 12889 ``(abs a = a) /\ x <= a ==> x <= a:real``) THEN 12890 CONJ_TAC THENL 12891 [ (* goal 1.1 (of 2) *) 12892 SIMP_TAC std_ss [ABS_ABS], 12893 (* goal 1.2 (of 2) *) 12894 GEN_REWR_TAC RAND_CONV [abs] THEN 12895 ASM_SIMP_TAC real_ss [INTEGRAL_DROP_POS] THEN 12896 MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN 12897 ASM_SIMP_TAC std_ss [] THEN X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 12898 EXPAND_TAC "g" THEN 12899 KNOW_TAC ``0 <= ((f :num -> real -> real) (k :num) (x :real) / 12900 (((&(i :num)) :real) + (1 :real))) /\ 12901 ((f :num -> real -> real) (k :num) (x :real) / 12902 (((&(i :num)) :real) + (1 :real))) <= f k x`` THENL 12903 [ (* goal 1.2.1 (of 2): 12904 0 <= f k x / (&i + 1) /\ f k x / (&i + 1) <= f k x *) 12905 CONJ_TAC THENL 12906 [ (* goal 1.2.1.1 (of 2) *) 12907 REWRITE_TAC [real_div] THEN MATCH_MP_TAC REAL_LE_MUL THEN 12908 ASM_SIMP_TAC real_ss [] THEN MATCH_MP_TAC REAL_LE_INV THEN 12909 ASM_SIMP_TAC std_ss [REAL_LE_LT, GSYM REAL_OF_NUM_ADD, 12910 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``], 12911 (* goal 1.2.1.2 (of 2) *) 12912 ALL_TAC ] THEN 12913 SIMP_TAC real_ss [REAL_LE_LDIV_EQ] THEN 12914 GEN_REWR_TAC LAND_CONV [GSYM REAL_MUL_RID] THEN 12915 ONCE_REWRITE_TAC [GSYM REAL_SUB_LE] THEN REWRITE_TAC [GSYM REAL_SUB_LDISTRIB] THEN 12916 MATCH_MP_TAC REAL_LE_MUL THEN ASM_SIMP_TAC real_ss [] THEN 12917 ASM_SIMP_TAC std_ss [REAL_LE_LT, GSYM REAL_OF_NUM_ADD, 12918 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 12919 REWRITE_TAC [REAL_ADD_SUB_ALT, GSYM REAL_LE_LT, REAL_POS], 12920 (* goal 1.2.2 (of 2) *) 12921 ALL_TAC] THEN 12922 RW_TAC std_ss [min_def] 12923 >- (NTAC 3 (POP_ASSUM MP_TAC) >> REAL_ARITH_TAC) \\ 12924 rw [abs] >> NTAC 3 (POP_ASSUM MP_TAC) \\ 12925 REAL_ARITH_TAC ], 12926 (* goal 2 (of 2) *) 12927 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 12928 SIMP_TAC std_ss [FORALL_AND_THM] THEN STRIP_TAC ] THEN 12929 ABBREV_TAC 12930 ``Z = 12931 {x:real | x IN s /\ ~(?l:real. ((\k. f k x) --> l) sequentially)}`` THEN 12932 KNOW_TAC ``?(k :real ->bool) (g :real -> real). 12933 negligible k /\ 12934 !(x :real). 12935 x IN (s :real -> bool) DIFF k ==> 12936 (((\(k :num). (f :num -> real -> real) k x) --> g x) sequentially : 12937 bool)`` THENL [ALL_TAC, METIS_TAC [SWAP_EXISTS_THM]] THEN 12938 EXISTS_TAC ``Z:real->bool`` THEN 12939 SIMP_TAC std_ss [RIGHT_EXISTS_AND_THM, GSYM SKOLEM_THM, RIGHT_EXISTS_IMP_THM] THEN 12940 CONJ_TAC THENL 12941 [ALL_TAC, EXPAND_TAC "Z" THEN SIMP_TAC std_ss [GSPECIFICATION] THEN SET_TAC[]] THEN 12942 MP_TAC(ISPECL 12943 [``h:num->real->real``, 12944 ``(\x. if x IN Z then 1 else 0):real->real``, 12945 ``s:real->bool``] 12946 MONOTONE_CONVERGENCE_DECREASING) THEN 12947 ASM_SIMP_TAC std_ss [] THEN 12948 SUBGOAL_THEN 12949 ``!i x:real. x IN s ==> (h (SUC i) x) <= (h i x):real`` 12950 ASSUME_TAC THENL 12951 [ (* goal 1 (of 2) *) 12952 MAP_EVERY X_GEN_TAC [``i:num``, ``x:real``] THEN DISCH_TAC THEN 12953 MATCH_MP_TAC(ISPEC ``sequentially`` LIM_DROP_LE) THEN 12954 EXISTS_TAC ``\n. (g:num->num->real->real) (SUC i) n x`` THEN 12955 EXISTS_TAC ``\n. (g:num->num->real->real) i n x`` THEN 12956 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_SEQUENTIALLY] THEN 12957 MATCH_MP_TAC ALWAYS_EVENTUALLY THEN X_GEN_TAC ``n:num`` THEN 12958 EXPAND_TAC "g" THEN SIMP_TAC std_ss [] THEN 12959 KNOW_TAC ``!x y a:real. x <= y ==> min x a <= min y a`` THENL 12960 [ KILL_TAC \\ 12961 RW_TAC real_ss [min_def] \\ 12962 `a < x` by PROVE_TAC [real_lte] \\ 12963 `a < y` by PROVE_TAC [REAL_LTE_TRANS] \\ 12964 PROVE_TAC [REAL_LTE_ANTISYM], DISCH_TAC] THEN 12965 FIRST_X_ASSUM MATCH_MP_TAC THEN 12966 REWRITE_TAC[real_div] THEN MATCH_MP_TAC REAL_LE_LMUL_IMP THEN 12967 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC REAL_LE_INV2 THEN 12968 REWRITE_TAC[GSYM REAL_OF_NUM_SUC] THEN SIMP_TAC real_ss [REAL_POS], 12969 (* goal 2 (of 2) *) 12970 ASM_SIMP_TAC std_ss [] ] THEN 12971 UNDISCH_TAC ``bounded {integral s (f k) | k IN univ(:num)}`` THEN DISCH_TAC THEN 12972 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [BOUNDED_POS]) THEN 12973 SIMP_TAC std_ss [FORALL_IN_GSPEC, IN_UNIV] THEN 12974 DISCH_THEN(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) THEN 12975 SUBGOAL_THEN 12976 ``!i. abs(integral s ((h:num->real->real) i)) <= B / (&i + &1)`` 12977 ASSUME_TAC THENL 12978 [ (* goal 1 (of 2) *) 12979 X_GEN_TAC ``i:num`` THEN 12980 MATCH_MP_TAC(ISPEC ``sequentially`` LIM_ABS_UBOUND) THEN 12981 EXISTS_TAC ``\k. integral s ((g:num->num->real->real) i k)`` THEN 12982 ASM_REWRITE_TAC[TRIVIAL_LIMIT_SEQUENTIALLY] THEN 12983 MATCH_MP_TAC ALWAYS_EVENTUALLY THEN X_GEN_TAC ``n:num`` THEN 12984 SIMP_TAC std_ss [] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 12985 EXISTS_TAC 12986 ``(integral s (\x. inv(&i + &1) * (f:num->real->real) n x))`` THEN 12987 CONJ_TAC THENL 12988 [ (* goal 1.1 (of 2) *) 12989 MATCH_MP_TAC INTEGRAL_ABS_BOUND_INTEGRAL THEN ASM_SIMP_TAC std_ss [] THEN 12990 CONJ_TAC THENL [METIS_TAC [INTEGRABLE_CMUL, ETA_AX], ALL_TAC] THEN 12991 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN EXPAND_TAC "g" THEN 12992 KNOW_TAC ``0 <= ((f :num -> real -> real) (n :num) (x :real) / 12993 (((&(i :num)) :real) + (1 :real))) /\ 12994 ((f :num -> real -> real) (n :num) (x :real) / 12995 (((&(i :num)) :real) + (1 :real))) <= inv (&i + 1) * f n x`` THENL 12996 [ (* goal 1.1.1 (of 2) *) 12997 CONJ_TAC THENL 12998 [ (* goal 1.1.1.1 (of 2) *) 12999 REWRITE_TAC [real_div] THEN MATCH_MP_TAC REAL_LE_MUL THEN 13000 ASM_SIMP_TAC real_ss [] THEN MATCH_MP_TAC REAL_LE_INV THEN 13001 ASM_SIMP_TAC std_ss [REAL_LE_LT, GSYM REAL_OF_NUM_ADD, 13002 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``], 13003 (* goal 1.1.1.2 (of 2) *) 13004 ALL_TAC ] THEN 13005 SIMP_TAC real_ss [REAL_LE_LDIV_EQ] THEN 13006 GEN_REWR_TAC RAND_CONV [REAL_ARITH ``a * b * c = b * (a * c:real)``] THEN 13007 GEN_REWR_TAC LAND_CONV [GSYM REAL_MUL_RID] THEN 13008 ONCE_REWRITE_TAC [GSYM REAL_SUB_LE] THEN REWRITE_TAC [GSYM REAL_SUB_LDISTRIB] THEN 13009 MATCH_MP_TAC REAL_LE_MUL THEN ASM_SIMP_TAC real_ss [] THEN 13010 ASM_SIMP_TAC std_ss [REAL_LE_LT, GSYM REAL_OF_NUM_ADD, 13011 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 13012 DISJ2_TAC THEN CONV_TAC SYM_CONV THEN REWRITE_TAC [REAL_SUB_0] THEN 13013 MATCH_MP_TAC REAL_MUL_LINV THEN SIMP_TAC real_ss [REAL_POS], 13014 (* goal 1.1.2 (of 2) *) 13015 RW_TAC real_ss [min_def] THEN 13016 NTAC 3 (POP_ASSUM MP_TAC) >> REAL_ARITH_TAC ], 13017 (* goal 1.2 (of 2) *) 13018 ONCE_REWRITE_TAC [METIS [] ``(\x. inv (&(i + 1)) * (f:num->real->real) n x) = 13019 (\x. inv (&(i + 1)) * (\x. f n x) x)``] THEN 13020 KNOW_TAC ``(\x. (f:num->real->real) n x) integrable_on s`` THENL 13021 [METIS_TAC [ETA_AX], DISCH_TAC] THEN 13022 ASM_SIMP_TAC real_ss [INTEGRAL_CMUL] THEN 13023 ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 13024 SIMP_TAC real_ss [REAL_LE_RDIV_EQ] THEN 13025 SIMP_TAC real_ss [REAL_MUL_LINV, GSYM REAL_MUL_ASSOC] THEN 13026 MATCH_MP_TAC(REAL_ARITH ``abs x <= a ==> x <= a:real``) THEN 13027 METIS_TAC [ETA_AX] ], 13028 (* goal 2 (of 2) *) 13029 ALL_TAC ] THEN 13030 KNOW_TAC ``(!(x :real). 13031 x IN (s :real -> bool) ==> 13032 (((\(k :num). (h :num -> real -> real) k x) --> 13033 if x IN (Z :real -> bool) then (1 :real) else (0 :real)) 13034 sequentially :bool)) /\ 13035 (bounded {integral s (h k) | k | T} :bool)`` THENL 13036 [ (* goal 1 (of 2) *) 13037 SIMP_TAC std_ss [bounded_def, FORALL_IN_GSPEC] THEN CONJ_TAC THENL 13038 [ALL_TAC, 13039 EXISTS_TAC ``B:real`` THEN X_GEN_TAC ``i:num`` THEN 13040 MATCH_MP_TAC REAL_LE_TRANS THEN 13041 EXISTS_TAC ``B / (&i + &1:real)`` THEN ASM_REWRITE_TAC[] THEN 13042 ASM_SIMP_TAC real_ss [REAL_LE_LDIV_EQ] THEN 13043 REWRITE_TAC[GSYM REAL_OF_NUM_ADD, 13044 REAL_ARITH ``B <= B * (i + &1) <=> &0:real <= i * B``] THEN 13045 ASM_SIMP_TAC std_ss [REAL_LE_MUL, REAL_POS, REAL_LT_IMP_LE]] THEN 13046 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 13047 ASM_CASES_TAC ``(x:real) IN Z`` THEN ASM_REWRITE_TAC[] THENL 13048 [ (* goal 1.1 (of 2) *) 13049 MATCH_MP_TAC LIM_EVENTUALLY THEN 13050 UNDISCH_TAC ``(x:real) IN Z`` THEN EXPAND_TAC "Z" THEN 13051 SIMP_TAC std_ss [GSPECIFICATION] THEN ASM_REWRITE_TAC[] THEN DISCH_TAC THEN 13052 MP_TAC(GEN ``B:real`` (ISPECL 13053 [``(\n. (f:num->real->real) (n:num) (x:real))``, ``B:real``] 13054 CONVERGENT_BOUNDED_MONOTONE)) THEN 13055 SIMP_TAC std_ss [LEFT_FORALL_IMP_THM, LEFT_EXISTS_AND_THM] THEN 13056 MATCH_MP_TAC(TAUT 13057 `q /\ ~r /\ (q ==> ~p ==> s) 13058 ==> (p /\ (q \/ q') ==> r) ==> s`) THEN 13059 CONJ_TAC THENL 13060 [ONCE_REWRITE_TAC [METIS [] ``f m x <= (f:num->real->real) n x <=> 13061 (\m n. f m x <= f n x) m n``] THEN 13062 MATCH_MP_TAC TRANSITIVE_STEPWISE_LE THEN 13063 METIS_TAC [REAL_LE_REFL, REAL_LE_TRANS], 13064 ALL_TAC] THEN 13065 CONJ_TAC THENL 13066 [FIRST_X_ASSUM(MP_TAC o SIMP_RULE std_ss [NOT_EXISTS_THM]) THEN 13067 ONCE_REWRITE_TAC[MONO_NOT_EQ] THEN SIMP_TAC std_ss [] THEN 13068 DISCH_THEN(X_CHOOSE_THEN ``l:real`` STRIP_ASSUME_TAC) THEN 13069 EXISTS_TAC ``l:real`` THEN REWRITE_TAC[LIM_SEQUENTIALLY] THEN 13070 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 13071 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 13072 SIMP_TAC std_ss [dist], 13073 ALL_TAC] THEN 13074 DISCH_TAC THEN SIMP_TAC std_ss [NOT_FORALL_THM, EVENTUALLY_SEQUENTIALLY] THEN 13075 SIMP_TAC std_ss [NOT_EXISTS_THM, NOT_FORALL_THM, REAL_NOT_LE] THEN 13076 DISCH_TAC THEN 13077 EXISTS_TAC ``0:num`` THEN X_GEN_TAC ``i:num`` THEN DISCH_TAC THEN 13078 MATCH_MP_TAC(ISPEC ``sequentially`` LIM_UNIQUE) THEN 13079 EXISTS_TAC ``(\n. (g:num->num->real->real) i n x)`` THEN 13080 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_SEQUENTIALLY] THEN 13081 MATCH_MP_TAC LIM_EVENTUALLY THEN 13082 EXPAND_TAC "g" THEN SIMP_TAC std_ss [EVENTUALLY_SEQUENTIALLY] THEN 13083 FIRST_X_ASSUM(MP_TAC o SPEC ``&i + &1:real``) THEN 13084 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 13085 X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 13086 KNOW_TAC ``!a b. (min a b = b) <=> b <= a:real`` THENL 13087 [ RW_TAC real_ss [min_def] THEN 13088 POP_ASSUM MP_TAC >> REAL_ARITH_TAC, DISCH_TAC ] THEN 13089 FIRST_X_ASSUM (fn th => REWRITE_TAC [th]) THEN 13090 SIMP_TAC real_ss [REAL_LE_RDIV_EQ, REAL_MUL_LID] THEN 13091 UNDISCH_TAC ``&i + 1 < abs ((f:num->real->real) N x)`` THEN DISCH_TAC THEN 13092 REWRITE_TAC [GSYM REAL_OF_NUM_ADD] THEN 13093 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 13094 ``a < abs N ==> &0 <= N:real /\ N <= n ==> a <= n:real``)) THEN 13095 ASM_SIMP_TAC std_ss [], 13096 (* goal 1.2 (of 2) *) 13097 UNDISCH_TAC ``~((x:real) IN Z)`` THEN EXPAND_TAC "Z" THEN 13098 SIMP_TAC std_ss [GSPECIFICATION] THEN 13099 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 13100 X_GEN_TAC ``l:real`` THEN 13101 DISCH_THEN(MP_TAC o MATCH_MP CONVERGENT_IMP_BOUNDED) THEN 13102 SIMP_TAC std_ss [BOUNDED_POS, FORALL_IN_IMAGE, IN_UNIV] THEN 13103 DISCH_THEN(X_CHOOSE_THEN ``C:real`` STRIP_ASSUME_TAC) THEN 13104 SIMP_TAC std_ss [LIM_SEQUENTIALLY, DIST_0] THEN 13105 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 13106 MP_TAC(ISPEC ``e / C:real`` REAL_ARCH_INV) THEN 13107 ASM_SIMP_TAC std_ss [REAL_LT_DIV] THEN 13108 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 13109 POP_ASSUM MP_TAC THEN ASM_SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN STRIP_TAC THEN 13110 X_GEN_TAC ``i:num`` THEN DISCH_TAC THEN 13111 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC ``inv(&N) * C:real`` THEN 13112 ASM_REWRITE_TAC[] THEN 13113 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``C / (&i + &1:real)`` THEN 13114 CONJ_TAC THENL 13115 [ALL_TAC, 13116 REWRITE_TAC[ONCE_REWRITE_RULE[REAL_MUL_SYM] real_div] THEN 13117 ASM_SIMP_TAC real_ss [REAL_LE_RMUL] THEN MATCH_MP_TAC REAL_LE_INV2 THEN 13118 ASM_REWRITE_TAC[REAL_LT, REAL_OF_NUM_LE, REAL_OF_NUM_ADD] THEN 13119 ASM_SIMP_TAC arith_ss []] THEN 13120 MATCH_MP_TAC(ISPEC ``sequentially`` LIM_ABS_UBOUND) THEN 13121 EXISTS_TAC ``\n. (g:num->num->real->real) i n x`` THEN 13122 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_SEQUENTIALLY] THEN 13123 MATCH_MP_TAC ALWAYS_EVENTUALLY THEN X_GEN_TAC ``n:num`` THEN 13124 EXPAND_TAC "g" THEN SIMP_TAC std_ss [] THEN 13125 KNOW_TAC ``!a x:real. &0 <= x /\ x <= a ==> abs(min x (&1)) <= a`` THENL 13126 [ RW_TAC real_ss [min_def] THEN 13127 NTAC 3 (POP_ASSUM MP_TAC) >> REAL_ARITH_TAC, DISCH_TAC ] THEN 13128 FIRST_X_ASSUM MATCH_MP_TAC THEN 13129 ASM_SIMP_TAC real_ss [REAL_LE_DIV, REAL_LE_ADD, REAL_POS] THEN 13130 REWRITE_TAC [real_div] THEN MATCH_MP_TAC REAL_LE_MUL2 THEN 13131 ASM_SIMP_TAC std_ss [GSYM REAL_OF_NUM_ADD, 13132 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 13133 SIMP_TAC std_ss [REAL_LE_REFL] THEN CONJ_TAC THENL 13134 [MATCH_MP_TAC REAL_LE_INV THEN SIMP_TAC real_ss [REAL_POS], ALL_TAC] THEN 13135 MATCH_MP_TAC(REAL_ARITH ``abs x <= a ==> x <= a:real``) THEN 13136 ASM_SIMP_TAC real_ss [] ], 13137 (* goal 2 (of 2) *) 13138 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13139 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 13140 MATCH_MP_TAC(MESON[LIM_UNIQUE, TRIVIAL_LIMIT_SEQUENTIALLY] 13141 ``(f --> 0) sequentially /\ ((i = 0) ==> p) 13142 ==> (f --> i) sequentially ==> p``) THEN 13143 CONJ_TAC THENL 13144 [MATCH_MP_TAC LIM_NULL_COMPARISON THEN 13145 EXISTS_TAC ``\i. B / (&i + &1:real)`` THEN 13146 ASM_SIMP_TAC std_ss [ALWAYS_EVENTUALLY] THEN 13147 REWRITE_TAC[real_div] THEN 13148 SUBST1_TAC(REAL_ARITH ``0:real = B * 0``) THEN 13149 ONCE_REWRITE_TAC [METIS [] ``(\x. B * inv (&x + 1:real)) = 13150 (\x. B * (\x. inv (&x + 1)) x)``] THEN 13151 MATCH_MP_TAC LIM_CMUL THEN 13152 SIMP_TAC std_ss [LIM_SEQUENTIALLY, DIST_0] THEN 13153 X_GEN_TAC ``e:real`` THEN GEN_REWR_TAC LAND_CONV [REAL_ARCH_INV] THEN 13154 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 13155 POP_ASSUM MP_TAC THEN STRIP_TAC THEN X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 13156 SIMP_TAC real_ss [ABS_INV] THEN 13157 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC ``inv(&N:real)`` THEN 13158 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC REAL_LE_INV2 THEN 13159 SIMP_TAC real_ss [METIS [abs, REAL_OF_NUM_ADD, REAL_POS] 13160 ``abs(&(n + &1)) = &n + &1:real``] THEN 13161 ASM_SIMP_TAC arith_ss [], 13162 ASM_SIMP_TAC std_ss [INTEGRAL_EQ_HAS_INTEGRAL] THEN 13163 W(MP_TAC o PART_MATCH (lhs o rand) HAS_INTEGRAL_NEGLIGIBLE_EQ o 13164 lhand o snd) THEN SIMP_TAC std_ss [] THEN 13165 KNOW_TAC ``(!x:real. x IN s ==> 0 <= if x IN Z then 1 else 0:real)`` THENL 13166 [SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 13167 REWRITE_TAC[AND_IMP_INTRO] THEN 13168 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 13169 REWRITE_TAC[REAL_POS], 13170 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13171 DISCH_THEN SUBST1_TAC THEN 13172 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] NEGLIGIBLE_SUBSET) THEN 13173 SIMP_TAC arith_ss [SUBSET_DEF, GSPECIFICATION] THEN 13174 EXPAND_TAC "Z" THEN SIMP_TAC real_ss [GSPECIFICATION]]] ] 13175QED 13176 13177val BEPPO_LEVI_DECREASING = store_thm ("BEPPO_LEVI_DECREASING", 13178 ``!f:num->real->real s. 13179 (!k. (f k) integrable_on s) /\ 13180 (!k x. x IN s ==> (f (SUC k) x) <= (f k x)) /\ 13181 bounded {integral s (f k) | k IN univ(:num)} 13182 ==> ?g k. negligible k /\ 13183 !x. x IN (s DIFF k) ==> ((\k. f k x) --> g x) sequentially``, 13184 REPEAT STRIP_TAC THEN 13185 MP_TAC(ISPECL [``\n x. -((f:num->real->real) n x)``, ``s:real->bool``] 13186 BEPPO_LEVI_INCREASING) THEN 13187 ASM_SIMP_TAC std_ss [INTEGRABLE_NEG, ETA_AX, REAL_LE_NEG2] THEN 13188 ASM_SIMP_TAC real_ss [METIS [INTEGRABLE_NEG, ETA_AX] 13189 ``(!k. (f:num->real->real) k integrable_on s) ==> 13190 (!k. (\x. -f k x) integrable_on s)``] THEN 13191 KNOW_TAC ``(bounded 13192 {integral s (\(x :real). -(f :num -> real -> real) k x) | 13193 k IN univ((:num) :num itself)} : bool)`` THENL 13194 [REWRITE_TAC[bounded_def] THEN 13195 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [bounded_def]) THEN 13196 SIMP_TAC std_ss [FORALL_IN_GSPEC] THEN 13197 METIS_TAC [INTEGRAL_NEG, ETA_AX, ABS_NEG], 13198 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13199 KNOW_TAC ``(?(k :real -> bool) (g :real -> real). 13200 negligible k /\ !(x :real). 13201 x IN (s :real -> bool) DIFF k ==> 13202 (((\(k :num). -(f :num -> real -> real) k x) --> g x) 13203 sequentially :bool)) ==> 13204 ?(k :real -> bool) (g :real -> real). negligible k /\ !(x :real). 13205 x IN s DIFF k ==> (((\(k :num). f k x) --> g x) sequentially :bool)`` THENL 13206 [ALL_TAC, METIS_TAC [SWAP_EXISTS_THM]] THEN 13207 DISCH_THEN (X_CHOOSE_TAC ``k:real->bool``) THEN EXISTS_TAC ``k:real->bool`` THEN 13208 POP_ASSUM MP_TAC THEN 13209 DISCH_THEN(X_CHOOSE_THEN ``g:real->real`` STRIP_ASSUME_TAC) THEN 13210 EXISTS_TAC ``\x. -((g:real->real) x)`` THEN 13211 ASM_SIMP_TAC std_ss [] THEN REPEAT STRIP_TAC THEN 13212 GEN_REWR_TAC (RATOR_CONV o LAND_CONV o ABS_CONV) 13213 [GSYM REAL_NEG_NEG] THEN 13214 ASM_SIMP_TAC std_ss [LIM_NEG_EQ]]); 13215 13216val BEPPO_LEVI_MONOTONE_CONVERGENCE_INCREASING = store_thm ("BEPPO_LEVI_MONOTONE_CONVERGENCE_INCREASING", 13217 ``!f:num->real->real s. 13218 (!k. (f k) integrable_on s) /\ 13219 (!k x. x IN s ==> (f k x) <= (f (SUC k) x)) /\ 13220 bounded {integral s (f k) | k IN univ(:num)} 13221 ==> ?g k. negligible k /\ 13222 (!x. x IN (s DIFF k) 13223 ==> ((\k. f k x) --> g x) sequentially) /\ 13224 g integrable_on s /\ 13225 ((\k. integral s (f k)) --> integral s g) sequentially``, 13226 REPEAT GEN_TAC THEN DISCH_TAC THEN 13227 FIRST_ASSUM(MP_TAC o MATCH_MP BEPPO_LEVI_INCREASING) THEN 13228 DISCH_THEN (X_CHOOSE_THEN ``g:real->real`` MP_TAC) THEN 13229 DISCH_THEN (X_CHOOSE_TAC ``k:real->bool``) THEN 13230 EXISTS_TAC ``g:real->real`` THEN EXISTS_TAC ``k:real->bool`` THEN 13231 POP_ASSUM MP_TAC THEN STRIP_TAC THEN ASM_SIMP_TAC std_ss [] THEN 13232 SUBGOAL_THEN 13233 ``(g:real->real) integrable_on (s DIFF k) /\ 13234 ((\i. integral (s DIFF k) (f i)) --> integral (s DIFF k) g) sequentially`` 13235 MP_TAC THENL 13236 [MATCH_MP_TAC MONOTONE_CONVERGENCE_INCREASING THEN 13237 ASM_SIMP_TAC std_ss [] THEN 13238 UNDISCH_TAC ``(!k. f k integrable_on s) /\ 13239 (!k x. x IN s ==> f k x <= f (SUC k) x) /\ 13240 bounded {integral s (f k) | k IN univ(:num)}``, 13241 ALL_TAC] THEN 13242 (SUBGOAL_THEN 13243 ``!f:real->real. (integral (s DIFF k) f = integral s f) /\ 13244 (f integrable_on (s DIFF k) <=> f integrable_on s)`` 13245 (fn th => SIMP_TAC std_ss [th, IN_DIFF]) THEN 13246 GEN_TAC THEN CONJ_TAC THEN TRY EQ_TAC THEN 13247 (MATCH_MP_TAC INTEGRABLE_SPIKE_SET ORELSE 13248 MATCH_MP_TAC INTEGRAL_SPIKE_SET) THEN 13249 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 13250 NEGLIGIBLE_SUBSET)) THEN 13251 SET_TAC[])); 13252 13253val BEPPO_LEVI_MONOTONE_CONVERGENCE_DECREASING = store_thm ("BEPPO_LEVI_MONOTONE_CONVERGENCE_DECREASING", 13254 ``!f:num->real->real s. 13255 (!k. (f k) integrable_on s) /\ 13256 (!k x. x IN s ==> (f (SUC k) x) <= (f k x)) /\ 13257 bounded {integral s (f k) | k IN univ(:num)} 13258 ==> ?g k. negligible k /\ 13259 (!x. x IN (s DIFF k) 13260 ==> ((\k. f k x) --> g x) sequentially) /\ 13261 g integrable_on s /\ 13262 ((\k. integral s (f k)) --> integral s g) sequentially``, 13263 REPEAT GEN_TAC THEN DISCH_TAC THEN 13264 FIRST_ASSUM(MP_TAC o MATCH_MP BEPPO_LEVI_DECREASING) THEN 13265 DISCH_THEN (X_CHOOSE_THEN ``g:real->real`` MP_TAC) THEN 13266 DISCH_THEN (X_CHOOSE_TAC ``k:real->bool``) THEN 13267 EXISTS_TAC ``g:real->real`` THEN EXISTS_TAC ``k:real->bool`` THEN 13268 POP_ASSUM MP_TAC THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 13269 SUBGOAL_THEN 13270 ``(g:real->real) integrable_on (s DIFF k) /\ 13271 ((\i. integral (s DIFF k) (f i)) --> integral (s DIFF k) g) sequentially`` 13272 MP_TAC THENL 13273 [MATCH_MP_TAC MONOTONE_CONVERGENCE_DECREASING THEN 13274 ASM_SIMP_TAC std_ss [] THEN 13275 UNDISCH_TAC `` (!k. f k integrable_on s) /\ 13276 (!k x. x IN s ==> f (SUC k) x <= f k x) /\ 13277 bounded {integral s (f k) | k IN univ(:num)}``, 13278 ALL_TAC] THEN 13279 (SUBGOAL_THEN 13280 ``!f:real->real. (integral (s DIFF k) f = integral s f) /\ 13281 (f integrable_on (s DIFF k) <=> f integrable_on s)`` 13282 (fn th => SIMP_TAC std_ss [th, IN_DIFF]) THEN 13283 GEN_TAC THEN CONJ_TAC THEN TRY EQ_TAC THEN 13284 (MATCH_MP_TAC INTEGRABLE_SPIKE_SET ORELSE 13285 MATCH_MP_TAC INTEGRAL_SPIKE_SET) THEN 13286 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 13287 NEGLIGIBLE_SUBSET)) THEN 13288 SET_TAC[])); 13289 13290val BEPPO_LEVI_MONOTONE_CONVERGENCE_INCREASING_AE = store_thm ("BEPPO_LEVI_MONOTONE_CONVERGENCE_INCREASING_AE", 13291 ``!f:num->real->real s. 13292 (!k. (f k) integrable_on s) /\ 13293 (!k. ?t. negligible t /\ 13294 !x. x IN s DIFF t ==> (f k x) <= (f (SUC k) x)) /\ 13295 bounded {integral s (f k) | k IN univ(:num)} 13296 ==> ?g k. negligible k /\ 13297 (!x. x IN (s DIFF k) 13298 ==> ((\k. f k x) --> g x) sequentially) /\ 13299 g integrable_on s /\ 13300 ((\k. integral s (f k)) --> integral s g) sequentially``, 13301 REPEAT GEN_TAC THEN SIMP_TAC std_ss [SKOLEM_THM] THEN 13302 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 13303 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 13304 SIMP_TAC std_ss [FORALL_AND_THM] THEN 13305 DISCH_THEN(X_CHOOSE_THEN ``t:num->real->bool`` STRIP_ASSUME_TAC) THEN 13306 MP_TAC(ISPECL 13307 [``\n x. if x IN BIGUNION {t k | k IN univ(:num)} then 0 13308 else (f:num->real->real) n x``, ``s:real->bool``] 13309 BEPPO_LEVI_MONOTONE_CONVERGENCE_INCREASING) THEN 13310 SUBGOAL_THEN 13311 ``negligible(BIGUNION {t k | k IN univ(:num)}:real->bool)`` 13312 ASSUME_TAC THENL [ASM_SIMP_TAC std_ss [NEGLIGIBLE_COUNTABLE_BIGUNION], ALL_TAC] THEN 13313 ASM_SIMP_TAC std_ss [] THEN 13314 KNOW_TAC ``(!(k :num). (\(x :real). 13315 if x IN BIGUNION 13316 {(t :num -> real -> bool) k | k IN univ((:num) :num itself)} 13317 then (0 : real) 13318 else (f :num -> real -> real) k x) integrable_on (s :real -> bool)) /\ 13319 (!(k :num) (x :real). x IN s ==> 13320 (if x IN BIGUNION {t k | k IN univ((:num) :num itself)} then 13321 (0 : real) else f k x) <= 13322 if x IN BIGUNION {t k | k IN univ((:num) :num itself)} then 13323 (0 : real) else f (SUC k) x) /\ 13324 (bounded {integral s (\(x :real). 13325 if x IN BIGUNION {t k | k IN univ((:num) :num itself)} then 13326 (0 : real) else f k x) | 13327 k IN univ((:num) :num itself)} :bool)`` THENL 13328 [REPEAT CONJ_TAC THENL 13329 [X_GEN_TAC ``k:num`` THEN 13330 MATCH_MP_TAC(REWRITE_RULE[AND_IMP_INTRO] INTEGRABLE_SPIKE) THEN 13331 EXISTS_TAC ``(f:num->real->real) k`` THEN 13332 EXISTS_TAC ``BIGUNION {t k | k IN univ(:num)}:real->bool`` THEN 13333 ASM_SIMP_TAC std_ss [IN_DIFF], 13334 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 13335 ASM_REWRITE_TAC[REAL_LE_REFL] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 13336 ASM_SET_TAC[], 13337 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 13338 BOUNDED_SUBSET)) THEN 13339 KNOW_TAC ``{(\k. integral (s :real -> bool) 13340 (\(x :real). if x IN BIGUNION 13341 {(t :num -> real -> bool) k | k IN univ((:num) :num itself)} 13342 then (0 : real) 13343 else (f :num -> real -> real) k x)) k | 13344 k IN univ((:num) :num itself)} SUBSET 13345 {(\k. integral s (f k)) k | k IN univ((:num) :num itself)}`` THENL 13346 [ALL_TAC, METIS_TAC []] THEN 13347 MATCH_MP_TAC(SET_RULE 13348 ``(!x. x IN s ==> (f x = g x)) 13349 ==> {f x | x IN s} SUBSET {g x | x IN s}``) THEN SIMP_TAC std_ss [] THEN 13350 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_SPIKE THEN 13351 EXISTS_TAC ``BIGUNION {t k | k IN univ(:num)}:real->bool`` THEN 13352 ASM_SIMP_TAC std_ss [IN_DIFF]], 13353 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13354 DISCH_THEN (X_CHOOSE_TAC ``g:real->real``) THEN 13355 EXISTS_TAC ``g:real->real`` THEN POP_ASSUM MP_TAC THEN 13356 DISCH_THEN(X_CHOOSE_THEN ``u:real->bool`` STRIP_ASSUME_TAC) THEN 13357 EXISTS_TAC ``u UNION BIGUNION {t k | k IN univ(:num)}:real->bool`` THEN 13358 ASM_REWRITE_TAC[NEGLIGIBLE_UNION_EQ] THEN CONJ_TAC THENL 13359 [X_GEN_TAC ``x:real`` THEN 13360 REWRITE_TAC[IN_DIFF, IN_UNION, DE_MORGAN_THM] THEN STRIP_TAC THEN 13361 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN 13362 ASM_REWRITE_TAC[IN_DIFF], 13363 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (MESON[] 13364 ``(f --> l) sequentially ==> (f = g) ==> (g --> l) sequentially``)) THEN 13365 SIMP_TAC std_ss [FUN_EQ_THM] THEN GEN_TAC THEN 13366 MATCH_MP_TAC INTEGRAL_SPIKE THEN 13367 EXISTS_TAC ``BIGUNION {t k | k IN univ(:num)}:real->bool`` THEN 13368 ASM_SIMP_TAC std_ss [IN_DIFF]]]); 13369 13370val BEPPO_LEVI_MONOTONE_CONVERGENCE_DECREASING_AE = store_thm ("BEPPO_LEVI_MONOTONE_CONVERGENCE_DECREASING_AE", 13371 ``!f:num->real->real s. 13372 (!k. (f k) integrable_on s) /\ 13373 (!k. ?t. negligible t /\ 13374 !x. x IN s DIFF t ==> (f (SUC k) x) <= (f k x)) /\ 13375 bounded {integral s (f k) | k IN univ(:num)} 13376 ==> ?g k. negligible k /\ 13377 (!x. x IN (s DIFF k) 13378 ==> ((\k. f k x) --> g x) sequentially) /\ 13379 g integrable_on s /\ 13380 ((\k. integral s (f k)) --> integral s g) sequentially``, 13381 REPEAT GEN_TAC THEN SIMP_TAC std_ss [SKOLEM_THM] THEN 13382 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 13383 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 13384 SIMP_TAC std_ss [FORALL_AND_THM] THEN 13385 DISCH_THEN(X_CHOOSE_THEN ``t:num->real->bool`` STRIP_ASSUME_TAC) THEN 13386 MP_TAC(ISPECL 13387 [``\n x. if x IN BIGUNION {t k | k IN univ(:num)} then 0 13388 else (f:num->real->real) n x``, ``s:real->bool``] 13389 BEPPO_LEVI_MONOTONE_CONVERGENCE_DECREASING) THEN 13390 SUBGOAL_THEN 13391 ``negligible(BIGUNION {t k | k IN univ(:num)}:real->bool)`` 13392 ASSUME_TAC THENL [ASM_SIMP_TAC std_ss [NEGLIGIBLE_COUNTABLE_BIGUNION], ALL_TAC] THEN 13393 ASM_SIMP_TAC std_ss [] THEN 13394 KNOW_TAC ``(!(k :num). (\(x :real). 13395 if x IN BIGUNION 13396 {(t :num -> real -> bool) k | k IN univ((:num) :num itself)} 13397 then (0 : real) 13398 else (f :num -> real -> real) k x) integrable_on (s :real -> bool)) /\ 13399 (!(k :num) (x :real). x IN s ==> 13400 (if x IN BIGUNION {t k | k IN univ((:num) :num itself)} then 13401 (0 : real) else f (SUC k) x) <= 13402 if x IN BIGUNION {t k | k IN univ((:num) :num itself)} then 13403 (0 : real) 13404 else f k x) /\ (bounded 13405 {integral s (\(x :real). 13406 if x IN BIGUNION {t k | k IN univ((:num) :num itself)} then 13407 (0 : real) 13408 else f k x) | k IN univ((:num) :num itself)} :bool)`` THENL 13409 [REPEAT CONJ_TAC THENL 13410 [X_GEN_TAC ``k:num`` THEN 13411 MATCH_MP_TAC(REWRITE_RULE[AND_IMP_INTRO] INTEGRABLE_SPIKE) THEN 13412 EXISTS_TAC ``(f:num->real->real) k`` THEN 13413 EXISTS_TAC ``BIGUNION {t k | k IN univ(:num)}:real->bool`` THEN 13414 ASM_SIMP_TAC std_ss [IN_DIFF], 13415 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 13416 ASM_SIMP_TAC std_ss [REAL_LE_REFL] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 13417 ASM_SET_TAC[], 13418 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 13419 BOUNDED_SUBSET)) THEN 13420 KNOW_TAC ``{(\k. integral (s :real -> bool) 13421 (\(x :real). if x IN BIGUNION 13422 {(t :num -> real -> bool) k | k IN univ((:num) :num itself)} 13423 then (0 : real) 13424 else (f :num -> real -> real) k x)) k | 13425 k IN univ((:num) :num itself)} SUBSET 13426 {(\k. integral s (f k)) k | k IN univ((:num) :num itself)}`` THENL 13427 [ALL_TAC, METIS_TAC []] THEN 13428 MATCH_MP_TAC(SET_RULE 13429 ``(!x. x IN s ==> (f x = g x)) 13430 ==> {f x | x IN s} SUBSET {g x | x IN s}``) THEN SIMP_TAC std_ss [] THEN 13431 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_SPIKE THEN 13432 EXISTS_TAC ``BIGUNION {t k | k IN univ(:num)}:real->bool`` THEN 13433 ASM_SIMP_TAC std_ss [IN_DIFF]], 13434 13435 DISCH_TAC THEN ASM_SIMP_TAC std_ss [] THEN POP_ASSUM K_TAC THEN 13436 DISCH_THEN (X_CHOOSE_TAC ``g:real->real``) THEN 13437 EXISTS_TAC ``g:real->real`` THEN POP_ASSUM MP_TAC THEN 13438 DISCH_THEN(X_CHOOSE_THEN ``u:real->bool`` STRIP_ASSUME_TAC) THEN 13439 EXISTS_TAC ``u UNION BIGUNION {t k | k IN univ(:num)}:real->bool`` THEN 13440 ASM_SIMP_TAC std_ss [NEGLIGIBLE_UNION_EQ] THEN CONJ_TAC THENL 13441 [X_GEN_TAC ``x:real`` THEN 13442 REWRITE_TAC[IN_DIFF, IN_UNION, DE_MORGAN_THM] THEN STRIP_TAC THEN 13443 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN 13444 ASM_REWRITE_TAC[IN_DIFF], 13445 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (MESON[] 13446 ``(f --> l) sequentially ==> (f = g) ==> (g --> l) sequentially``)) THEN 13447 SIMP_TAC std_ss [FUN_EQ_THM] THEN GEN_TAC THEN 13448 MATCH_MP_TAC INTEGRAL_SPIKE THEN 13449 EXISTS_TAC ``BIGUNION {t k | k IN univ(:num)}:real->bool`` THEN 13450 ASM_SIMP_TAC std_ss [IN_DIFF]]]); 13451 13452(* ------------------------------------------------------------------------- *) 13453(* Fatou's lemma and Lieb's extension. *) 13454(* ------------------------------------------------------------------------- *) 13455 13456val FATOU = store_thm ("FATOU", 13457 ``!f:num->real->real g s t B. 13458 negligible t /\ 13459 (!n. (f n) integrable_on s) /\ 13460 (!n x. x IN s DIFF t ==> &0 <= (f n x)) /\ 13461 (!x. x IN s DIFF t ==> ((\n. f n x) --> g x) sequentially) /\ 13462 (!n. (integral s (f n)) <= B) 13463 ==> g integrable_on s /\ 13464 &0 <= (integral s g) /\ (integral s g) <= B``, 13465 REPEAT GEN_TAC THEN STRIP_TAC THEN 13466 ABBREV_TAC 13467 ``h = \n x. (inf {((f:num->real->real) j x) | n <= j})`` THEN 13468 MP_TAC((GEN ``m:num`` 13469 (ISPECL [``\k:num x:real. (inf {(f j x) | j IN m..(m+k)})``, 13470 ``(h:num->real->real) m``, 13471 ``s:real->bool``, ``t:real->bool``] 13472 MONOTONE_CONVERGENCE_DECREASING_AE))) THEN 13473 ASM_SIMP_TAC std_ss [] THEN 13474 KNOW_TAC ``!(m :num). 13475 (!(k :num). 13476 (\(x :real). 13477 inf 13478 {(f :num -> real -> real) j x | 13479 j IN m .. m + k}) integrable_on (s :real -> bool)) /\ 13480 (!(k :num) (x :real). 13481 x IN s DIFF (t :real -> bool) ==> 13482 inf {f j x | j IN m .. m + SUC k} <= 13483 inf {f j x | j IN m .. m + k}) /\ 13484 (!(x :real). 13485 x IN s DIFF t ==> 13486 (((\(k :num). inf {f j x | j IN m .. m + k}) --> 13487 (h :num -> real -> real) m x) sequentially :bool)) /\ 13488 (bounded 13489 {integral s (\(x :real). inf {f j x | j IN m .. m + k}) | 13490 k IN univ((:num) :num itself)} :bool)`` THENL 13491 [X_GEN_TAC ``m:num`` THEN EXPAND_TAC "h" THEN SIMP_TAC std_ss [] THEN 13492 REPEAT CONJ_TAC THENL 13493 [GEN_TAC THEN MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN 13494 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 13495 REWRITE_TAC [METIS [] ``(\x. inf (IMAGE (\j. f j x) (m .. k + m))) = 13496 (\x. inf (IMAGE ((\x. (\j. f j x)) x) (m .. k + m)))``] THEN 13497 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INF THEN 13498 SIMP_TAC std_ss [FINITE_NUMSEG, NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 13499 ASM_SIMP_TAC std_ss [METIS [ETA_AX] ``(\x. f i x) = f i``] THEN 13500 REPEAT STRIP_TAC THEN 13501 MATCH_MP_TAC NONNEGATIVE_ABSOLUTELY_INTEGRABLE_AE THEN 13502 EXISTS_TAC ``t:real->bool`` THEN 13503 ASM_SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 13504 ASM_SIMP_TAC std_ss [AND_IMP_INTRO], 13505 REPEAT STRIP_TAC THEN SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 13506 MATCH_MP_TAC REAL_LE_INF_SUBSET THEN 13507 SIMP_TAC std_ss [IMAGE_EQ_EMPTY, NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 13508 CONJ_TAC THENL 13509 [MATCH_MP_TAC IMAGE_SUBSET THEN 13510 REWRITE_TAC[SUBSET_NUMSEG] THEN ARITH_TAC, 13511 ALL_TAC] THEN 13512 SIMP_TAC std_ss [FORALL_IN_IMAGE] THEN 13513 ONCE_REWRITE_TAC [METIS [] 13514 ``b <= f j x <=> (b <= (\j. (f:num->real->real) j x) j)``] THEN 13515 MATCH_MP_TAC LOWER_BOUND_FINITE_SET_REAL THEN 13516 REWRITE_TAC[FINITE_NUMSEG], 13517 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 13518 REWRITE_TAC[LIM_SEQUENTIALLY] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 13519 REWRITE_TAC[dist] THEN 13520 MP_TAC(SPEC ``{((f:num->real->real) j x) | m <= j}`` INF) THEN 13521 ABBREV_TAC ``i = inf {((f:num->real->real) j x) | m <= j}`` THEN 13522 REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 13523 IMAGE (\j. f j x) {j | m <= j}``] THEN 13524 SIMP_TAC std_ss [FORALL_IN_IMAGE, EXISTS_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 13525 SIMP_TAC std_ss [GSPECIFICATION, EXTENSION, NOT_IN_EMPTY] THEN 13526 KNOW_TAC ``(?x. m <= x) /\ (?b. !j. m <= j ==> 13527 b <= (f:num->real->real) j x)`` THENL 13528 [ASM_MESON_TAC[LESS_EQ_REFL], 13529 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 13530 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o SPEC ``i + e:real``)) THEN 13531 ASM_SIMP_TAC std_ss [REAL_ARITH ``&0 < e ==> ~(i + e <= i:real)``] THEN 13532 SIMP_TAC std_ss [NOT_FORALL_THM, NOT_IMP, REAL_NOT_LE] THEN 13533 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 13534 X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 13535 REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | j IN s} = 13536 IMAGE (\j. f j x) {j | j IN s}``] THEN 13537 UNDISCH_TAC ``m <= N /\ (f:num->real->real) N x < i + e`` THEN STRIP_TAC THEN 13538 FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 13539 ``y < i + e ==> i <= ix /\ ix <= y ==> abs(ix - i) < e:real``)) THEN 13540 CONJ_TAC THENL 13541 [EXPAND_TAC "i" THEN MATCH_MP_TAC REAL_LE_INF_SUBSET THEN 13542 SIMP_TAC real_ss [IMAGE_EQ_EMPTY, SET_RULE ``{x | x IN s} = s``] THEN 13543 REWRITE_TAC[NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 13544 REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] 13545 ``{(f:num->real->real) j x | m <= j} = 13546 IMAGE (\j. f j x) {j | m <= j}``] THEN 13547 CONJ_TAC THENL 13548 [MATCH_MP_TAC IMAGE_SUBSET THEN 13549 SIMP_TAC std_ss [SUBSET_DEF, IN_NUMSEG, GSPECIFICATION] THEN ARITH_TAC, 13550 SIMP_TAC std_ss [FORALL_IN_IMAGE, GSPECIFICATION] THEN ASM_MESON_TAC[]], 13551 ALL_TAC] THEN 13552 W(MP_TAC o C SPEC INF o rand o lhand o snd) THEN 13553 KNOW_TAC ``IMAGE (\(j :num). (f :num -> real -> real) j (x :real)) 13554 {j | j IN (m :num) .. m + (n :num)} <> ({} :real -> bool) /\ 13555 (?(b :real). !(x' :real). 13556 x' IN IMAGE (\(j :num). f j x) {j | j IN m .. m + n} ==> 13557 b <= x')`` THENL 13558 [SIMP_TAC std_ss [IMAGE_EQ_EMPTY, SET_RULE ``{x | x IN s} = s``] THEN 13559 REWRITE_TAC[NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 13560 SIMP_TAC std_ss [FORALL_IN_IMAGE, GSPECIFICATION] THEN 13561 EXISTS_TAC ``i:real`` THEN GEN_TAC THEN REWRITE_TAC[IN_NUMSEG] THEN 13562 DISCH_THEN(fn th => FIRST_ASSUM MATCH_MP_TAC THEN MP_TAC th) THEN 13563 ARITH_TAC, 13564 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 13565 SIMP_TAC std_ss [FORALL_IN_IMAGE] THEN 13566 DISCH_THEN(MATCH_MP_TAC o CONJUNCT1) THEN 13567 SIMP_TAC std_ss [GSPECIFICATION, IN_NUMSEG] THEN 13568 ASM_SIMP_TAC arith_ss [], 13569 REWRITE_TAC[bounded_def] THEN EXISTS_TAC ``B:real`` THEN 13570 SIMP_TAC std_ss [FORALL_IN_GSPEC, IN_UNIV] THEN 13571 X_GEN_TAC ``n:num`` THEN 13572 MATCH_MP_TAC(REAL_ARITH ``&0 <= x /\ x <= b ==> abs(x) <= b:real``) THEN 13573 CONJ_TAC THENL 13574 [MATCH_MP_TAC INTEGRAL_DROP_POS_AE THEN 13575 EXISTS_TAC ``t:real->bool`` THEN ASM_REWRITE_TAC[] THEN 13576 CONJ_TAC THENL 13577 [ALL_TAC, 13578 REPEAT STRIP_TAC THEN SIMP_TAC std_ss [] THEN MATCH_MP_TAC REAL_LE_INF THEN 13579 ASM_SIMP_TAC real_ss [GSYM IMAGE_DEF, FORALL_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 13580 SIMP_TAC std_ss [NUMSEG_EMPTY, NOT_LESS, LE_ADD]], 13581 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 13582 ``(integral s ((f:num->real->real) m))`` THEN 13583 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC INTEGRAL_DROP_LE THEN 13584 ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THENL 13585 [ALL_TAC, 13586 SIMP_TAC real_ss [REAL_INF_LE_FINITE, GSYM IMAGE_DEF, 13587 IMAGE_FINITE, IMAGE_EQ_EMPTY, FINITE_NUMSEG, IN_NUMSEG, 13588 NUMSEG_EMPTY, NOT_LESS, LE_ADD, EXISTS_IN_IMAGE] THEN 13589 MESON_TAC[REAL_LE_REFL, LESS_EQ_REFL, LE_ADD]]] THEN 13590 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE THEN 13591 SIMP_TAC real_ss [GSYM IMAGE_DEF] THEN 13592 REWRITE_TAC [METIS [] ``(\x. inf (IMAGE (\j. f j x) (m .. m + n))) = 13593 (\x. inf (IMAGE ((\x. (\j. f j x)) x) (m .. m + n)))``] THEN 13594 MATCH_MP_TAC ABSOLUTELY_INTEGRABLE_INF THEN 13595 SIMP_TAC std_ss [FINITE_NUMSEG, NUMSEG_EMPTY, NOT_LESS, LE_ADD] THEN 13596 ASM_SIMP_TAC std_ss [METIS [ETA_AX] ``(\x. f i x) = f i``] THEN 13597 REPEAT STRIP_TAC THEN 13598 MATCH_MP_TAC NONNEGATIVE_ABSOLUTELY_INTEGRABLE_AE THEN 13599 EXISTS_TAC ``t:real->bool`` THEN 13600 ASM_SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 13601 ASM_REWRITE_TAC[AND_IMP_INTRO]], ALL_TAC] THEN 13602 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13603 REWRITE_TAC[FORALL_AND_THM] THEN STRIP_TAC THEN 13604 MP_TAC(ISPECL [``h:num->real->real``, ``g:real->real``, 13605 ``s:real->bool``, ``t:real->bool``] 13606 MONOTONE_CONVERGENCE_INCREASING_AE) THEN 13607 ASM_SIMP_TAC std_ss [] THEN 13608 SUBGOAL_THEN 13609 ``!n. &0 <= (integral s ((h:num->real->real) n)) /\ 13610 (integral s ((h:num->real->real) n)) <= B`` 13611 MP_TAC THENL 13612 [X_GEN_TAC ``m:num`` THEN CONJ_TAC THENL 13613 [MATCH_MP_TAC INTEGRAL_DROP_POS_AE THEN 13614 EXISTS_TAC ``t:real->bool`` THEN ASM_SIMP_TAC std_ss [] THEN 13615 EXPAND_TAC "h" THEN SIMP_TAC std_ss [] THEN 13616 REPEAT STRIP_TAC THEN MATCH_MP_TAC REAL_LE_INF THEN 13617 REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 13618 IMAGE (\j. f j x) {j | m <= j}``] THEN 13619 ASM_SIMP_TAC std_ss [FORALL_IN_IMAGE, IMAGE_EQ_EMPTY] THEN 13620 SIMP_TAC std_ss [EXTENSION, GSPECIFICATION, NOT_IN_EMPTY] THEN 13621 MESON_TAC[LESS_EQ_REFL], 13622 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 13623 ``(integral s ((f:num->real->real) m))`` THEN 13624 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC INTEGRAL_LE_AE THEN 13625 EXISTS_TAC ``t:real->bool`` THEN ASM_REWRITE_TAC[] THEN 13626 REPEAT STRIP_TAC THEN EXPAND_TAC "h" THEN 13627 GEN_REWR_TAC RAND_CONV [GSYM INF_SING] THEN 13628 MATCH_MP_TAC REAL_LE_INF_SUBSET THEN 13629 SIMP_TAC std_ss [NOT_INSERT_EMPTY, SING_SUBSET, FORALL_IN_GSPEC] THEN 13630 CONJ_TAC THENL [SIMP_TAC std_ss [GSPECIFICATION], ASM_MESON_TAC[]] THEN 13631 MESON_TAC[LESS_EQ_REFL, REAL_LE_REFL]], 13632 SIMP_TAC std_ss [FORALL_AND_THM] THEN STRIP_TAC] THEN 13633 KNOW_TAC ``(!(k :num) (x :real). 13634 x IN (s :real -> bool) DIFF (t :real -> bool) ==> 13635 (h :num -> real -> real) k x <= h (SUC k) x) /\ 13636 (!(x :real). 13637 x IN s DIFF t ==> 13638 (((\(k :num). h k x) --> (g :real -> real) x) sequentially : 13639 bool)) /\ 13640 (bounded {integral s (h k) | k IN univ((:num) :num itself)} :bool)`` THENL 13641 [REPEAT CONJ_TAC THENL 13642 [REPEAT STRIP_TAC THEN EXPAND_TAC "h" THEN SIMP_TAC std_ss [] THEN 13643 MATCH_MP_TAC REAL_LE_INF_SUBSET THEN 13644 REWRITE_TAC [METIS [SIMPLE_IMAGE_GEN] ``{(f:num->real->real) j x | m <= j} = 13645 IMAGE (\j. f j x) {j | m <= j}``] THEN 13646 SIMP_TAC std_ss [FORALL_IN_IMAGE, IMAGE_EQ_EMPTY, FORALL_IN_GSPEC] THEN 13647 SIMP_TAC std_ss [EXTENSION, GSPECIFICATION, NOT_IN_EMPTY, NOT_LESS_EQUAL] THEN 13648 REPEAT CONJ_TAC THENL 13649 [EXISTS_TAC ``k + 1:num`` THEN SIMP_TAC arith_ss [], 13650 MATCH_MP_TAC IMAGE_SUBSET THEN 13651 SIMP_TAC std_ss [SUBSET_DEF, GSPECIFICATION] THEN 13652 SIMP_TAC arith_ss [ADD1, IN_IMAGE] THEN GEN_TAC THEN 13653 STRIP_TAC THEN EXISTS_TAC ``j:num`` THEN 13654 FULL_SIMP_TAC std_ss [GSPECIFICATION] THEN POP_ASSUM MP_TAC THEN 13655 ARITH_TAC, 13656 ASM_MESON_TAC[]], 13657 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 13658 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN 13659 ASM_REWRITE_TAC[LIM_SEQUENTIALLY] THEN DISCH_TAC THEN 13660 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 13661 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN 13662 ASM_REWRITE_TAC[REAL_HALF] THEN DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN 13663 EXISTS_TAC ``N:num`` THEN POP_ASSUM MP_TAC THEN 13664 REWRITE_TAC[dist] THEN REPEAT STRIP_TAC THEN 13665 KNOW_TAC ``!h g. &0 < e /\ g - e / &2 <= h /\ h <= g + e / &2 ==> 13666 abs(h - g) < e:real`` THENL 13667 [ONCE_REWRITE_TAC [REAL_ARITH ``a - b <= c <=> a - c <= b:real``, 13668 REAL_ARITH ``a <= b + c <=> a - b <= c:real``] THEN 13669 SIMP_TAC std_ss [REAL_LE_LDIV_EQ, REAL_LE_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 13670 REAL_ARITH_TAC, DISCH_TAC] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 13671 ASM_SIMP_TAC std_ss [] THEN EXPAND_TAC "h" THEN SIMP_TAC std_ss [] THEN 13672 MATCH_MP_TAC REAL_INF_BOUNDS THEN SIMP_TAC std_ss [FORALL_IN_GSPEC] THEN 13673 SIMP_TAC std_ss [SET_RULE ``({f n | P n} = {}) <=> !n. ~P n``] THEN 13674 CONJ_TAC THENL [MESON_TAC[LESS_EQ_REFL], GEN_TAC THEN DISCH_TAC] THEN 13675 KNOW_TAC ``!h g. abs(h - g) < e / &2 ==> 13676 g - e / &2 <= h /\ h <= g + e / &2:real`` THENL 13677 [ONCE_REWRITE_TAC [REAL_ARITH ``a - b <= c <=> a - c <= b:real``, 13678 REAL_ARITH ``a <= b + c <=> a - b <= c:real``] THEN 13679 SIMP_TAC std_ss [REAL_LE_LDIV_EQ, REAL_LE_RDIV_EQ, REAL_LT_RDIV_EQ, 13680 REAL_ARITH ``0 < 2:real``] THEN REAL_ARITH_TAC, 13681 DISCH_TAC] THEN 13682 FIRST_X_ASSUM MATCH_MP_TAC THEN METIS_TAC[LESS_EQ_TRANS], 13683 SIMP_TAC std_ss [bounded_def, FORALL_IN_GSPEC] THEN EXISTS_TAC ``B:real`` THEN 13684 REPEAT STRIP_TAC THEN REWRITE_TAC[] THEN 13685 MATCH_MP_TAC(REAL_ARITH ``&0 <= x /\ x <= b ==> abs x <= b:real``) THEN 13686 ASM_REWRITE_TAC[]], 13687 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13688 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN CONJ_TAC THENL 13689 [MATCH_MP_TAC(ISPEC ``sequentially`` LIM_DROP_LBOUND), 13690 MATCH_MP_TAC(ISPEC ``sequentially`` LIM_DROP_UBOUND)] THEN 13691 EXISTS_TAC ``\n. integral s ((h:num->real->real) n)`` THEN 13692 ASM_SIMP_TAC real_ss [TRIVIAL_LIMIT_SEQUENTIALLY, EVENTUALLY_TRUE]]); 13693 13694(* ------------------------------------------------------------------------- *) 13695(* Fundamental theorem of calculus, starting with strong forms. 12023 *) 13696(* ------------------------------------------------------------------------- *) 13697 13698val FUNDAMENTAL_THEOREM_OF_CALCULUS_STRONG = store_thm ("FUNDAMENTAL_THEOREM_OF_CALCULUS_STRONG", 13699 ``!f:real->real f' s a b. 13700 COUNTABLE s /\ 13701 a <= b /\ f continuous_on interval[a,b] /\ 13702 (!x. x IN interval[a,b] DIFF s 13703 ==> (f has_vector_derivative f'(x)) (at x within interval[a,b])) 13704 ==> (f' has_integral (f(b) - f(a))) (interval[a,b])``, 13705 REPEAT STRIP_TAC THEN 13706 MATCH_MP_TAC HAS_INTEGRAL_SPIKE THEN 13707 EXISTS_TAC ``(\x. if x IN s then 0 else f' x):real->real`` THEN 13708 EXISTS_TAC ``s:real->bool`` THEN 13709 ASM_SIMP_TAC std_ss [NEGLIGIBLE_COUNTABLE, IN_DIFF] THEN 13710 SUBGOAL_THEN 13711 ``?f t. (s = IMAGE (f:num->real) t) /\ 13712 (!m n. m IN t /\ n IN t /\ (f m = f n) ==> (m = n))`` 13713 MP_TAC THENL 13714 [ASM_CASES_TAC ``FINITE(s:real->bool)`` THENL 13715 [FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINITE_INDEX_NUMSEG]) THEN 13716 ASM_MESON_TAC[], 13717 MP_TAC(ISPEC ``s:real->bool`` COUNTABLE_AS_INJECTIVE_IMAGE) THEN 13718 ASM_REWRITE_TAC[] THEN MESON_TAC[IN_UNIV]], 13719 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM, INJECTIVE_ON_LEFT_INVERSE] THEN 13720 MAP_EVERY X_GEN_TAC [``r:num->real``, ``t:num->bool``] THEN 13721 DISCH_THEN(CONJUNCTS_THEN2 SUBST_ALL_TAC MP_TAC) THEN 13722 DISCH_THEN(X_CHOOSE_TAC ``n:real->num``)] THEN 13723 REWRITE_TAC[HAS_INTEGRAL_FACTOR_CONTENT] THEN 13724 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 13725 SUBGOAL_THEN 13726 ``!x. ?d. &0 < d /\ 13727 (x IN interval[a,b] 13728 ==> (x IN IMAGE (r:num->real) t 13729 ==> !y. abs(y - x) < d /\ y IN interval[a,b] 13730 ==> abs(f y - f x) 13731 <= e / &2 pow (4 + n x) * abs(b - a)) /\ 13732 (~(x IN IMAGE r t) 13733 ==> !y. abs(y - x) < d /\ y IN interval[a,b] 13734 ==> abs(f y - f x - (y - x) * f' x:real) 13735 <= e / &2 * abs(y - x)))`` 13736 MP_TAC THENL 13737 [X_GEN_TAC ``x:real`` THEN 13738 ASM_CASES_TAC ``(x:real) IN interval[a,b]`` THENL 13739 [ALL_TAC, EXISTS_TAC ``&1:real`` THEN ASM_REWRITE_TAC[REAL_LT_01]] THEN 13740 ASM_CASES_TAC ``x IN IMAGE (r:num->real) t`` THEN ASM_REWRITE_TAC[] THENL 13741 [FIRST_ASSUM(MP_TAC o MATCH_MP (REAL_ARITH 13742 ``a <= b ==> (a = b:real) \/ a < b``)) THEN 13743 REWRITE_TAC[] THEN STRIP_TAC THENL 13744 [EXISTS_TAC ``&1:real`` THEN REWRITE_TAC[REAL_LT_01] THEN 13745 UNDISCH_TAC ``(x:real) IN interval[a,b]`` THEN 13746 ASM_SIMP_TAC std_ss [INTERVAL_SING, IN_SING, REAL_SUB_REFL, ABS_0] THEN 13747 REAL_ARITH_TAC, 13748 UNDISCH_TAC ``f continuous_on interval [(a,b)]`` THEN DISCH_TAC THEN 13749 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [continuous_on]) THEN 13750 DISCH_THEN(MP_TAC o SPEC ``x:real``) THEN ASM_REWRITE_TAC[dist] THEN 13751 DISCH_THEN(MP_TAC o SPEC 13752 ``e / &2 pow (4 + n(x:real)) * abs(b - a:real)``) THEN 13753 ASM_SIMP_TAC std_ss [REAL_LT_DIV, REAL_LT_MUL, GSYM ABS_NZ, REAL_SUB_0, 13754 REAL_LT_POW2, REAL_LT_IMP_NE] THEN 13755 MESON_TAC[REAL_LT_IMP_LE]], 13756 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN 13757 ASM_SIMP_TAC std_ss [IN_DIFF, has_vector_derivative, 13758 HAS_DERIVATIVE_WITHIN_ALT] THEN 13759 DISCH_THEN(MP_TAC o SPEC ``e / &2:real`` o CONJUNCT2) THEN 13760 ASM_REWRITE_TAC[REAL_HALF] THEN MESON_TAC[]], 13761 DISCH_TAC THEN POP_ASSUM (MP_TAC o SIMP_RULE std_ss [RIGHT_IMP_EXISTS_THM]) THEN 13762 SIMP_TAC std_ss [SKOLEM_THM, LEFT_IMP_EXISTS_THM, FORALL_AND_THM, AND_IMP_INTRO, 13763 TAUT `p ==> q /\ r <=> (p ==> q) /\ (p ==> r)`] THEN 13764 X_GEN_TAC ``d:real->real`` THEN 13765 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 13766 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)] THEN 13767 EXISTS_TAC ``\x. ball(x:real,d(x))`` THEN 13768 ASM_SIMP_TAC std_ss [GAUGE_BALL_DEPENDENT] THEN 13769 X_GEN_TAC ``p:(real#(real->bool))->bool`` THEN STRIP_TAC THEN 13770 MP_TAC(ISPECL [``f:real->real``, ``p:(real#(real->bool))->bool``, 13771 ``a:real``, ``b:real``] 13772 ADDITIVE_TAGGED_DIVISION_1) THEN 13773 ASM_SIMP_TAC std_ss [CONTENT_CLOSED_INTERVAL] THEN DISCH_THEN(SUBST1_TAC o SYM) THEN 13774 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 13775 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 13776 ASM_SIMP_TAC std_ss [GSYM SUM_SUB, LAMBDA_PROD] THEN 13777 SUBGOAL_THEN 13778 ``p:(real#(real->bool))->bool = 13779 {(x,k) | (x,k) IN p /\ x IN IMAGE r (t:num->bool)} UNION 13780 {(x,k) | (x,k) IN p /\ ~(x IN IMAGE r (t:num->bool))}`` 13781 SUBST1_TAC THENL 13782 [SIMP_TAC std_ss [EXTENSION, FORALL_PROD, IN_ELIM_PAIR_THM, IN_UNION] THEN 13783 MESON_TAC[], 13784 ALL_TAC] THEN 13785 W(MP_TAC o PART_MATCH (lhs o rand) SUM_UNION o rand o lhand o snd) THEN 13786 KNOW_TAC ``FINITE 13787 {(x,k) | 13788 (x,k) IN (p :real # (real -> bool) -> bool) /\ 13789 x IN IMAGE (r :num -> real) (t :num -> bool)} /\ 13790 FINITE {(x,k) | (x,k) IN p /\ x NOTIN IMAGE r t} /\ 13791 DISJOINT {(x,k) | (x,k) IN p /\ x IN IMAGE r t} 13792 {(x,k) | (x,k) IN p /\ x NOTIN IMAGE r t}`` THENL 13793 [REWRITE_TAC[SET_RULE ``DISJOINT s t <=> !x. x IN s ==> ~(x IN t)``] THEN 13794 SIMP_TAC std_ss [FORALL_IN_GSPEC, IN_ELIM_PAIR_THM] THEN CONJ_TAC THEN 13795 MATCH_MP_TAC FINITE_SUBSET THEN 13796 EXISTS_TAC ``p:(real#(real->bool))->bool`` THEN 13797 ASM_SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC, IN_ELIM_PAIR_THM], 13798 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13799 DISCH_THEN SUBST1_TAC] THEN 13800 SUBGOAL_THEN 13801 ``(!P. FINITE {(x:real,k:real->bool) | (x,k) IN p /\ P x k}) /\ 13802 (!P x. FINITE {(x:real,k:real->bool) |k| (x,k) IN p /\ P x k})`` 13803 STRIP_ASSUME_TAC THENL 13804 [REPEAT STRIP_TAC THEN MATCH_MP_TAC FINITE_SUBSET THEN 13805 EXISTS_TAC ``p:real#(real->bool)->bool`` THEN 13806 ASM_SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC], 13807 ALL_TAC] THEN 13808 KNOW_TAC ``!x y e a. abs(x:real) <= e / &2 * a /\ abs(y) <= e / &2 * a 13809 ==> abs(x + y) <= e * a`` THENL 13810 [REPEAT GEN_TAC THEN REWRITE_TAC [real_div] THEN 13811 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c = (a * c) * b:real``] THEN 13812 REWRITE_TAC [GSYM real_div] THEN 13813 SIMP_TAC std_ss [REAL_LE_RDIV_EQ, REAL_ARITH ``0 < &2:real``] THEN 13814 REAL_ARITH_TAC, DISCH_TAC] THEN 13815 FIRST_X_ASSUM (MATCH_MP_TAC) THEN 13816 CONJ_TAC THENL 13817 [MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 13818 ``abs(sum {(x,k) | (x,k) IN p /\ x IN IMAGE (r:num->real) t /\ 13819 ~(content k = &0)} 13820 (\(x,k). -(f(interval_upperbound k) - 13821 (f:real->real)(interval_lowerbound k))))`` THEN 13822 CONJ_TAC THENL 13823 [MATCH_MP_TAC REAL_EQ_IMP_LE THEN AP_TERM_TAC THEN 13824 MATCH_MP_TAC SUM_EQ_SUPERSET THEN 13825 ASM_SIMP_TAC std_ss [FORALL_IN_GSPEC, IMP_CONJ] THEN 13826 CONJ_TAC THENL [SIMP_TAC std_ss [LAMBDA_PAIR] THEN SET_TAC[], ALL_TAC] THEN 13827 SIMP_TAC std_ss [REAL_ARITH ``a * 0 - x:real = -x``] THEN 13828 SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN 13829 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 13830 SUBGOAL_THEN ``?u v:real. (k = interval[u,v]) /\ x IN interval[u,v]`` 13831 STRIP_ASSUME_TAC THENL 13832 [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 13833 ASM_REWRITE_TAC[CONTENT_EQ_0] THEN 13834 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [IN_INTERVAL]) THEN 13835 DISCH_THEN(MP_TAC o MATCH_MP REAL_LE_TRANS) THEN 13836 SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, 13837 GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LE, REAL_NOT_LT] THEN 13838 REPEAT STRIP_TAC THEN MATCH_MP_TAC(REAL_ARITH 13839 ``(x:real = y) ==> (-(x - y) = 0)``) THEN 13840 AP_TERM_TAC THEN ASM_SIMP_TAC std_ss [GSYM REAL_LE_ANTISYM], 13841 ALL_TAC] THEN 13842 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 13843 ``sum {(x,k:real->bool) | (x,k) IN p /\ x IN IMAGE (r:num->real) t /\ 13844 ~(content k = &0)} 13845 ((\(x,k). e / &2 pow (3 + n x) * abs (b - a:real)))`` THEN 13846 CONJ_TAC THENL 13847 [MATCH_MP_TAC SUM_ABS_LE THEN 13848 ASM_SIMP_TAC std_ss [FORALL_IN_GSPEC, IMP_CONJ] THEN 13849 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 13850 SUBGOAL_THEN ``?u v:real. (k = interval[u,v]) /\ x IN interval[u,v]`` 13851 MP_TAC THENL [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 13852 DISCH_THEN(REPEAT_TCL CHOOSE_THEN 13853 (CONJUNCTS_THEN2 SUBST_ALL_TAC MP_TAC)) THEN 13854 SIMP_TAC std_ss [CONTENT_EQ_0, REAL_NOT_LE, REAL_LT_IMP_LE, IN_INTERVAL, 13855 INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 13856 REPEAT STRIP_TAC THEN 13857 UNDISCH_TAC ``!(x :real). 13858 x IN interval [((a :real),(b :real))] /\ 13859 x IN IMAGE (r :num -> real) (t :num -> bool) ==> 13860 !(y :real). 13861 abs (y - x) < (d :real -> real) x /\ y IN interval [(a,b)] ==> 13862 abs ((f :real -> real) y - f x) <= 13863 (e :real) / (2 :real) pow ((4 :num) + (n :real -> num) x) * 13864 abs (b - a)`` THEN DISCH_TAC THEN 13865 FIRST_X_ASSUM (MP_TAC o SPEC ``x:real``) THEN 13866 KNOW_TAC ``(x :real) IN interval [((a :real),(b :real))] /\ 13867 x IN IMAGE (r :num -> real) (t :num -> bool)`` THENL 13868 [ASM_MESON_TAC[TAGGED_DIVISION_OF, SUBSET_DEF], 13869 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 13870 DISCH_THEN(fn th => 13871 MP_TAC(ISPEC ``u:real`` th) THEN MP_TAC(ISPEC ``v:real`` th)) THEN 13872 UNDISCH_TAC ``(\x. ball (x,d x)) FINE p`` THEN DISCH_TAC THEN 13873 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN BETA_TAC THEN 13874 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``interval[u:real,v]``]) THEN 13875 ASM_REWRITE_TAC[SUBSET_DEF, IN_BALL] THEN 13876 DISCH_THEN(fn th => 13877 MP_TAC(ISPEC ``u:real`` th) THEN MP_TAC(ISPEC ``v:real`` th)) THEN 13878 ASM_REWRITE_TAC[dist, ENDS_IN_INTERVAL, INTERVAL_NE_EMPTY] THEN 13879 ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE, ABS_SUB] THEN DISCH_TAC THEN DISCH_TAC THEN 13880 SUBGOAL_THEN ``interval[u:real,v] SUBSET interval[a,b]`` ASSUME_TAC THENL 13881 [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 13882 KNOW_TAC ``v IN interval [(a,b)]`` THENL 13883 [ASM_MESON_TAC[ENDS_IN_INTERVAL, SUBSET_DEF, INTERVAL_NE_EMPTY, 13884 REAL_LT_IMP_LE], 13885 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13886 ONCE_REWRITE_TAC[TAUT `p ==> q ==> r <=> q ==> p ==> r`]] THEN 13887 KNOW_TAC ``u IN interval [(a,b)]`` THENL 13888 [ASM_MESON_TAC[ENDS_IN_INTERVAL, SUBSET_DEF, INTERVAL_NE_EMPTY, 13889 REAL_LT_IMP_LE], 13890 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13891 ONCE_REWRITE_TAC[TAUT `p ==> q ==> r <=> q ==> p ==> r`]] THEN 13892 SIMP_TAC std_ss [REAL_POW_ADD, real_div, REAL_INV_MUL] THEN 13893 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c = (a * c) * b:real``] THEN 13894 REWRITE_TAC [GSYM real_div] THEN 13895 SIMP_TAC std_ss [REAL_LE_RDIV_EQ, 13896 METIS [REAL_LT_MUL, REAL_LT_POW2] ``0:real < (2 pow 3 * 2 pow n x)``, 13897 METIS [REAL_LT_MUL, REAL_LT_POW2] ``0:real < (2 pow 4 * 2 pow n x)``] THEN 13898 ONCE_REWRITE_TAC [ARITH_PROVE ``4 = SUC 3``] THEN ONCE_REWRITE_TAC [pow] THEN 13899 ONCE_REWRITE_TAC [REAL_ARITH ``a * (b * c * d) = (a * c * d) * b:real``] THEN 13900 SIMP_TAC std_ss [GSYM REAL_LE_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 13901 GEN_REWR_TAC (RAND_CONV o RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 13902 DISCH_TAC THEN DISCH_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN 13903 EXISTS_TAC `` abs ((f :real -> real) (v :real) - f (x :real)) * 13904 (2 :real) pow (3 :num) * (2 :real) pow (n :real -> num) x + 13905 abs ((f :real -> real) (u :real) - f (x :real)) * 13906 (2 :real) pow (3 :num) * (2 :real) pow (n :real -> num) x`` THEN 13907 CONJ_TAC THENL [ALL_TAC, MATCH_MP_TAC REAL_LE_ADD2] THEN 13908 ASM_REWRITE_TAC [] THEN 13909 REWRITE_TAC [GSYM REAL_ADD_RDISTRIB] THEN REWRITE_TAC [REAL_MUL_ASSOC] THEN 13910 MATCH_MP_TAC REAL_LE_RMUL_IMP THEN 13911 SIMP_TAC std_ss [REAL_LE_LT, REAL_LT_POW2] THEN 13912 REWRITE_TAC [GSYM REAL_LE_LT] THEN MATCH_MP_TAC REAL_LE_RMUL_IMP THEN 13913 SIMP_TAC std_ss [REAL_LE_LT, REAL_LT_POW2] THEN 13914 REWRITE_TAC [GSYM REAL_LE_LT] THEN 13915 REAL_ARITH_TAC, ALL_TAC] THEN 13916 MP_TAC(ISPECL 13917 [``FST:real#(real->bool)->real``, 13918 ``\(x:real,k:real->bool). e / &2 pow (3 + n x) * abs (b - a:real)``, 13919 ``{(x:real,k:real->bool) | (x,k) IN p /\ x IN IMAGE (r:num->real) t /\ 13920 ~(content k = &0)}``, 13921 ``IMAGE (r:num->real) t``] SUM_GROUP) THEN 13922 KNOW_TAC ``FINITE 13923 {(x,k) | 13924 (x,k) IN (p :real # (real -> bool) -> bool) /\ 13925 x IN IMAGE (r :num -> real) (t :num -> bool) /\ 13926 content k <> (0 :real)} /\ 13927 IMAGE (FST :real # (real -> bool) -> real) 13928 {(x,k) | 13929 (x,k) IN p /\ x IN IMAGE r t /\ content k <> (0 :real)} SUBSET 13930 IMAGE r t`` THENL 13931 [ASM_SIMP_TAC std_ss [] THEN 13932 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_IMAGE, FORALL_IN_GSPEC], 13933 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 13934 DISCH_THEN(SUBST1_TAC o SYM)] THEN 13935 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 13936 ``sum (IMAGE (r:num->real) t) 13937 (\x. sum {(x,k:real->bool) |k| 13938 (x,k) IN p /\ ~(content k = &0)} 13939 (\yk. e / &2 pow (3 + n x) * abs(b - a:real)))`` THEN 13940 CONJ_TAC THENL 13941 [MATCH_MP_TAC REAL_EQ_IMP_LE THEN MATCH_MP_TAC SUM_EQ THEN 13942 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN SIMP_TAC std_ss [] THEN 13943 MATCH_MP_TAC SUM_EQ_SUPERSET THEN 13944 ASM_SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC, IMP_CONJ] THEN 13945 SIMP_TAC std_ss [GSPECIFICATION, PAIR_EQ, LAMBDA_PAIR] THEN METIS_TAC[], 13946 ALL_TAC] THEN 13947 ASM_SIMP_TAC std_ss [SUM_CONST] THEN REWRITE_TAC [REAL_MUL_ASSOC] THEN 13948 SIMP_TAC std_ss [SUM_RMUL] THEN 13949 ASM_SIMP_TAC std_ss [abs, REAL_SUB_LE] THEN MATCH_MP_TAC REAL_LE_RMUL_IMP THEN 13950 ASM_SIMP_TAC std_ss [REAL_SUB_LE, REAL_POW_ADD, real_div, REAL_INV_MUL, 13951 REAL_LT_POW2, REAL_LT_IMP_NE, REAL_MUL_ASSOC] THEN 13952 KNOW_TAC ``!p e n. p * e * inv(&2 pow 3) * n = e / &8 * (p * n):real`` THENL 13953 [REPEAT GEN_TAC THEN REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN 13954 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c * d = (a * c * d) * b:real``] THEN 13955 REWRITE_TAC [GSYM real_div] THEN 13956 SIMP_TAC std_ss [REAL_EQ_RDIV_EQ, REAL_ARITH ``0 < 8:real``] THEN 13957 REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN 13958 ONCE_REWRITE_TAC [REAL_ARITH 13959 ``a * b * c * d * e = (a * c * d * e) * b:real``] THEN 13960 REWRITE_TAC [GSYM real_div] THEN 13961 SIMP_TAC std_ss [REAL_EQ_LDIV_EQ, REAL_LT_POW2] THEN 13962 REWRITE_TAC [ARITH_PROVE ``3 = SUC 2``, pow, POW_2] THEN REAL_ARITH_TAC, 13963 DISCH_TAC THEN ONCE_ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 13964 KNOW_TAC ``!e x. e / &8 * x <= e * inv(&2) <=> e * x <= e * &4:real`` THENL 13965 [REPEAT GEN_TAC THEN REWRITE_TAC [GSYM real_div] THEN 13966 SIMP_TAC std_ss [REAL_LE_RDIV_EQ, REAL_ARITH ``0 < 2:real``] THEN 13967 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c = b * c * a:real``] THEN 13968 REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN REWRITE_TAC [GSYM real_div] THEN 13969 SIMP_TAC std_ss [REAL_LE_LDIV_EQ, REAL_ARITH ``0 < 8:real``] THEN 13970 REAL_ARITH_TAC, 13971 DISCH_TAC THEN ASM_SIMP_TAC std_ss [REAL_LE_LMUL, SUM_LMUL] THEN 13972 POP_ASSUM K_TAC] THEN 13973 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 13974 ``sum (IMAGE (r:num->real) t INTER 13975 IMAGE (FST:real#(real->bool)->real) p) 13976 (\x. &(CARD {(x,k:real->bool) | k | 13977 (x,k) IN p /\ ~(content k = &0)}) * 13978 inv(&2 pow n x))`` THEN 13979 CONJ_TAC THENL 13980 [MATCH_MP_TAC REAL_EQ_IMP_LE THEN MATCH_MP_TAC SUM_SUPERSET THEN 13981 SIMP_TAC std_ss [INTER_SUBSET, IMP_CONJ, FORALL_IN_IMAGE] THEN 13982 SIMP_TAC std_ss [IN_INTER, FUN_IN_IMAGE] THEN 13983 SIMP_TAC std_ss [IN_IMAGE, EXISTS_PROD] THEN 13984 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_ENTIRE] THEN 13985 DISJ1_TAC THEN AP_TERM_TAC THEN 13986 MATCH_MP_TAC(METIS [CARD_EMPTY, CARD_INSERT] ``(s = {}) ==> (CARD s = 0)``) THEN 13987 ASM_SET_TAC[], ALL_TAC] THEN 13988 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 13989 ``sum (IMAGE (r:num->real) t INTER 13990 IMAGE (FST:real#(real->bool)->real) p) 13991 (\x. &2 / &2 pow (n x))`` THEN 13992 CONJ_TAC THENL 13993 [MATCH_MP_TAC SUM_LE THEN 13994 ASM_SIMP_TAC std_ss [IMAGE_FINITE, FINITE_INTER] THEN 13995 GEN_TAC THEN DISCH_TAC THEN REWRITE_TAC[real_div] THEN 13996 MATCH_MP_TAC REAL_LE_RMUL_IMP THEN 13997 SIMP_TAC std_ss [REAL_LE_INV_EQ, POW_POS, REAL_POS, REAL_OF_NUM_LE] THEN 13998 GEN_REWR_TAC RAND_CONV [GSYM EXP_1] THEN 13999 MATCH_MP_TAC TAGGED_PARTIAL_DIVISION_COMMON_TAGS THEN 14000 ASM_MESON_TAC[tagged_division_of], 14001 ALL_TAC] THEN 14002 SIMP_TAC std_ss [real_div, SUM_LMUL, REAL_ARITH ``&2 * x <= &4 <=> x <= &2:real``, 14003 POW_INV, REAL_ARITH ``2 <> 0:real``] THEN 14004 SUBGOAL_THEN 14005 ``(\x:real. inv (&2) pow n x) = (\n. inv(&2:real) pow n) o n`` 14006 SUBST1_TAC THENL [SIMP_TAC std_ss [o_DEF], ALL_TAC] THEN 14007 W(MP_TAC o PART_MATCH (rand o rand) SUM_IMAGE o lhand o snd) THEN 14008 KNOW_TAC ``(!(x :real) (y :real). 14009 x IN 14010 IMAGE (r :num -> real) (t :num -> bool) INTER 14011 IMAGE (FST :real # (real -> bool) -> real) 14012 (p :real # (real -> bool) -> bool) /\ 14013 y IN IMAGE r t INTER IMAGE (FST :real # (real -> bool) -> real) p /\ 14014 ((n :real -> num) x = n y) ==> 14015 (x = y))`` THENL 14016 [ASM_SET_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 14017 POP_ASSUM K_TAC THEN DISCH_THEN(SUBST1_TAC o SYM)] THEN 14018 SUBGOAL_THEN 14019 ``?m. IMAGE (n:real->num) 14020 (IMAGE (r:num->real) t INTER 14021 IMAGE (FST:real#(real->bool)->real) p) SUBSET ((0:num)..m)`` 14022 STRIP_ASSUME_TAC THENL 14023 [REWRITE_TAC[SUBSET_DEF, IN_NUMSEG, LE_0] THEN 14024 GEN_REWR_TAC (QUANT_CONV o QUANT_CONV o RAND_CONV o LAND_CONV) 14025 [METIS [] ``x = (\x. x) x``] THEN 14026 MATCH_MP_TAC UPPER_BOUND_FINITE_SET THEN 14027 ASM_SIMP_TAC std_ss [IMAGE_FINITE, FINITE_INTER], 14028 ALL_TAC] THEN 14029 MATCH_MP_TAC REAL_LE_TRANS THEN 14030 EXISTS_TAC ``sum((0:num)..m) (\n. inv(&2) pow n)`` THEN CONJ_TAC THENL 14031 [MATCH_MP_TAC SUM_SUBSET THEN 14032 ASM_SIMP_TAC std_ss [IMAGE_FINITE, FINITE_INTER, FINITE_NUMSEG] THEN 14033 SIMP_TAC std_ss [REAL_LE_INV_EQ, POW_POS, REAL_POS] THEN ASM_SET_TAC[], 14034 SIMP_TAC std_ss [SUM_GP, LT, SUB_0] THEN 14035 SIMP_TAC std_ss [METIS [REAL_ARITH ``1 <> 2:real``, REAL_INV_1OVER, 14036 REAL_EQ_LDIV_EQ, REAL_ARITH ``0 < 2:real``, REAL_MUL_LID] 14037 ``inv 2 <> 1:real``, pow, REAL_INV_1OVER] THEN 14038 SIMP_TAC std_ss [METIS [REAL_HALF_DOUBLE, REAL_EQ_SUB_RADD] 14039 ``1 - 1 / 2 = 1 / 2:real``] THEN 14040 SIMP_TAC std_ss [GSYM pow] THEN 14041 KNOW_TAC ``!x. (&1 - x) / (&1 / &2) <= &2 <=> &0 <= x:real`` THENL 14042 [REPEAT GEN_TAC THEN REWRITE_TAC [real_div, REAL_MUL_ASSOC, 14043 REAL_MUL_LID, REAL_INV_INV] THEN 14044 REAL_ARITH_TAC, DISCH_TAC] THEN 14045 ASM_REWRITE_TAC [] THEN MATCH_MP_TAC POW_POS THEN 14046 SIMP_TAC std_ss [REAL_LE_RDIV_EQ, REAL_ARITH ``0 < 2:real``, REAL_MUL_LZERO, 14047 REAL_ARITH ``0 <= 1:real``]], 14048 MP_TAC(ISPECL [``\x:real. x``, ``p:(real#(real->bool))->bool``, 14049 ``a:real``, ``b:real``] ADDITIVE_TAGGED_DIVISION_1) THEN 14050 ASM_SIMP_TAC std_ss [] THEN DISCH_THEN(SUBST1_TAC o SYM) THEN 14051 REWRITE_TAC[GSYM SUM_LMUL] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 14052 EXISTS_TAC 14053 ``sum {(x:real,k:real->bool) | 14054 (x,k) IN p /\ ~(x IN IMAGE r (t:num->bool))} 14055 (\x. e / &2 * 14056 (\(x,k). interval_upperbound k - interval_lowerbound k) x)`` THEN 14057 CONJ_TAC THENL 14058 [MATCH_MP_TAC SUM_ABS_LE THEN ASM_SIMP_TAC std_ss [FORALL_IN_GSPEC] THEN 14059 SIMP_TAC std_ss [o_DEF] THEN 14060 REWRITE_TAC[REAL_ARITH ``abs(a - (b - c):real) = abs(b - c - a)``] THEN 14061 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN STRIP_TAC THEN 14062 SUBGOAL_THEN ``?u v:real. (k = interval[u,v]) /\ x IN interval[u,v]`` 14063 MP_TAC THENL [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 14064 DISCH_THEN(REPEAT_TCL CHOOSE_THEN 14065 (CONJUNCTS_THEN2 SUBST_ALL_TAC MP_TAC)) THEN 14066 REWRITE_TAC[IN_INTERVAL] THEN DISCH_THEN(fn th => 14067 ASSUME_TAC th THEN MP_TAC(MATCH_MP REAL_LE_TRANS th)) THEN 14068 ASM_SIMP_TAC std_ss [CONTENT_CLOSED_INTERVAL, 14069 INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 14070 DISCH_TAC THEN 14071 UNDISCH_TAC `` !(x :real). 14072 x IN interval [((a :real),(b :real))] /\ 14073 x NOTIN IMAGE (r :num -> real) (t :num -> bool) ==> 14074 !(y :real). 14075 abs (y - x) < (d :real -> real) x /\ y IN interval [(a,b)] ==> 14076 abs 14077 ((f :real -> real) y - f x - 14078 (y - x) * (f' :real -> real) x) <= 14079 (e :real) / (2 :real) * abs (y - x)`` THEN DISCH_TAC THEN 14080 FIRST_X_ASSUM (MP_TAC o SPEC ``x:real``) THEN 14081 ASM_REWRITE_TAC[] THEN 14082 SUBGOAL_THEN ``interval[u:real,v] SUBSET interval[a,b]`` ASSUME_TAC THENL 14083 [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 14084 KNOW_TAC ``x IN interval [(a,b)]`` THENL 14085 [ASM_MESON_TAC[SUBSET_DEF, IN_INTERVAL], 14086 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 14087 DISCH_THEN(fn th => 14088 MP_TAC(ISPEC ``u:real`` th) THEN MP_TAC(ISPEC ``v:real`` th)) THEN 14089 UNDISCH_TAC ``(\x. ball (x,d x)) FINE p`` THEN DISCH_TAC THEN 14090 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 14091 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``interval[u:real,v]``]) THEN 14092 ASM_SIMP_TAC std_ss [SUBSET_DEF, IN_BALL] THEN 14093 DISCH_THEN(fn th => 14094 MP_TAC(ISPEC ``u:real`` th) THEN MP_TAC(ISPEC ``v:real`` th)) THEN 14095 ASM_SIMP_TAC std_ss [dist, ENDS_IN_INTERVAL, INTERVAL_NE_EMPTY] THEN 14096 ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE, ABS_SUB] THEN DISCH_TAC THEN DISCH_TAC THEN 14097 KNOW_TAC ``v IN interval [(a,b)]`` THENL 14098 [ASM_MESON_TAC[ENDS_IN_INTERVAL, SUBSET_DEF, INTERVAL_NE_EMPTY, 14099 REAL_LT_IMP_LE], 14100 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 14101 ONCE_REWRITE_TAC[TAUT `p ==> q ==> r <=> q ==> p ==> r`]] THEN 14102 KNOW_TAC ``u IN interval [(a,b)]`` THENL 14103 [ASM_MESON_TAC[ENDS_IN_INTERVAL, SUBSET_DEF, INTERVAL_NE_EMPTY, 14104 REAL_LT_IMP_LE], 14105 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 14106 ONCE_REWRITE_TAC[TAUT `p ==> q ==> r <=> q ==> p ==> r`]] THEN 14107 ASM_SIMP_TAC std_ss [REAL_ARITH ``a <= b ==> (abs(a - b) = b - a:real)``, 14108 REAL_ARITH ``b <= a ==> (abs(a - b) = a - b:real)``] THEN 14109 REWRITE_TAC[REAL_SUB_LDISTRIB] THEN MATCH_MP_TAC(REAL_ARITH 14110 ``(x - y:real = z) ==> abs(x) <= c - b 14111 ==> abs(y) <= b - a ==> abs(z) <= c - a``) THEN 14112 REAL_ARITH_TAC, 14113 MATCH_MP_TAC SUM_SUBSET_SIMPLE THEN ASM_REWRITE_TAC[] THEN 14114 CONJ_TAC THENL [SIMP_TAC std_ss [LAMBDA_PAIR] THEN ASM_SET_TAC[], 14115 SIMP_TAC std_ss [FORALL_PROD]] THEN 14116 SIMP_TAC std_ss [IN_DIFF, IN_ELIM_PAIR_THM] THEN 14117 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN STRIP_TAC THEN 14118 SUBGOAL_THEN ``?u v:real. (k = interval[u,v]) /\ x IN interval[u,v]`` 14119 MP_TAC THENL [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 14120 DISCH_THEN(REPEAT_TCL CHOOSE_THEN 14121 (CONJUNCTS_THEN2 SUBST_ALL_TAC MP_TAC)) THEN 14122 REWRITE_TAC[IN_INTERVAL, o_THM] THEN 14123 DISCH_THEN(MP_TAC o MATCH_MP REAL_LE_TRANS) THEN 14124 SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 14125 REPEAT STRIP_TAC THEN MATCH_MP_TAC REAL_LE_MUL THEN 14126 CONJ_TAC THENL [REWRITE_TAC [REAL_LE_LT] THEN 14127 ASM_SIMP_TAC std_ss [REAL_HALF], ALL_TAC] THEN 14128 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC]]); 14129 14130val FUNDAMENTAL_THEOREM_OF_CALCULUS_INTERIOR_STRONG = store_thm ("FUNDAMENTAL_THEOREM_OF_CALCULUS_INTERIOR_STRONG", 14131 ``!f:real->real f' s a b. 14132 COUNTABLE s /\ 14133 a <= b /\ f continuous_on interval[a,b] /\ 14134 (!x. x IN interval(a,b) DIFF s 14135 ==> (f has_vector_derivative f'(x)) (at x)) 14136 ==> (f' has_integral (f(b) - f(a))) (interval[a,b])``, 14137 REPEAT STRIP_TAC THEN 14138 MATCH_MP_TAC FUNDAMENTAL_THEOREM_OF_CALCULUS_STRONG THEN 14139 EXISTS_TAC ``(a:real) INSERT (b:real) INSERT s`` THEN 14140 ASM_REWRITE_TAC[COUNTABLE_INSERT, IN_INTERVAL, IN_DIFF] THEN 14141 REWRITE_TAC[DE_MORGAN_THM, IN_INSERT] THEN 14142 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_VECTOR_DERIVATIVE_AT_WITHIN THEN 14143 FIRST_X_ASSUM MATCH_MP_TAC THEN 14144 ASM_REWRITE_TAC[IN_INTERVAL, IN_DIFF, IN_INSERT] THEN 14145 METIS_TAC[REAL_LT_LE]); 14146 14147val FUNDAMENTAL_THEOREM_OF_CALCULUS = store_thm ("FUNDAMENTAL_THEOREM_OF_CALCULUS", 14148 ``!f:real->real f' a b. 14149 a <= b /\ 14150 (!x. x IN interval[a,b] 14151 ==> (f has_vector_derivative f'(x)) (at x within interval[a,b])) 14152 ==> (f' has_integral (f(b) - f(a))) (interval[a,b])``, 14153 REPEAT STRIP_TAC THEN 14154 MATCH_MP_TAC FUNDAMENTAL_THEOREM_OF_CALCULUS_STRONG THEN 14155 EXISTS_TAC ``{}:real->bool`` THEN 14156 ASM_REWRITE_TAC[COUNTABLE_EMPTY, DIFF_EMPTY] THEN 14157 MATCH_MP_TAC DIFFERENTIABLE_IMP_CONTINUOUS_ON THEN 14158 REWRITE_TAC[differentiable_on] THEN 14159 METIS_TAC[has_vector_derivative, differentiable]); 14160 14161val FUNDAMENTAL_THEOREM_OF_CALCULUS_INTERIOR = store_thm ("FUNDAMENTAL_THEOREM_OF_CALCULUS_INTERIOR", 14162 ``!f:real->real f' a b. 14163 a <= b /\ f continuous_on interval[a,b] /\ 14164 (!x. x IN interval(a,b) 14165 ==> (f has_vector_derivative f'(x)) (at x)) 14166 ==> (f' has_integral (f(b) - f(a))) (interval[a,b])``, 14167 REPEAT STRIP_TAC THEN 14168 MATCH_MP_TAC FUNDAMENTAL_THEOREM_OF_CALCULUS_INTERIOR_STRONG THEN 14169 EXISTS_TAC ``{}:real->bool`` THEN 14170 ASM_REWRITE_TAC[COUNTABLE_EMPTY, DIFF_EMPTY]); 14171 14172val ANTIDERIVATIVE_INTEGRAL_CONTINUOUS = store_thm ("ANTIDERIVATIVE_INTEGRAL_CONTINUOUS", 14173 ``!f:real->real a b. 14174 (f continuous_on interval[a,b]) 14175 ==> ?g. !u v. u IN interval[a,b] /\ v IN interval[a,b] /\ u <= v 14176 ==> (f has_integral (g(v) - g(u))) (interval[u,v])``, 14177 REPEAT STRIP_TAC THEN 14178 FIRST_ASSUM(MP_TAC o MATCH_MP ANTIDERIVATIVE_CONTINUOUS) THEN 14179 STRIP_TAC THEN EXISTS_TAC ``g:real->real`` THEN 14180 REPEAT STRIP_TAC THEN MATCH_MP_TAC FUNDAMENTAL_THEOREM_OF_CALCULUS THEN 14181 ASM_REWRITE_TAC[] THEN X_GEN_TAC ``x:real`` THEN 14182 STRIP_TAC THEN MATCH_MP_TAC HAS_VECTOR_DERIVATIVE_WITHIN_SUBSET THEN 14183 EXISTS_TAC ``interval[a:real,b]`` THEN CONJ_TAC THENL 14184 [FIRST_X_ASSUM MATCH_MP_TAC, ALL_TAC] THEN 14185 REPEAT(POP_ASSUM MP_TAC) THEN 14186 REWRITE_TAC[SUBSET_INTERVAL, IN_INTERVAL] THENL 14187 [REAL_ARITH_TAC, METIS_TAC [REAL_LE_TRANS]]); 14188 14189(* ------------------------------------------------------------------------- *) 14190(* This doesn't directly involve integration, but that gives an easy proof. *) 14191(* ------------------------------------------------------------------------- *) 14192 14193val HAS_DERIVATIVE_ZERO_UNIQUE_STRONG_INTERVAL = store_thm ("HAS_DERIVATIVE_ZERO_UNIQUE_STRONG_INTERVAL", 14194 ``!f:real->real a b k y. 14195 COUNTABLE k /\ f continuous_on interval[a,b] /\ (f a = y) /\ 14196 (!x. x IN (interval[a,b] DIFF k) 14197 ==> (f has_derivative (\h. 0)) (at x within interval[a,b])) 14198 ==> !x. x IN interval[a,b] ==> (f x = y)``, 14199 REPEAT STRIP_TAC THEN ONCE_REWRITE_TAC[GSYM REAL_SUB_0] THEN 14200 MATCH_MP_TAC(ISPEC ``(\x. 0):real->real`` HAS_INTEGRAL_UNIQUE) THEN 14201 EXISTS_TAC ``interval[a:real,x]`` THEN 14202 REWRITE_TAC[HAS_INTEGRAL_0] THEN FIRST_X_ASSUM(SUBST_ALL_TAC o SYM) THEN 14203 MATCH_MP_TAC FUNDAMENTAL_THEOREM_OF_CALCULUS_INTERIOR_STRONG THEN 14204 EXISTS_TAC ``k:real->bool`` THEN ASM_SIMP_TAC std_ss [] THEN REPEAT CONJ_TAC THENL 14205 [REPEAT(FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [IN_INTERVAL])) THEN 14206 SIMP_TAC std_ss [], 14207 MATCH_MP_TAC CONTINUOUS_ON_SUBSET THEN 14208 EXISTS_TAC ``interval[a:real,b]`` THEN 14209 ASM_REWRITE_TAC[SUBSET_INTERVAL] THEN 14210 REPEAT(FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [IN_INTERVAL])) THEN 14211 SIMP_TAC std_ss [REAL_LE_REFL], 14212 X_GEN_TAC ``y:real`` THEN DISCH_TAC THEN 14213 FIRST_X_ASSUM(MP_TAC o SPEC ``y:real``) THEN 14214 KNOW_TAC ``y IN interval [(a,b)] DIFF k`` THENL 14215 [REPEAT(POP_ASSUM MP_TAC) THEN 14216 SIMP_TAC std_ss [IN_DIFF, IN_INTERVAL] THEN REAL_ARITH_TAC, 14217 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 14218 DISCH_THEN(MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 14219 HAS_DERIVATIVE_WITHIN_SUBSET)) THEN 14220 DISCH_THEN(MP_TAC o SPEC ``interval(a:real,b)``) THEN 14221 REWRITE_TAC[INTERVAL_OPEN_SUBSET_CLOSED] THEN 14222 REWRITE_TAC[has_vector_derivative, REAL_MUL_RZERO] THEN 14223 MATCH_MP_TAC EQ_IMPLIES THEN MATCH_MP_TAC HAS_DERIVATIVE_WITHIN_OPEN THEN 14224 REPEAT(POP_ASSUM MP_TAC) THEN 14225 SIMP_TAC std_ss [OPEN_INTERVAL, IN_INTERVAL, IN_DIFF] THEN REAL_ARITH_TAC]); 14226 14227(* ------------------------------------------------------------------------- *) 14228(* Integration by parts. *) 14229(* ------------------------------------------------------------------------- *) 14230 14231val INTEGRATION_BY_PARTS = store_thm ("INTEGRATION_BY_PARTS", 14232 ``!(bop:real->real->real) f g f' g' a b c y. 14233 bilinear bop /\ a <= b /\ COUNTABLE c /\ 14234 (\x. bop (f x) (g x)) continuous_on interval[a,b] /\ 14235 (!x. x IN interval(a,b) DIFF c 14236 ==> (f has_vector_derivative f'(x)) (at x) /\ 14237 (g has_vector_derivative g'(x)) (at x)) /\ 14238 ((\x. bop (f x) (g' x)) has_integral 14239 ((bop (f b) (g b) - bop (f a) (g a)) - y)) 14240 (interval[a,b]) 14241 ==> ((\x. bop (f' x) (g x)) has_integral y) (interval[a,b])``, 14242 REPEAT STRIP_TAC THEN 14243 MP_TAC(ISPECL [``\x:real. (bop:real->real->real) (f x) (g x)``, 14244 ``\x:real. (bop:real->real->real) (f x) (g' x) + 14245 (bop:real->real->real) (f' x) (g x)``, 14246 ``c:real->bool``, ``a:real``, ``b:real``] 14247 FUNDAMENTAL_THEOREM_OF_CALCULUS_INTERIOR_STRONG) THEN 14248 ASM_SIMP_TAC std_ss [HAS_VECTOR_DERIVATIVE_BILINEAR_AT] THEN 14249 FIRST_ASSUM(fn th => MP_TAC th THEN REWRITE_TAC[GSYM IMP_CONJ_ALT] THEN 14250 DISCH_THEN(MP_TAC o MATCH_MP HAS_INTEGRAL_SUB)) THEN 14251 SIMP_TAC std_ss [REAL_ARITH ``b - a - (b - a - y):real = y``, REAL_ADD_SUB]); 14252 14253val INTEGRATION_BY_PARTS_SIMPLE = store_thm ("INTEGRATION_BY_PARTS_SIMPLE", 14254 ``!(bop:real->real->real) f g f' g' a b y. 14255 bilinear bop /\ a <= b /\ 14256 (!x. x IN interval[a,b] 14257 ==> (f has_vector_derivative f'(x)) (at x within interval[a,b]) /\ 14258 (g has_vector_derivative g'(x)) (at x within interval[a,b])) /\ 14259 ((\x. bop (f x) (g' x)) has_integral 14260 ((bop (f b) (g b) - bop (f a) (g a)) - y)) 14261 (interval[a,b]) 14262 ==> ((\x. bop (f' x) (g x)) has_integral y) (interval[a,b])``, 14263 REPEAT STRIP_TAC THEN 14264 MP_TAC(ISPECL [``\x:real. (bop:real->real->real) (f x) (g x)``, 14265 ``\x:real. (bop:real->real->real) (f x) (g' x) + 14266 (bop:real->real->real) (f' x) (g x)``, 14267 ``a:real``, ``b:real``] 14268 FUNDAMENTAL_THEOREM_OF_CALCULUS) THEN 14269 ASM_SIMP_TAC std_ss [HAS_VECTOR_DERIVATIVE_BILINEAR_WITHIN] THEN 14270 FIRST_ASSUM(fn th => MP_TAC th THEN REWRITE_TAC[GSYM IMP_CONJ_ALT] THEN 14271 DISCH_THEN(MP_TAC o MATCH_MP HAS_INTEGRAL_SUB)) THEN 14272 SIMP_TAC std_ss [REAL_ARITH ``b - a - (b - a - y):real = y``, REAL_ADD_SUB]); 14273 14274val INTEGRABLE_BY_PARTS = store_thm ("INTEGRABLE_BY_PARTS", 14275 ``!(bop:real->real->real) f g f' g' a b c. 14276 bilinear bop /\ COUNTABLE c /\ 14277 (\x. bop (f x) (g x)) continuous_on interval[a,b] /\ 14278 (!x. x IN interval(a,b) DIFF c 14279 ==> (f has_vector_derivative f'(x)) (at x) /\ 14280 (g has_vector_derivative g'(x)) (at x)) /\ 14281 (\x. bop (f x) (g' x)) integrable_on interval[a,b] 14282 ==> (\x. bop (f' x) (g x)) integrable_on interval[a,b]``, 14283 REPEAT GEN_TAC THEN 14284 DISJ_CASES_TAC(REAL_ARITH ``b <= a \/ a <= b:real``) THENL 14285 [DISCH_THEN(K ALL_TAC) THEN MATCH_MP_TAC INTEGRABLE_ON_NULL THEN 14286 ASM_REWRITE_TAC[CONTENT_EQ_0], 14287 REPEAT(DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC)) THEN 14288 REWRITE_TAC[integrable_on] THEN 14289 DISCH_THEN(X_CHOOSE_THEN ``y:real`` STRIP_ASSUME_TAC) THEN 14290 EXISTS_TAC ``(bop ((f:real->real) b) ((g:real->real) b) - 14291 bop (f a) (g a)) - (y:real)`` THEN 14292 MATCH_MP_TAC INTEGRATION_BY_PARTS THEN MAP_EVERY EXISTS_TAC 14293 [``f:real->real``, ``g':real->real``, ``c:real->bool``] THEN 14294 ASM_REWRITE_TAC[REAL_ARITH ``b - a - ((b - a) - y):real = y``]]); 14295 14296val INTEGRABLE_BY_PARTS_EQ = store_thm ("INTEGRABLE_BY_PARTS_EQ", 14297 ``!(bop:real->real->real) f g f' g' a b c. 14298 bilinear bop /\ COUNTABLE c /\ 14299 (\x. bop (f x) (g x)) continuous_on interval[a,b] /\ 14300 (!x. x IN interval(a,b) DIFF c 14301 ==> (f has_vector_derivative f'(x)) (at x) /\ 14302 (g has_vector_derivative g'(x)) (at x)) 14303 ==> ((\x. bop (f x) (g' x)) integrable_on interval[a,b] <=> 14304 (\x. bop (f' x) (g x)) integrable_on interval[a,b])``, 14305 REPEAT STRIP_TAC THEN EQ_TAC THENL 14306 [METIS_TAC[INTEGRABLE_BY_PARTS], DISCH_TAC] THEN 14307 MP_TAC(ISPEC ``\x y. (bop:real->real->real) y x`` 14308 INTEGRABLE_BY_PARTS) THEN 14309 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 14310 KNOW_TAC ``bilinear (\(x :real) (y :real). (bop :real -> real -> real) y x)`` THENL 14311 [ALL_TAC, METIS_TAC[]] THEN 14312 UNDISCH_TAC ``bilinear(bop:real->real->real)`` THEN 14313 REWRITE_TAC[bilinear] THEN METIS_TAC[]); 14314 14315(* ------------------------------------------------------------------------- *) 14316(* Equiintegrability. The definition here only really makes sense for an *) 14317(* elementary set. We just use compact intervals in applications below. *) 14318(* ------------------------------------------------------------------------- *) 14319 14320val _ = set_fixity "equiintegrable_on" (Infix(NONASSOC, 450)); 14321 14322val equiintegrable_on = new_definition ("equiintegrable_on", 14323 ``fs equiintegrable_on i <=> 14324 (!f:real->real. f IN fs ==> f integrable_on i) /\ 14325 (!e. &0 < e 14326 ==> ?d. gauge d /\ 14327 !f p. f IN fs /\ p tagged_division_of i /\ d FINE p 14328 ==> abs(sum p (\(x,k). content(k) * f(x)) - 14329 integral i f) < e)``); 14330 14331val EQUIINTEGRABLE_ON_SING = store_thm ("EQUIINTEGRABLE_ON_SING", 14332 ``!f:real->real a b. 14333 {f} equiintegrable_on interval[a,b] <=> 14334 f integrable_on interval[a,b]``, 14335 REPEAT GEN_TAC THEN REWRITE_TAC[equiintegrable_on] THEN 14336 SIMP_TAC std_ss [IN_SING, UNWIND_FORALL_THM2] THEN 14337 ASM_CASES_TAC ``(f:real->real) integrable_on interval[a,b]`` THEN 14338 ASM_SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, UNWIND_FORALL_THM2] THEN 14339 FIRST_ASSUM(MP_TAC o MATCH_MP INTEGRABLE_INTEGRAL) THEN 14340 REWRITE_TAC[has_integral, AND_IMP_INTRO]); 14341 14342(* ------------------------------------------------------------------------- *) 14343(* Basic combining theorems for the interval of integration. *) 14344(* ------------------------------------------------------------------------- *) 14345 14346val EQUIINTEGRABLE_ON_NULL = store_thm ("EQUIINTEGRABLE_ON_NULL", 14347 ``!fs:(real->real)->bool a b. 14348 (content(interval[a,b]) = &0) ==> fs equiintegrable_on interval[a,b]``, 14349 REPEAT STRIP_TAC THEN REWRITE_TAC[equiintegrable_on] THEN 14350 ASM_SIMP_TAC std_ss [INTEGRABLE_ON_NULL] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 14351 EXISTS_TAC ``\x:real. ball(x,&1)`` THEN REWRITE_TAC[GAUGE_TRIVIAL] THEN 14352 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP (REWRITE_RULE[IMP_CONJ] 14353 SUM_CONTENT_NULL) th]) THEN 14354 ASM_SIMP_TAC std_ss [INTEGRAL_NULL, REAL_SUB_REFL, ABS_0]); 14355 14356val lemma1 = prove ( 14357 ``(!x k. (x,k) IN {x,f k | P x k} ==> Q x k) <=> 14358 (!x k. P x k ==> Q x (f k))``, 14359 REWRITE_TAC[GSPECIFICATION, PAIR_EQ] THEN 14360 SET_TAC[]); 14361 14362val lemma2 = prove ( 14363 ``!f:'b->'b s:('a#'b)->bool. 14364 FINITE s ==> FINITE {x,f k | (x,k) IN s /\ P x k}``, 14365 REPEAT STRIP_TAC THEN MATCH_MP_TAC FINITE_SUBSET THEN 14366 EXISTS_TAC ``IMAGE (\(x:'a,k:'b). x,(f k:'b)) s`` THEN 14367 ASM_SIMP_TAC std_ss [IMAGE_FINITE] THEN 14368 SIMP_TAC std_ss [SUBSET_DEF, FORALL_PROD, lemma1, IN_IMAGE] THEN 14369 SIMP_TAC std_ss [EXISTS_PROD, PAIR_EQ] THEN METIS_TAC[]); 14370 14371val lemma3 = prove ( 14372 ``!f:real->real g:(real->bool)->(real->bool) p. 14373 FINITE p 14374 ==> (sum {x,g k |x,k| (x,k) IN p /\ ~(g k = {})} 14375 (\(x,k). content k * f x) = 14376 sum (IMAGE (\(x,k). x,g k) p) (\(x,k). content k * f x))``, 14377 REPEAT STRIP_TAC THEN CONV_TAC SYM_CONV THEN MATCH_MP_TAC SUM_SUPERSET THEN 14378 ASM_SIMP_TAC std_ss [IMAGE_FINITE, lemma2] THEN 14379 SIMP_TAC std_ss [IMP_CONJ, FORALL_IN_IMAGE] THEN 14380 SIMP_TAC std_ss [FORALL_PROD, SUBSET_DEF, IN_IMAGE, EXISTS_PROD] THEN 14381 SIMP_TAC std_ss [GSPECIFICATION, PAIR_EQ, REAL_ENTIRE, EXISTS_PROD] THEN 14382 METIS_TAC[CONTENT_EMPTY]); 14383 14384val lemma4 = prove ( 14385 ``(\(x,l). content (g l) * f x) = 14386 (\(x,l). content l * f x) o (\(x,l). x,g l)``, 14387 SIMP_TAC std_ss [FUN_EQ_THM, o_THM, FORALL_PROD]); 14388 14389val EQUIINTEGRABLE_ON_SPLIT = store_thm ("EQUIINTEGRABLE_ON_SPLIT", 14390 ``!fs:(real->real)->bool k a b c. 14391 fs equiintegrable_on (interval[a,b] INTER {x | x <= c}) /\ 14392 fs equiintegrable_on (interval[a,b] INTER {x | x >= c}) 14393 ==> fs equiintegrable_on (interval[a,b])``, 14394 REPEAT GEN_TAC THEN 14395 REWRITE_TAC[equiintegrable_on] THEN 14396 MATCH_MP_TAC(TAUT 14397 `(a /\ b ==> c) /\ (a /\ b /\ c ==> a' /\ b' ==> c') 14398 ==> (a /\ a') /\ (b /\ b') ==> c /\ c'`) THEN 14399 CONJ_TAC THENL 14400 [REWRITE_TAC[integrable_on] THEN METIS_TAC[HAS_INTEGRAL_SPLIT], 14401 STRIP_TAC] THEN 14402 SUBGOAL_THEN 14403 ``!f:real->real. 14404 f IN fs 14405 ==> (integral (interval[a,b]) f = 14406 integral (interval [a,b] INTER {x | x <= c}) f + 14407 integral (interval [a,b] INTER {x | x >= c}) f)`` 14408 (fn th => SIMP_TAC std_ss [th]) 14409 THENL 14410 [REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRAL_UNIQUE THEN 14411 MATCH_MP_TAC HAS_INTEGRAL_SPLIT THEN 14412 MAP_EVERY EXISTS_TAC [``c:real``] THEN 14413 ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRAL], 14414 ALL_TAC] THEN 14415 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN STRIP_TAC THEN 14416 FIRST_X_ASSUM(CONJUNCTS_THEN2 (MP_TAC o SPEC ``e / &2:real``) STRIP_ASSUME_TAC) THEN 14417 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 14418 DISCH_THEN(X_CHOOSE_THEN ``d2:real->real->bool`` 14419 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 14420 DISCH_THEN(X_CHOOSE_THEN ``d1:real->real->bool`` 14421 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 14422 EXISTS_TAC ``\x. if x = c then (d1(x:real) INTER d2(x)):real->bool 14423 else ball(x,abs(x - c)) INTER d1(x) INTER d2(x)`` THEN 14424 CONJ_TAC THENL 14425 [REWRITE_TAC[gauge_def] THEN GEN_TAC THEN 14426 RULE_ASSUM_TAC(REWRITE_RULE[gauge_def]) THEN 14427 SIMP_TAC std_ss [] THEN COND_CASES_TAC THEN 14428 ASM_SIMP_TAC std_ss [OPEN_INTER, IN_INTER, OPEN_BALL, IN_BALL] THEN 14429 ASM_REWRITE_TAC[DIST_REFL, GSYM ABS_NZ, REAL_SUB_0], 14430 ALL_TAC] THEN 14431 X_GEN_TAC ``f:real->real`` THEN 14432 X_GEN_TAC ``p:(real#(real->bool))->bool`` THEN STRIP_TAC THEN 14433 SUBGOAL_THEN 14434 ``(!x:real kk. (x,kk) IN p /\ ~(kk INTER {x:real | x <= c} = {}) 14435 ==> x <= c) /\ 14436 (!x:real kk. (x,kk) IN p /\ ~(kk INTER {x:real | x >= c} = {}) 14437 ==> x >= c)`` 14438 STRIP_ASSUME_TAC THENL 14439 [CONJ_TAC THEN FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 14440 SIMP_TAC std_ss [] THEN DISCH_TAC THEN 14441 X_GEN_TAC ``x:real`` THEN X_GEN_TAC ``kk:real->bool`` THEN 14442 POP_ASSUM (MP_TAC o SPECL [``x:real``, ``kk:real->bool``]) THEN 14443 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THEN 14444 COND_CASES_TAC THEN ASM_REWRITE_TAC[REAL_LE_REFL, real_ge] THEN DISCH_THEN 14445 (MP_TAC o MATCH_MP (SET_RULE ``k SUBSET (a INTER b) ==> k SUBSET a``)) THEN 14446 DISCH_THEN 14447 (MP_TAC o MATCH_MP (SET_RULE ``k SUBSET (a INTER b) ==> k SUBSET a``)) THEN 14448 SIMP_TAC std_ss [SUBSET_DEF, IN_BALL, dist] THEN DISCH_TAC THENL 14449 [UNDISCH_TAC ``kk INTER {x:real | x <= c} <> {}``, 14450 UNDISCH_TAC ``kk INTER {x:real | x >= c} <> {}``] THEN DISCH_TAC THEN 14451 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [GSYM MEMBER_NOT_EMPTY]) THEN 14452 DISCH_THEN(X_CHOOSE_THEN ``u:real`` MP_TAC) THEN 14453 SIMP_TAC std_ss [IN_INTER, GSPECIFICATION] THEN REPEAT STRIP_TAC THEN 14454 FIRST_X_ASSUM(MP_TAC o SPEC ``u:real``) THEN ASM_SIMP_TAC std_ss [] THEN 14455 ONCE_REWRITE_TAC[MONO_NOT_EQ] THEN 14456 SIMP_TAC std_ss [REAL_NOT_LE, REAL_NOT_LT] THEN STRIP_TAC THEN 14457 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC ``abs((x - u:real))`` THEN 14458 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 14459 ALL_TAC] THEN 14460 UNDISCH_TAC ``!f p. 14461 f IN fs /\ 14462 p tagged_division_of interval [(a,b)] INTER {x | x >= c} /\ 14463 d2 FINE p ==> 14464 abs (sum p (\(x,k). content k * f x) - 14465 integral (interval [(a,b)] INTER {x | x >= c}) f) < e / 2`` THEN 14466 DISCH_TAC THEN 14467 FIRST_X_ASSUM (MP_TAC o SPEC 14468 ``{(x:real,kk INTER {x:real | x >= c}) |x,kk| 14469 (x,kk) IN p /\ ~(kk INTER {x:real | x >= c} = {})}`` o 14470 SPEC ``f:real->real``) THEN 14471 UNDISCH_TAC ``!f p. 14472 f IN fs /\ 14473 p tagged_division_of interval [(a,b)] INTER {x | x <= c} /\ 14474 d1 FINE p ==> 14475 abs (sum p (\(x,k). content k * f x) - 14476 integral (interval [(a,b)] INTER {x | x <= c}) f) < e / 2`` THEN 14477 DISCH_TAC THEN 14478 FIRST_X_ASSUM (MP_TAC o SPEC 14479 ``{(x:real,kk INTER {x:real | x <= c}) |x,kk| 14480 (x,kk) IN p /\ ~(kk INTER {x:real | x <= c} = {})}`` o 14481 SPEC ``f:real->real``) THEN 14482 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC(TAUT 14483 `(a /\ b) /\ (a' /\ b' ==> c) ==> (a ==> a') ==> (b ==> b') ==> c`) THEN 14484 CONJ_TAC THENL 14485 [UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 14486 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 14487 REWRITE_TAC[TAGGED_DIVISION_OF] THEN 14488 REPEAT(MATCH_MP_TAC(TAUT 14489 `(a ==> (a' /\ a'')) /\ (b ==> (b' /\ d) /\ (b'' /\ e)) 14490 ==> a /\ b ==> ((a' /\ b') /\ d) /\ ((a'' /\ b'') /\ e)`) THEN 14491 CONJ_TAC) THEN 14492 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 14493 SIMP_TAC std_ss [lemma1] THEN REWRITE_TAC[AND_IMP_INTRO] THENL 14494 [SIMP_TAC std_ss [lemma2], 14495 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN 14496 DISCH_TAC THEN X_GEN_TAC ``x:real`` THEN X_GEN_TAC ``kk:real->bool`` THEN 14497 POP_ASSUM (MP_TAC o SPECL [``x:real``,``kk:real->bool``]) THEN 14498 DISCH_THEN(fn th => CONJ_TAC THEN STRIP_TAC THEN MP_TAC th) THEN 14499 (ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 14500 [SIMP_TAC std_ss [IN_INTER, GSPECIFICATION] THEN ASM_MESON_TAC[], ALL_TAC]) THEN 14501 (MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL [SET_TAC[], ALL_TAC]) THEN 14502 METIS_TAC[INTERVAL_SPLIT], 14503 DISCH_THEN(fn th => CONJ_TAC THEN MP_TAC th) THEN 14504 (DISCH_TAC THEN X_GEN_TAC ``x1:real`` THEN X_GEN_TAC ``k1:real->bool`` THEN 14505 POP_ASSUM (MP_TAC o SPECL [``x1:real``,``k1:real->bool``]) THEN 14506 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THEN 14507 DISCH_TAC THEN X_GEN_TAC ``x2:real`` THEN X_GEN_TAC ``k2:real->bool`` THEN 14508 POP_ASSUM (MP_TAC o SPECL [``x2:real``,``k2:real->bool``]) THEN 14509 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THEN 14510 (KNOW_TAC ``(x1 <> x2:real) \/ (k1 <> k2:real->bool)`` THENL 14511 [METIS_TAC[PAIR_EQ], ALL_TAC] THEN DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 14512 MATCH_MP_TAC(SET_RULE 14513 ``s SUBSET s' /\ t SUBSET t' 14514 ==> (s' INTER t' = {}) ==> (s INTER t = {})``) THEN 14515 CONJ_TAC THEN MATCH_MP_TAC SUBSET_INTERIOR THEN SET_TAC[])), 14516 ALL_TAC] THEN 14517 MATCH_MP_TAC(TAUT `(a ==> b /\ c) /\ d /\ e 14518 ==> (a ==> (b /\ d) /\ (c /\ e))`) THEN 14519 CONJ_TAC THENL 14520 [DISCH_THEN(fn th => CONJ_TAC THEN MP_TAC th) THEN 14521 DISCH_THEN(SUBST1_TAC o SYM) THEN REWRITE_TAC[INTER_BIGUNION] THEN 14522 ONCE_REWRITE_TAC[EXTENSION] THEN REWRITE_TAC[IN_BIGUNION] THEN 14523 X_GEN_TAC ``x:real`` THEN AP_TERM_TAC THEN 14524 GEN_REWR_TAC I [FUN_EQ_THM] THEN X_GEN_TAC ``kk:real->bool`` THEN 14525 SIMP_TAC std_ss [GSPECIFICATION, PAIR_EQ, EXISTS_PROD] THEN 14526 METIS_TAC[NOT_IN_EMPTY], 14527 ALL_TAC] THEN 14528 UNDISCH_TAC ``(\x. 14529 if x = c then d1 x INTER d2 x 14530 else ball (x,abs (x - c)) INTER d1 x INTER d2 x) FINE p`` THEN DISCH_TAC THEN 14531 CONJ_TAC THEN FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 14532 SIMP_TAC std_ss [FINE, lemma1] THEN 14533 DISCH_TAC THEN X_GEN_TAC ``x:real`` THEN X_GEN_TAC ``k:real->bool`` THEN 14534 POP_ASSUM (MP_TAC o SPECL [``x:real``,``k:real->bool``]) THEN 14535 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 14536 ASM_SIMP_TAC std_ss [] THEN SET_TAC[], 14537 ALL_TAC] THEN 14538 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 14539 DISCH_THEN(MP_TAC o MATCH_MP (REAL_ARITH 14540 ``x < e / &2 /\ y < e / &2 ==> x + y < e / 2 + e / 2:real``)) THEN 14541 REWRITE_TAC [REAL_HALF] THEN 14542 DISCH_THEN(MP_TAC o MATCH_MP ABS_TRIANGLE_LT) THEN 14543 MATCH_MP_TAC EQ_IMPLIES THEN AP_THM_TAC THEN AP_TERM_TAC THEN AP_TERM_TAC THEN 14544 REWRITE_TAC[REAL_ARITH 14545 ``((a - i) + (b - j) = c - (i + j)) <=> (a + b = c:real)``] THEN 14546 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 14547 MATCH_MP_TAC EQ_TRANS THEN 14548 EXISTS_TAC 14549 ``sum p (\(x,l). content (l INTER {x:real | x <= c}) * 14550 (f:real->real) x) + 14551 sum p (\(x,l). content (l INTER {x:real | x >= c}) * 14552 (f:real->real) x)`` THEN 14553 CONJ_TAC THENL 14554 [ALL_TAC, 14555 ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN MATCH_MP_TAC SUM_EQ THEN 14556 SIMP_TAC std_ss [FORALL_PROD, GSYM REAL_ADD_RDISTRIB] THEN 14557 MAP_EVERY X_GEN_TAC [``x:real``, ``l:real->bool``] THEN 14558 DISCH_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN 14559 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 14560 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 14561 DISCH_THEN (CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 14562 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 14563 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``l:real->bool``]) THEN 14564 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN 14565 ASM_SIMP_TAC std_ss [GSYM CONTENT_SPLIT]] THEN 14566 ASM_SIMP_TAC std_ss [lemma3] THEN BINOP_TAC THENL 14567 [ONCE_REWRITE_TAC [METIS [] 14568 ``(\(x,l). content (l INTER {x | x <= c}) * f x) = 14569 (\(x,l). content ((\l. l INTER {x | x <= c}) l) * f x)``], 14570 ONCE_REWRITE_TAC [METIS [] 14571 ``(\(x,l). content (l INTER {x | x >= c}) * f x) = 14572 (\(x,l). content ((\l. l INTER {x | x >= c}) l) * f x)``]] THEN 14573 (GEN_REWR_TAC (RAND_CONV o RAND_CONV) [lemma4] THEN 14574 SIMP_TAC std_ss [] THEN 14575 MATCH_MP_TAC SUM_IMAGE_NONZERO THEN ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 14576 SIMP_TAC std_ss [PAIR_EQ] THEN 14577 METIS_TAC[TAGGED_DIVISION_SPLIT_LEFT_INJ, REAL_MUL_LZERO, 14578 TAGGED_DIVISION_SPLIT_RIGHT_INJ])); 14579 14580val EQUIINTEGRABLE_DIVISION = store_thm ("EQUIINTEGRABLE_DIVISION", 14581 ``!fs:(real->real)->bool d a b. 14582 d division_of interval[a,b] 14583 ==> (fs equiintegrable_on interval[a,b] <=> 14584 !i. i IN d ==> fs equiintegrable_on i)``, 14585 REPEAT STRIP_TAC THEN CONV_TAC SYM_CONV THEN 14586 MATCH_MP_TAC OPERATIVE_DIVISION_AND THEN 14587 ASM_REWRITE_TAC[operative, NEUTRAL_AND] THEN 14588 POP_ASSUM_LIST(K ALL_TAC) THEN CONJ_TAC THENL 14589 [MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN DISCH_TAC THEN 14590 ASM_SIMP_TAC std_ss [equiintegrable_on, INTEGRABLE_ON_NULL] THEN 14591 GEN_TAC THEN DISCH_TAC THEN EXISTS_TAC ``\x:real. ball(x,&1)`` THEN 14592 ASM_SIMP_TAC std_ss [GAUGE_TRIVIAL, INTEGRAL_NULL, REAL_SUB_RZERO] THEN 14593 REPEAT STRIP_TAC THEN 14594 FIRST_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 14595 ``&0 < e ==> (x = 0) ==> abs x < e:real``)) THEN 14596 MATCH_MP_TAC SUM_EQ_0 THEN SIMP_TAC std_ss [FORALL_PROD] THEN 14597 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_ENTIRE] THEN DISJ1_TAC THEN 14598 RULE_ASSUM_TAC(REWRITE_RULE[TAGGED_DIVISION_OF]) THEN 14599 ASM_MESON_TAC[CONTENT_EQ_0_INTERIOR, SUBSET_INTERIOR, 14600 SET_RULE ``(s = {}) <=> s SUBSET {}``], 14601 ALL_TAC] THEN 14602 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``, ``c:real``] THEN 14603 EQ_TAC THENL [ALL_TAC, METIS_TAC[EQUIINTEGRABLE_ON_SPLIT]] THEN 14604 ASM_SIMP_TAC std_ss [INTEGRABLE_SPLIT, equiintegrable_on] THEN 14605 STRIP_TAC THEN CONJ_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 14606 (FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 14607 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 14608 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 14609 ASM_CASES_TAC ``gauge(d:real->real->bool)`` THEN ASM_REWRITE_TAC[] THEN 14610 DISCH_TAC THEN X_GEN_TAC ``f:real->real`` THEN 14611 POP_ASSUM (MP_TAC o SPEC ``f:real->real``) THEN 14612 ASM_CASES_TAC ``(f:real->real) IN fs`` THEN ASM_REWRITE_TAC[] THEN 14613 DISCH_TAC THEN 14614 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, 14615 ``d:real->real->bool``, ``e / &2:real``] 14616 HENSTOCK_LEMMA_PART1) THEN ASM_SIMP_TAC std_ss [REAL_HALF] THEN 14617 DISCH_TAC THEN X_GEN_TAC ``p:real#(real->bool)->bool`` THEN 14618 POP_ASSUM (MP_TAC o SPEC ``p:real#(real->bool)->bool``) THEN 14619 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 14620 KNOW_TAC ``p tagged_partial_division_of interval [(a,b)] /\ d FINE p`` THENL 14621 [ASM_REWRITE_TAC[] THEN MATCH_MP_TAC TAGGED_PARTIAL_DIVISION_OF_SUBSET THEN 14622 RULE_ASSUM_TAC(REWRITE_RULE[tagged_division_of]) THEN 14623 ASM_MESON_TAC[INTER_SUBSET], 14624 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 14625 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 14626 MATCH_MP_TAC(REAL_ARITH 14627 ``&0 < e / 2 /\ (x:real = y) ==> abs(x) <= e / &2 ==> abs(y) < e / 2 + e / 2``) THEN 14628 ASM_REWRITE_TAC[REAL_HALF] THEN ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 14629 W(MP_TAC o PART_MATCH (lhand o rand) 14630 INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN o rand o rand o snd) THEN 14631 ASM_SIMP_TAC std_ss [GSYM INTERVAL_SPLIT, INTEGRABLE_SPLIT] THEN 14632 DISCH_THEN SUBST1_TAC THEN 14633 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 14634 ASM_SIMP_TAC std_ss [GSYM SUM_SUB] THEN MATCH_MP_TAC SUM_EQ THEN 14635 SIMP_TAC std_ss [FORALL_PROD])); 14636 14637(* ------------------------------------------------------------------------- *) 14638(* Main limit theorem for an equiintegrable sequence. *) 14639(* ------------------------------------------------------------------------- *) 14640 14641val EQUIINTEGRABLE_LIMIT = store_thm ("EQUIINTEGRABLE_LIMIT", 14642 ``!f g:real->real a b. 14643 {f n | n IN univ(:num)} equiintegrable_on interval[a,b] /\ 14644 (!x. x IN interval[a,b] ==> ((\n. f n x) --> g x) sequentially) 14645 ==> g integrable_on interval[a,b] /\ 14646 ((\n. integral(interval[a,b]) (f n)) --> integral(interval[a,b]) g) 14647 sequentially``, 14648 REPEAT GEN_TAC THEN STRIP_TAC THEN 14649 ASM_CASES_TAC ``content(interval[a:real,b]) = &0`` THEN 14650 ASM_SIMP_TAC std_ss [INTEGRABLE_ON_NULL, INTEGRAL_NULL, LIM_CONST] THEN 14651 SUBGOAL_THEN ``cauchy (\n. integral(interval[a,b]) (f n :real->real))`` 14652 MP_TAC THENL 14653 [REWRITE_TAC[cauchy] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 14654 UNDISCH_TAC ``{f n | n IN univ(:num)} equiintegrable_on interval [(a,b)]`` THEN 14655 DISCH_TAC THEN 14656 FIRST_ASSUM(MP_TAC o REWRITE_RULE [equiintegrable_on]) THEN 14657 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC, IN_UNIV] THEN 14658 DISCH_TAC THEN REWRITE_TAC[AND_IMP_INTRO, GSYM CONJ_ASSOC] THEN 14659 DISCH_THEN(MP_TAC o SPEC ``e / &3:real``) THEN 14660 KNOW_TAC ``0 < e / 3:real`` THENL [UNDISCH_TAC ``0 < e:real`` THEN 14661 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN REAL_ARITH_TAC, 14662 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 14663 DISCH_THEN(X_CHOOSE_THEN ``d:real->real->bool`` STRIP_ASSUME_TAC) THEN 14664 FIRST_ASSUM(MP_TAC o MATCH_MP FINE_DIVISION_EXISTS) THEN 14665 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 14666 DISCH_THEN(X_CHOOSE_THEN ``p:(real#(real->bool))->bool`` 14667 STRIP_ASSUME_TAC) THEN 14668 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 14669 FIRST_X_ASSUM(MP_TAC o GEN ``n:num`` o SPECL 14670 [``n:num``, ``p:(real#(real->bool))->bool``]) THEN 14671 ASM_REWRITE_TAC[] THEN DISCH_TAC THEN SUBGOAL_THEN 14672 ``cauchy (\n. sum p (\(x,k:real->bool). 14673 content k * (f:num->real->real) n x))`` 14674 MP_TAC THENL 14675 [MATCH_MP_TAC CONVERGENT_IMP_CAUCHY THEN 14676 EXISTS_TAC ``sum p (\(x,k:real->bool). 14677 content k * (g:real->real) x)`` THEN 14678 MATCH_MP_TAC 14679 (SIMP_RULE std_ss [LAMBDA_PROD] 14680 (SIMP_RULE std_ss [FORALL_PROD] 14681 (ISPECL [``sequentially``, ``\(x:real,k:real->bool) (n:num). 14682 content k * (f n x:real)``] LIM_SUM))) THEN 14683 ASM_SIMP_TAC std_ss [] THEN 14684 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 14685 ONCE_REWRITE_TAC [METIS [] ``(\n. content k * f n x) = 14686 (\n. content k * (\n. f n x) n)``] THEN 14687 MATCH_MP_TAC LIM_CMUL THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 14688 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 14689 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 14690 ASM_SIMP_TAC std_ss [SUBSET_DEF] THEN ASM_MESON_TAC[], 14691 REWRITE_TAC[cauchy] THEN DISCH_THEN(MP_TAC o SPEC ``e / &3:real``) THEN 14692 KNOW_TAC ``0 < e / 3:real`` THENL [UNDISCH_TAC ``0 < e:real`` THEN 14693 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN REAL_ARITH_TAC, 14694 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 14695 SIMP_TAC std_ss [AND_IMP_INTRO, RIGHT_IMP_FORALL_THM, GE] THEN 14696 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 14697 X_GEN_TAC ``m:num`` THEN X_GEN_TAC ``n:num`` THEN 14698 POP_ASSUM (MP_TAC o SPECL [``m:num``,``n:num``]) THEN 14699 ASM_CASES_TAC ``N:num <= m /\ N <= n`` THEN ASM_REWRITE_TAC[dist] THEN 14700 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 14701 MATCH_MP_TAC(REAL_ARITH 14702 ``abs(sm - gm:real) * 3 < e /\ abs(sn - gn) * 3 < e 14703 ==> abs (sm - sn) * 3 < e ==> abs(gm - gn) < e:real``) THEN 14704 ASM_SIMP_TAC real_ss [GSYM REAL_LT_RDIV_EQ]], 14705 14706 REWRITE_TAC[GSYM CONVERGENT_EQ_CAUCHY] THEN 14707 DISCH_THEN(X_CHOOSE_TAC ``l:real``) THEN 14708 SUBGOAL_THEN ``((g:real->real) has_integral l) (interval[a,b])`` 14709 (fn th => METIS_TAC[th, integrable_on, INTEGRAL_UNIQUE]) THEN 14710 REWRITE_TAC[has_integral] THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 14711 UNDISCH_TAC ``{f n | n IN univ(:num)} equiintegrable_on interval [(a,b)]`` THEN 14712 DISCH_TAC THEN 14713 FIRST_ASSUM(MP_TAC o REWRITE_RULE [equiintegrable_on]) THEN 14714 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC, IN_UNIV] THEN 14715 DISCH_TAC THEN SIMP_TAC std_ss [AND_IMP_INTRO, GSYM CONJ_ASSOC] THEN 14716 DISCH_THEN(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 14717 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 14718 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 14719 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 14720 X_GEN_TAC ``p:(real#(real->bool))->bool`` THEN STRIP_TAC THEN 14721 GEN_REWR_TAC (RAND_CONV) [GSYM REAL_HALF] THEN 14722 MATCH_MP_TAC(REAL_ARITH 14723 ``&0 < e / 2 /\ x <= e / &2 ==> x < e / 2 + e / 2:real``) THEN 14724 ASM_REWRITE_TAC[REAL_HALF] THEN 14725 MATCH_MP_TAC(ISPEC ``sequentially`` LIM_ABS_UBOUND) THEN 14726 EXISTS_TAC ``\n:num. sum p (\(x,k:real->bool). content k * f n x) - 14727 integral (interval [a,b]) (f n :real->real)`` THEN 14728 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_SEQUENTIALLY, REAL_LT_IMP_LE] THEN 14729 REWRITE_TAC[EVENTUALLY_TRUE] THEN 14730 ONCE_REWRITE_TAC [METIS [] 14731 ``(\n. sum p (\(x,k). content k * f n x) - 14732 integral (interval [(a,b)]) (f n)) = 14733 (\n. (\n. sum p (\(x,k). content k * f n x)) n - 14734 (\n. integral (interval [(a,b)]) (f n)) n)``] THEN 14735 MATCH_MP_TAC LIM_SUB THEN ASM_SIMP_TAC std_ss [] THEN 14736 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 14737 MATCH_MP_TAC 14738 (SIMP_RULE std_ss [LAMBDA_PROD] 14739 (SIMP_RULE std_ss [FORALL_PROD] 14740 (ISPECL [``sequentially``, ``\(x:real,k:real->bool) (n:num). 14741 content k * (f n x:real)``] LIM_SUM))) THEN 14742 ASM_REWRITE_TAC [] THEN 14743 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 14744 SIMP_TAC std_ss [] THEN 14745 ONCE_REWRITE_TAC[METIS [] ``(\n. content k * f n x) = 14746 (\n. content k * (\n. f n x) n)``] THEN 14747 MATCH_MP_TAC LIM_CMUL THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 14748 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 14749 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 14750 ASM_SIMP_TAC std_ss [SUBSET_DEF] THEN ASM_MESON_TAC[]]); 14751 14752(* ------------------------------------------------------------------------- *) 14753(* Combining theorems for the set of equiintegrable functions. *) 14754(* ------------------------------------------------------------------------- *) 14755 14756val EQUIINTEGRABLE_SUBSET = store_thm ("EQUIINTEGRABLE_SUBSET", 14757 ``!fs gs s. 14758 fs equiintegrable_on s /\ gs SUBSET fs ==> gs equiintegrable_on s``, 14759 REWRITE_TAC[equiintegrable_on, SUBSET_DEF] THEN METIS_TAC[]); 14760 14761val EQUIINTEGRABLE_UNION = store_thm ("EQUIINTEGRABLE_UNION", 14762 ``!fs:(real->real)->bool gs s. 14763 fs equiintegrable_on s /\ gs equiintegrable_on s 14764 ==> (fs UNION gs) equiintegrable_on s``, 14765 REPEAT GEN_TAC THEN REWRITE_TAC[equiintegrable_on, IN_UNION] THEN 14766 REWRITE_TAC[TAUT `a \/ b ==> c <=> (a ==> c) /\ (b ==> c)`] THEN 14767 SIMP_TAC std_ss [FORALL_AND_THM] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 14768 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 14769 REPEAT(FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``)) THEN ASM_REWRITE_TAC[] THEN 14770 DISCH_THEN(X_CHOOSE_THEN ``d1:real->real->bool`` STRIP_ASSUME_TAC) THEN 14771 DISCH_THEN(X_CHOOSE_THEN ``d2:real->real->bool`` STRIP_ASSUME_TAC) THEN 14772 EXISTS_TAC ``\x. (d1:real->real->bool) x INTER d2 x`` THEN 14773 ASM_SIMP_TAC std_ss [GAUGE_INTER, FINE_INTER] THEN 14774 REPEAT STRIP_TAC THEN ASM_SIMP_TAC std_ss []); 14775 14776val EQUIINTEGRABLE_EQ = store_thm ("EQUIINTEGRABLE_EQ", 14777 ``!fs gs:(real->real)->bool s. 14778 fs equiintegrable_on s /\ 14779 (!g. g IN gs ==> ?f. f IN fs /\ (!x. x IN s ==> (f x = g x))) 14780 ==> gs equiintegrable_on s``, 14781 REPEAT GEN_TAC THEN REWRITE_TAC[equiintegrable_on] THEN 14782 DISCH_THEN(CONJUNCTS_THEN2 STRIP_ASSUME_TAC ASSUME_TAC) THEN 14783 CONJ_TAC THENL 14784 [X_GEN_TAC ``g:real->real`` THEN DISCH_TAC THEN 14785 UNDISCH_TAC ``!g:real->real. g IN gs ==> ?f. f IN fs /\ !x. x IN s ==> 14786 (f x = g x)`` THEN DISCH_TAC THEN 14787 FIRST_X_ASSUM (MP_TAC o SPEC ``g:real->real``) THEN 14788 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 14789 X_GEN_TAC ``f:real->real`` THEN STRIP_TAC THEN 14790 FIRST_X_ASSUM(MP_TAC o SPEC ``f:real->real``) THEN 14791 ASM_MESON_TAC[INTEGRABLE_SPIKE, IN_DIFF, NEGLIGIBLE_EMPTY], 14792 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 14793 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 14794 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 14795 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 14796 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 14797 MAP_EVERY X_GEN_TAC 14798 [``g:real->real``, ``p:(real#(real->bool))->bool``] THEN STRIP_TAC THEN 14799 UNDISCH_TAC ``!g:real->real. g IN gs ==> ?f. f IN fs /\ !x. x IN s ==> 14800 (f x = g x)`` THEN DISCH_TAC THEN 14801 FIRST_X_ASSUM (MP_TAC o SPEC ``g:real->real``) THEN 14802 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 14803 X_GEN_TAC ``f:real->real`` THEN STRIP_TAC THEN 14804 FIRST_X_ASSUM(MP_TAC o SPECL 14805 [``f:real->real``, ``p:(real#(real->bool))->bool``]) THEN 14806 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC(MESON[] 14807 ``(x:real = y) /\ (a = b) ==> abs(x - a) < e ==> abs(y - b) < e:real``) THEN 14808 CONJ_TAC THENL 14809 [MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [FORALL_PROD] THEN 14810 RULE_ASSUM_TAC(REWRITE_RULE[TAGGED_DIVISION_OF, SUBSET_DEF]) THEN 14811 ASM_MESON_TAC[], 14812 ASM_MESON_TAC[INTEGRAL_EQ]]]); 14813 14814val EQUIINTEGRABLE_CMUL = store_thm ("EQUIINTEGRABLE_CMUL", 14815 ``!fs:(real->real)->bool s k. 14816 fs equiintegrable_on s 14817 ==> {(\x. c * f x) | abs(c) <= k /\ f IN fs} equiintegrable_on s``, 14818 REPEAT GEN_TAC THEN 14819 SIMP_TAC std_ss [equiintegrable_on, INTEGRABLE_CMUL, FORALL_IN_GSPEC] THEN 14820 STRIP_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 14821 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC] THEN 14822 ASM_SIMP_TAC std_ss [RIGHT_IMP_FORALL_THM, INTEGRAL_CMUL, AND_IMP_INTRO] THEN 14823 FIRST_X_ASSUM(MP_TAC o SPEC ``e / (abs(k) + &1:real)``) THEN 14824 ASM_SIMP_TAC std_ss [REAL_LT_RDIV_EQ, REAL_MUL_LZERO, 14825 REAL_ARITH ``&0 < abs(k) + &1:real``] THEN 14826 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 14827 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 14828 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 14829 MAP_EVERY X_GEN_TAC [``c:real``, ``f:real->real``, 14830 ``p:(real#(real->bool))->bool``] THEN 14831 STRIP_TAC THEN FIRST_X_ASSUM(MP_TAC o 14832 SPECL [``f:real->real``, ``p:(real#(real->bool))->bool``]) THEN 14833 ASM_REWRITE_TAC[] THEN 14834 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LET_TRANS) THEN 14835 MATCH_MP_TAC(REAL_ARITH ``&0 <= y /\ x <= c * y ==> x <= y * (c + &1:real)``) THEN 14836 REWRITE_TAC[ABS_POS] THEN MATCH_MP_TAC(REAL_ARITH 14837 ``!c. (x = c * y) /\ c * y <= k * y ==> x <= k * y:real``) THEN 14838 EXISTS_TAC ``abs c:real`` THEN CONJ_TAC THENL 14839 [REWRITE_TAC[GSYM ABS_MUL, GSYM SUM_LMUL, REAL_SUB_LDISTRIB] THEN 14840 SIMP_TAC std_ss [LAMBDA_PROD, REAL_MUL_ASSOC] THEN 14841 SIMP_TAC std_ss [REAL_MUL_SYM], 14842 MATCH_MP_TAC REAL_LE_RMUL_IMP THEN REWRITE_TAC[ABS_POS] THEN 14843 UNDISCH_TAC ``abs c <= k:real`` THEN REAL_ARITH_TAC]); 14844 14845val EQUIINTEGRABLE_ADD = store_thm ("EQUIINTEGRABLE_ADD", 14846 ``!fs:(real->real)->bool gs s. 14847 fs equiintegrable_on s /\ gs equiintegrable_on s 14848 ==> {(\x. f x + g x) | f IN fs /\ g IN gs} equiintegrable_on s``, 14849 REPEAT GEN_TAC THEN 14850 SIMP_TAC std_ss [equiintegrable_on, INTEGRABLE_ADD, FORALL_IN_GSPEC] THEN 14851 DISCH_THEN(CONJUNCTS_THEN2 14852 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC) 14853 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 14854 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 14855 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC] THEN 14856 ASM_SIMP_TAC std_ss [RIGHT_IMP_FORALL_THM, INTEGRAL_ADD, AND_IMP_INTRO] THEN 14857 FIRST_X_ASSUM (MP_TAC o SPEC ``e / &2:real``) THEN 14858 FIRST_X_ASSUM (MP_TAC o SPEC ``e / &2:real``) THEN 14859 ASM_REWRITE_TAC[REAL_HALF] THEN 14860 DISCH_THEN(X_CHOOSE_THEN ``d1:real->real->bool`` 14861 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 14862 DISCH_THEN(X_CHOOSE_THEN ``d2:real->real->bool`` 14863 (CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC)) THEN 14864 EXISTS_TAC ``\x. (d1:real->real->bool) x INTER d2 x`` THEN 14865 ASM_SIMP_TAC std_ss [GAUGE_INTER, FINE_INTER] THEN 14866 MAP_EVERY X_GEN_TAC [``f:real->real``, ``g:real->real``, 14867 ``p:(real#(real->bool))->bool``] THEN STRIP_TAC THEN 14868 FIRST_X_ASSUM (MP_TAC o SPECL 14869 [``g:real->real``, ``p:(real#(real->bool))->bool``]) THEN 14870 FIRST_X_ASSUM (MP_TAC o SPECL 14871 [``f:real->real``, ``p:(real#(real->bool))->bool``]) THEN 14872 ASM_REWRITE_TAC[] THEN 14873 GEN_REWR_TAC (RAND_CONV o RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 14874 MATCH_MP_TAC(REAL_ARITH 14875 ``(s + s' = t) 14876 ==> abs(s - i) < e / &2 ==> abs(s' - i') < e / &2 14877 ==> abs(t - (i + i')) < e / 2 + e / 2:real``) THEN 14878 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 14879 ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN 14880 SIMP_TAC std_ss [LAMBDA_PROD, REAL_ADD_LDISTRIB]); 14881 14882val EQUIINTEGRABLE_NEG = store_thm ("EQUIINTEGRABLE_NEG", 14883 ``!fs:(real->real)->bool s. 14884 fs equiintegrable_on s 14885 ==> {(\x. -(f x)) | f IN fs} equiintegrable_on s``, 14886 REPEAT STRIP_TAC THEN 14887 FIRST_ASSUM(MP_TAC o SPEC ``&1:real`` o MATCH_MP EQUIINTEGRABLE_CMUL) THEN 14888 MATCH_MP_TAC (REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 14889 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC] THEN 14890 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 14891 X_GEN_TAC ``f:real->real`` THEN DISCH_TAC THEN EXISTS_TAC ``- &1:real`` THEN 14892 EXISTS_TAC ``f:real->real`` THEN 14893 ASM_REWRITE_TAC[REAL_MUL_LNEG, REAL_MUL_LID] THEN REAL_ARITH_TAC); 14894 14895val EQUIINTEGRABLE_SUB = store_thm ("EQUIINTEGRABLE_SUB", 14896 ``!fs:(real->real)->bool gs s. 14897 fs equiintegrable_on s /\ gs equiintegrable_on s 14898 ==> {(\x. f x - g x) | f IN fs /\ g IN gs} equiintegrable_on s``, 14899 REPEAT GEN_TAC THEN DISCH_THEN(CONJUNCTS_THEN2 14900 MP_TAC (MP_TAC o MATCH_MP EQUIINTEGRABLE_NEG)) THEN 14901 REWRITE_TAC[GSYM IMP_CONJ_ALT] THEN 14902 DISCH_THEN(MP_TAC o MATCH_MP EQUIINTEGRABLE_ADD) THEN 14903 MATCH_MP_TAC (REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 14904 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC] THEN 14905 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 14906 MAP_EVERY X_GEN_TAC [``f:real->real``, ``g:real->real``] THEN 14907 STRIP_TAC THEN EXISTS_TAC ``f:real->real`` THEN 14908 EXISTS_TAC ``\x. -((g:real->real) x)`` THEN 14909 ASM_SIMP_TAC std_ss [real_sub] THEN EXISTS_TAC ``g:real->real`` THEN 14910 ASM_REWRITE_TAC[]); 14911 14912val EQUIINTEGRABLE_SUM = store_thm ("EQUIINTEGRABLE_SUM", 14913 ``!fs:(real->real)->bool a b. 14914 fs equiintegrable_on interval[a,b] 14915 ==> {(\x. sum t (\i. c i * f i x)) | 14916 FINITE t /\ 14917 (!i:'a. i IN t ==> &0 <= c i /\ (f i) IN fs) /\ 14918 (sum t c = &1)} 14919 equiintegrable_on interval[a,b]``, 14920 REPEAT GEN_TAC THEN REWRITE_TAC[equiintegrable_on] THEN 14921 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC] THEN 14922 SIMP_TAC std_ss [AND_IMP_INTRO, GSYM CONJ_ASSOC, RIGHT_IMP_FORALL_THM] THEN 14923 STRIP_TAC THEN CONJ_TAC THENL 14924 [REPEAT STRIP_TAC THEN 14925 ONCE_REWRITE_TAC [METIS [] 14926 ``(\x. sum t (\i. c i * f i x)) = (\x. sum t (\i. (\i x. c i * f i x) i x))``] THEN 14927 MATCH_MP_TAC INTEGRABLE_SUM THEN ASM_SIMP_TAC std_ss [] THEN GEN_TAC THEN 14928 STRIP_TAC THEN MATCH_MP_TAC INTEGRABLE_CMUL THEN FIRST_ASSUM MATCH_MP_TAC THEN 14929 METIS_TAC [], ALL_TAC] THEN ASM_SIMP_TAC std_ss [INTEGRAL_SUM] THEN 14930 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 14931 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 14932 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 14933 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 14934 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN MAP_EVERY X_GEN_TAC 14935 [``t:'a->bool``, ``c:'a->real``, ``f:'a->real->real``, 14936 ``p:(real#(real->bool))->bool``] THEN 14937 STRIP_TAC THEN 14938 SUBGOAL_THEN 14939 ``!i:'a. i IN t 14940 ==> (integral (interval[a,b]) (\x:real. c i * f i x:real) = 14941 sum p (\(x:real,k). 14942 integral (k:real->bool) (\x:real. c i * f i x)))`` 14943 (fn th => SIMP_TAC std_ss [th]) 14944 THENL 14945 [REPEAT STRIP_TAC THEN 14946 MATCH_MP_TAC INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN THEN 14947 METIS_TAC [INTEGRABLE_CMUL, ETA_AX], 14948 ALL_TAC] THEN 14949 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 14950 SUBGOAL_THEN 14951 ``sum p (\(x,k:real->bool). content k * sum t (\i. c i * f i x)) = 14952 sum t (\i. c i * 14953 sum p (\(x,k). content k * (f:'a->real->real) i x))`` 14954 SUBST1_TAC THENL 14955 [SIMP_TAC std_ss [GSYM SUM_LMUL] THEN 14956 ONCE_REWRITE_TAC [METIS [] 14957 ``(\i. sum p (\x. c i * (\(x,k). content k * f i x) x)) = 14958 (\i. sum p ((\i. (\x. c i * (\(x,k). content k * f i x) x)) i))``] THEN 14959 W(MP_TAC o PART_MATCH (lhs o rand) SUM_SWAP o 14960 rand o snd) THEN 14961 ASM_REWRITE_TAC[] THEN DISCH_THEN SUBST1_TAC THEN 14962 MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [FORALL_PROD, REAL_MUL_ASSOC] THEN 14963 REPEAT STRIP_TAC THEN GEN_REWR_TAC (RAND_CONV o ONCE_DEPTH_CONV) 14964 [REAL_ARITH ``a * b * c = b * a * c:real``] THEN SIMP_TAC std_ss [], 14965 ALL_TAC] THEN 14966 MATCH_MP_TAC REAL_LET_TRANS THEN 14967 EXISTS_TAC ``sum t (\i:'a. c i * e / &2)`` THEN CONJ_TAC THENL 14968 [ALL_TAC, 14969 ASM_SIMP_TAC real_ss [real_div, SUM_RMUL, ETA_AX, REAL_MUL_LID] THEN 14970 REWRITE_TAC [GSYM real_div] THEN SIMP_TAC real_ss [REAL_LT_LDIV_EQ] THEN 14971 UNDISCH_TAC ``0 < e:real`` THEN REAL_ARITH_TAC] THEN 14972 KNOW_TAC ``integral (interval [(a,b)]) (\x. sum t (\i. c i * f i x)) = 14973 integral (interval [(a,b)]) (\x. sum t (\i. (\i x. c i * f i x) i x))`` THENL 14974 [SIMP_TAC std_ss [], DISCH_THEN (fn th => REWRITE_TAC [th])] THEN 14975 KNOW_TAC ``integral (interval [(a,b)]) (\x. sum t (\i. (\i x. c i * f i x) i x)) = 14976 sum t (\i. integral (interval [(a,b)]) ((\i x. c i * f i x) i))`` THENL 14977 [MATCH_MP_TAC INTEGRAL_SUM THEN ASM_SIMP_TAC std_ss [] THEN 14978 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRABLE_CMUL THEN METIS_TAC [], 14979 SIMP_TAC std_ss [] THEN DISCH_THEN (fn th => SIMP_TAC std_ss [th])] THEN 14980 ASM_SIMP_TAC std_ss [GSYM SUM_SUB] THEN MATCH_MP_TAC SUM_ABS_LE THEN 14981 ASM_REWRITE_TAC[] THEN X_GEN_TAC ``i:'a`` THEN DISCH_TAC THEN 14982 ASM_SIMP_TAC std_ss [GSYM SUM_LMUL, GSYM SUM_SUB] THEN 14983 SIMP_TAC std_ss [LAMBDA_PROD] THEN FIRST_X_ASSUM(MP_TAC o SPECL 14984 [``(f:'a->real->real) i``, ``p:(real#(real->bool))->bool``]) THEN 14985 ASM_SIMP_TAC std_ss [] THEN DISCH_THEN(MP_TAC o MATCH_MP REAL_LT_IMP_LE) THEN 14986 DISCH_THEN(MP_TAC o SPEC ``abs((c:'a->real) i)`` o 14987 MATCH_MP(SIMP_RULE std_ss [IMP_CONJ_ALT] REAL_LE_LMUL_IMP)) THEN 14988 ASM_REWRITE_TAC[ABS_POS, GSYM ABS_MUL] THEN 14989 ASM_SIMP_TAC std_ss [GSYM SUM_LMUL, REAL_SUB_LDISTRIB] THEN 14990 KNOW_TAC `` abs ((c:'a->real) i) = c i`` THENL 14991 [ASM_SIMP_TAC std_ss [abs], DISCH_THEN (fn th => REWRITE_TAC [th])] THEN 14992 SIMP_TAC std_ss [LAMBDA_PROD] THEN 14993 REWRITE_TAC [REAL_MUL_ASSOC, real_div] THEN 14994 MATCH_MP_TAC(REAL_ARITH ``(x = y) ==> x <= a ==> y <= a:real``) THEN 14995 AP_TERM_TAC THEN 14996 KNOW_TAC 14997 ``integral (interval [(a,b)]) (\(x :real). c i * (f :'a -> real -> real) i x) = 14998 (c:'a->real) i * integral (interval [(a,b)]) (f i)`` THENL 14999 [MATCH_MP_TAC INTEGRAL_CMUL THEN METIS_TAC [], 15000 DISCH_THEN (fn th => REWRITE_TAC [th])]); 15001 15002val EQUIINTEGRABLE_UNIFORM_LIMIT = store_thm ("EQUIINTEGRABLE_UNIFORM_LIMIT", 15003 ``!fs:(real->real)->bool a b. 15004 fs equiintegrable_on interval[a,b] 15005 ==> {g | !e. &0 < e 15006 ==> ?f. f IN fs /\ 15007 !x. x IN interval[a,b] ==> abs(g x - f x) < e} 15008 equiintegrable_on interval[a,b]``, 15009 REPEAT STRIP_TAC THEN 15010 FIRST_ASSUM(MP_TAC o REWRITE_RULE [equiintegrable_on]) THEN 15011 SIMP_TAC std_ss [equiintegrable_on, GSPECIFICATION] THEN REPEAT GEN_TAC THEN 15012 STRIP_TAC THEN CONJ_TAC THENL 15013 [ASM_MESON_TAC[INTEGRABLE_UNIFORM_LIMIT, REAL_LT_IMP_LE], ALL_TAC] THEN 15014 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 15015 FIRST_X_ASSUM(MP_TAC o SPEC ``e / &2:real``) THEN ASM_REWRITE_TAC[REAL_HALF] THEN 15016 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 15017 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 15018 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN MAP_EVERY X_GEN_TAC 15019 [``g:real->real``,``p:(real#(real->bool))->bool``] THEN 15020 STRIP_TAC THEN 15021 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 15022 SUBGOAL_THEN ``(g:real->real) integrable_on interval[a,b]`` 15023 ASSUME_TAC THENL 15024 [ASM_MESON_TAC[INTEGRABLE_UNIFORM_LIMIT, REAL_LT_IMP_LE], ALL_TAC] THEN 15025 FIRST_X_ASSUM(MP_TAC o GEN ``n:num`` o SPEC ``inv(&n + &1:real)``) THEN 15026 SIMP_TAC std_ss [REAL_LT_INV_EQ, 15027 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 15028 SIMP_TAC std_ss [SKOLEM_THM, FORALL_AND_THM, LEFT_IMP_EXISTS_THM] THEN 15029 X_GEN_TAC ``f:num->real->real`` THEN STRIP_TAC THEN 15030 SUBGOAL_THEN 15031 ``!x. x IN interval[a,b] 15032 ==> ((\n. f n x) --> (g:real->real) x) sequentially`` 15033 ASSUME_TAC THENL 15034 [X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 15035 REWRITE_TAC[LIM_SEQUENTIALLY] THEN X_GEN_TAC ``k:real`` THEN DISCH_TAC THEN 15036 MP_TAC(SPEC ``k:real`` REAL_ARCH_INV) THEN ASM_REWRITE_TAC[] THEN 15037 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 15038 POP_ASSUM MP_TAC THEN STRIP_TAC THEN 15039 X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN REWRITE_TAC [dist] THEN 15040 ONCE_REWRITE_TAC[REAL_ARITH ``abs(a:real - b) = abs(b - a)``] THEN 15041 MATCH_MP_TAC REAL_LT_TRANS THEN EXISTS_TAC ``inv(&n + &1:real)`` THEN 15042 ASM_SIMP_TAC std_ss [] THEN 15043 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC ``inv(&N:real)`` THEN 15044 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC REAL_LE_INV2 THEN 15045 REWRITE_TAC[REAL_OF_NUM_ADD, REAL_OF_NUM_LE, REAL_LT] THEN 15046 ASM_SIMP_TAC arith_ss [], 15047 ALL_TAC] THEN 15048 MP_TAC(ISPECL [``f:num->real->real``, ``g:real->real``, 15049 ``a:real``, ``b:real``] EQUIINTEGRABLE_LIMIT) THEN 15050 KNOW_TAC ``{f n | n IN univ(:num)} equiintegrable_on interval [(a,b)] /\ 15051 (!x. x IN interval [(a,b)] ==> ((\n. f n x) --> g x) sequentially)`` THENL 15052 [ASM_REWRITE_TAC[] THEN MATCH_MP_TAC EQUIINTEGRABLE_SUBSET THEN 15053 EXISTS_TAC ``fs:(real->real)->bool`` THEN ASM_SET_TAC[], 15054 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 15055 DISCH_TAC] THEN 15056 SUBGOAL_THEN 15057 ``((\n. sum p (\(x,k:real->bool). 15058 content k * (f:num->real->real) n x)) --> 15059 sum p (\(x,k). content k * g x)) sequentially`` 15060 ASSUME_TAC 15061 THENL 15062 [MATCH_MP_TAC 15063 (SIMP_RULE std_ss [LAMBDA_PROD] 15064 (SIMP_RULE std_ss [FORALL_PROD] 15065 (ISPECL [``sequentially``, ``\(x:real,k:real->bool) (n:num). 15066 content k * (f n x:real)``] LIM_SUM))) THEN 15067 ASM_REWRITE_TAC[] THEN 15068 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 15069 SIMP_TAC std_ss [] THEN 15070 ONCE_REWRITE_TAC [METIS [] ``(\n. content k * f n x) = 15071 (\n. content k * (\n. f n x) n)``] THEN 15072 MATCH_MP_TAC LIM_CMUL THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 15073 UNDISCH_TAC ``p tagged_division_of interval [(a,b)]`` THEN DISCH_TAC THEN 15074 FIRST_X_ASSUM(MP_TAC o SIMP_RULE std_ss [TAGGED_DIVISION_OF]) THEN 15075 ASM_SIMP_TAC std_ss [SUBSET_DEF] THEN ASM_MESON_TAC[], 15076 ALL_TAC] THEN 15077 FIRST_X_ASSUM (MP_TAC o REWRITE_RULE[LIM_SEQUENTIALLY]) THEN 15078 DISCH_THEN(MP_TAC o SPEC ``e / &4:real``) THEN 15079 KNOW_TAC ``0 < e / 4:real`` THENL 15080 [UNDISCH_TAC ``0 < e:real`` THEN SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 15081 REAL_ARITH_TAC, DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 15082 DISCH_THEN(X_CHOOSE_THEN ``N1:num`` ASSUME_TAC) THEN 15083 UNDISCH_TAC ``((\n. integral (interval [(a,b)]) (f n)) --> 15084 integral (interval [(a,b)]) g) sequentially`` THEN DISCH_TAC THEN 15085 FIRST_X_ASSUM (MP_TAC o REWRITE_RULE[LIM_SEQUENTIALLY]) THEN 15086 DISCH_THEN(MP_TAC o SPEC ``e / &4:real``) THEN 15087 KNOW_TAC ``0 < e / 4:real`` THENL 15088 [UNDISCH_TAC ``0 < e:real`` THEN SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 15089 REAL_ARITH_TAC, DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 15090 DISCH_THEN(X_CHOOSE_THEN ``N2:num`` ASSUME_TAC) THEN 15091 SUBGOAL_THEN ``?n:num. N1 <= n /\ N2 <= n`` STRIP_ASSUME_TAC THENL 15092 [EXISTS_TAC ``N1 + N2:num`` THEN ARITH_TAC, ALL_TAC] THEN 15093 FIRST_X_ASSUM (MP_TAC o SPEC ``n:num``) THEN 15094 FIRST_X_ASSUM (MP_TAC o SPEC ``n:num``) THEN 15095 FIRST_X_ASSUM(MP_TAC o SPECL 15096 [``(f:num->real->real) n``, ``p:(real#(real->bool))->bool``]) THEN 15097 ASM_SIMP_TAC real_ss [dist, REAL_LT_RDIV_EQ] THEN REAL_ARITH_TAC); 15098 15099val lemma = prove ( 15100 ``(!x k. (x,k) IN IMAGE (\(x,k). f x k,g x k) s ==> Q x k) <=> 15101 (!x k. (x,k) IN s ==> Q (f x k) (g x k))``, 15102 SIMP_TAC std_ss [IN_IMAGE, PAIR_EQ, EXISTS_PROD] THEN SET_TAC[]); 15103 15104Theorem EQUIINTEGRABLE_REFLECT : 15105 !(fs :(real->real)->bool) a b. 15106 fs equiintegrable_on interval[a,b] 15107 ==> {(\x. f(-x)) | f IN fs} equiintegrable_on interval[-b,-a] 15108Proof 15109 REPEAT GEN_TAC THEN REWRITE_TAC[equiintegrable_on] THEN 15110 SIMP_TAC std_ss [RIGHT_FORALL_IMP_THM, IMP_CONJ, FORALL_IN_GSPEC] THEN 15111 DISCH_TAC THEN DISCH_TAC THEN 15112 ASM_SIMP_TAC std_ss [INTEGRABLE_REFLECT, INTEGRAL_REFLECT] THEN 15113 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 15114 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 15115 POP_ASSUM MP_TAC THEN POP_ASSUM K_TAC THEN DISCH_TAC THEN 15116 DISCH_THEN(X_CHOOSE_THEN ``d:real->real->bool`` STRIP_ASSUME_TAC) THEN 15117 EXISTS_TAC ``\x. IMAGE (\x. -x) ((d:real->real->bool) (-x))`` THEN 15118 CONJ_TAC THENL 15119 [UNDISCH_TAC ``gauge d`` THEN DISCH_TAC THEN 15120 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [gauge_def]) THEN 15121 SIMP_TAC std_ss [gauge_def, OPEN_NEGATIONS] THEN DISCH_TAC THEN 15122 GEN_TAC THEN GEN_REWR_TAC LAND_CONV [GSYM REAL_NEG_NEG] THEN 15123 ASM_SIMP_TAC std_ss [FUN_IN_IMAGE], 15124 ALL_TAC] THEN 15125 X_GEN_TAC ``f:real->real`` THEN DISCH_TAC THEN 15126 X_GEN_TAC ``p:real#(real->bool)->bool`` THEN REPEAT DISCH_TAC THEN 15127 FIRST_X_ASSUM(MP_TAC o SPEC ``f:real->real``) THEN ASM_REWRITE_TAC[] THEN 15128 DISCH_THEN(MP_TAC o SPEC 15129 ``IMAGE (\(x,k). (-x:real,IMAGE (\x. -x) (k:real->bool))) p``) THEN 15130 KNOW_TAC ``IMAGE (\(x,k). (-x,IMAGE (\x. -x) k)) p tagged_division_of 15131 interval [(a,b)]`` THENL 15132 [ (* goal 1 (of 2) *) 15133 UNDISCH_TAC ``p tagged_division_of interval [(-b,-a)]`` THEN DISCH_TAC THEN 15134 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [TAGGED_DIVISION_OF]) THEN 15135 REWRITE_TAC[TAGGED_DIVISION_OF] THEN 15136 STRIP_TAC THEN ASM_SIMP_TAC std_ss [IMAGE_FINITE] THEN 15137 SIMP_TAC std_ss [RIGHT_FORALL_IMP_THM, IMP_CONJ, lemma] THEN 15138 REPEAT CONJ_TAC THENL (* 3 subgoals *) 15139 [ (* goal 1.1 (of 3) *) 15140 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 15141 ASM_SIMP_TAC std_ss [FUN_IN_IMAGE] THEN CONJ_TAC THENL 15142 [SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_IMAGE] THEN 15143 ONCE_REWRITE_TAC[GSYM IN_INTERVAL_REFLECT] THEN 15144 ASM_SIMP_TAC std_ss [REAL_NEG_NEG, GSYM SUBSET_DEF] THEN ASM_MESON_TAC[], 15145 SIMP_TAC std_ss [EXTENSION, IN_IMAGE] THEN 15146 REWRITE_TAC[REAL_ARITH ``(x:real = -y) <=> (-x = y)``] THEN 15147 ONCE_REWRITE_TAC[GSYM IN_INTERVAL_REFLECT] THEN 15148 SIMP_TAC std_ss [UNWIND_THM1] THEN 15149 SUBGOAL_THEN ``?u v:real. k = interval[u,v]`` 15150 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 15151 THENL [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 15152 ASM_MESON_TAC[REAL_NEG_NEG]], 15153 (* goal 1.2 (of 3) *) 15154 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 15155 MAP_EVERY X_GEN_TAC [``y:real``, ``l:real->bool``] THEN DISCH_TAC THEN 15156 FIRST_X_ASSUM(MP_TAC o SPECL 15157 [``x:real``, ``k:real->bool``, 15158 ``y:real``, ``l:real->bool``]) THEN 15159 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC MONO_IMP THEN 15160 CONJ_TAC THENL [MESON_TAC[PAIR_EQ], ALL_TAC] THEN 15161 SIMP_TAC std_ss [INTERIOR_NEGATIONS] THEN 15162 MATCH_MP_TAC(SET_RULE 15163 ``(!x. f(f x) = x) 15164 ==> (s INTER t = {}) ==> (IMAGE f s INTER IMAGE f t = {})``) THEN 15165 SIMP_TAC std_ss [REAL_NEG_NEG], 15166 (* goal 1.3 (of 3) *) 15167 GEN_REWR_TAC I [EXTENSION] THEN 15168 ONCE_REWRITE_TAC[GSYM IN_INTERVAL_REFLECT] THEN 15169 FIRST_X_ASSUM(SUBST1_TAC o SYM) THEN X_GEN_TAC ``y:real`` THEN 15170 SIMP_TAC std_ss [IN_BIGUNION, GSPECIFICATION] THEN 15171 KNOW_TAC ``(? (s :real -> bool). ( \s. 15172 (y :real) IN s /\ ?(x :real). (x,s) IN 15173 IMAGE ( \ ((x :real),(k :real -> bool)). (-x,IMAGE (\ (x :real). -x) k)) 15174 (p :real # (real -> bool) -> bool)) s) <=> 15175 ? (s :real -> bool). ( \s. -y IN s /\ ? (x :real). (x,s) IN p) s`` THENL 15176 [ALL_TAC, METIS_TAC []] THEN 15177 MATCH_MP_TAC(MESON[] 15178 ``!f. (!x. f(f x) = x) /\ (!x. P x <=> Q(f x)) 15179 ==> ((?x. P x) <=> (?x. Q x))``) THEN SIMP_TAC std_ss [] THEN 15180 EXISTS_TAC ``IMAGE ((\x. -x):real->real)`` THEN CONJ_TAC THENL 15181 [SIMP_TAC std_ss [GSYM IMAGE_COMPOSE, o_DEF, REAL_NEG_NEG, IMAGE_ID], 15182 ALL_TAC] THEN 15183 X_GEN_TAC ``t:real->bool`` THEN BINOP_TAC THENL 15184 [ SIMP_TAC std_ss [IN_IMAGE, EXISTS_PROD, PAIR_EQ] THEN 15185 SUBGOAL_THEN ``!k:real->bool. IMAGE (\x. -x) (IMAGE (\x. -x) k) = k`` 15186 MP_TAC THENL 15187 [SIMP_TAC std_ss [GSYM IMAGE_COMPOSE, o_DEF, REAL_NEG_NEG, IMAGE_ID], 15188 METIS_TAC[REAL_EQ_NEG]], 15189 SIMP_TAC std_ss [IN_IMAGE, EXISTS_PROD] THEN EQ_TAC THENL 15190 [STRIP_TAC THEN 15191 ASM_SIMP_TAC std_ss [IMAGE_IMAGE, o_DEF, IMAGE_ID, REAL_NEG_NEG] THEN 15192 METIS_TAC [], 15193 DISCH_THEN (X_CHOOSE_TAC ``x:real``) THEN 15194 EXISTS_TAC ``x:real`` THEN 15195 EXISTS_TAC ``IMAGE (\x:real. -x) t`` THEN 15196 ASM_SIMP_TAC std_ss [IMAGE_IMAGE, o_DEF, IMAGE_ID, 15197 REAL_NEG_NEG] ] ] ], 15198 (* goal 2 (of 2) *) 15199 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 15200 KNOW_TAC ``(d :real -> real -> bool) FINE 15201 IMAGE (\ ((x :real),(k :real -> bool)). (-x,IMAGE (\ (x :real). -x) k)) 15202 (p :real # (real -> bool) -> bool)`` THENL 15203 [FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [FINE]) THEN 15204 SIMP_TAC std_ss [FINE, lemma] THEN 15205 DISCH_TAC THEN X_GEN_TAC ``x:real`` THEN X_GEN_TAC ``k:real->bool`` THEN 15206 POP_ASSUM (MP_TAC o SPECL [``x:real``, ``k:real->bool``]) THEN 15207 MATCH_MP_TAC MONO_IMP THEN REWRITE_TAC[] THEN 15208 MATCH_MP_TAC(SET_RULE 15209 ``(!x. f(f x) = x) ==> k SUBSET IMAGE f s ==> IMAGE f k SUBSET s``) THEN 15210 SIMP_TAC std_ss [REAL_NEG_NEG], 15211 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 15212 MATCH_MP_TAC(REAL_ARITH 15213 ``(x:real = y) ==> abs(x - i) < e ==> abs(y - i) < e``) THEN 15214 W(MP_TAC o PART_MATCH (lhs o rand) SUM_IMAGE o lhs o snd) THEN 15215 FIRST_ASSUM(ASSUME_TAC o MATCH_MP TAGGED_DIVISION_OF_FINITE) THEN 15216 ASM_SIMP_TAC std_ss [] THEN 15217 KNOW_TAC ``(!(x :real # (real -> bool)) (y :real # (real -> bool)). 15218 x IN (p :real # (real -> bool) -> bool) /\ y IN p /\ 15219 ((\ ((x :real),(k :real -> bool)). (-x,IMAGE (\ (x :real). -x) k)) x = 15220 (\ ((x :real),(k :real -> bool)). (-x,IMAGE (\ (x :real). -x) k)) 15221 y) ==> (x = y))`` THENL 15222 [MATCH_MP_TAC(MESON[] 15223 ``(!x. f(f x) = x) 15224 ==> !x y. x IN p /\ y IN p /\ (f x = f y) ==> (x = y)``) THEN 15225 SIMP_TAC std_ss [FORALL_PROD, GSYM IMAGE_COMPOSE, o_DEF, REAL_NEG_NEG, 15226 IMAGE_ID], 15227 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 15228 DISCH_THEN SUBST1_TAC THEN MATCH_MP_TAC SUM_EQ THEN 15229 SIMP_TAC std_ss [FORALL_PROD, o_THM] THEN 15230 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 15231 SUBGOAL_THEN ``?u v:real. k = interval[u,v]`` 15232 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 15233 THENL [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 15234 AP_THM_TAC THEN AP_TERM_TAC THEN 15235 SUBGOAL_THEN ``(\x. -x):real->real = (\x. -(&1) * x + 0)`` SUBST1_TAC 15236 THENL [REWRITE_TAC[FUN_EQ_THM] THEN REAL_ARITH_TAC, ALL_TAC] THEN 15237 SIMP_TAC std_ss [CONTENT_IMAGE_AFFINITY_INTERVAL, ABS_NEG] THEN 15238 SIMP_TAC std_ss [POW_1, REAL_MUL_LID, ABS_N]] ] 15239QED 15240 15241(* ------------------------------------------------------------------------- *) 15242(* Some technical lemmas about minimizing a "flat" part of a sum over a *) 15243(* division, followed by subinterval resictions for equiintegrable family. *) 15244(* ------------------------------------------------------------------------- *) 15245 15246val lemma0 = prove ( 15247 ``!k:real->bool. 15248 content k / (interval_upperbound k - interval_lowerbound k) = 15249 if content k = &0 then &0 15250 else &1:real``, 15251 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 15252 ASM_REWRITE_TAC[real_div, REAL_MUL_LZERO] THEN 15253 REWRITE_TAC[content] THEN 15254 COND_CASES_TAC THENL [ASM_MESON_TAC[CONTENT_EMPTY], ALL_TAC] THEN 15255 UNDISCH_TAC ``~(content(k:real->bool) = &0)`` THEN 15256 ASM_REWRITE_TAC[content, PRODUCT_EQ_0_NUMSEG] THEN 15257 ASM_MESON_TAC[REAL_MUL_RINV]); 15258 15259val lemma1 = prove ( 15260 ``!d a b:real s. 15261 d division_of s /\ s SUBSET interval[a,b] /\ 15262 ((!k. k IN d 15263 ==> ~(content k = &0) /\ ~(k INTER {x | x = a} = {})) \/ 15264 (!k. k IN d 15265 ==> ~(content k = &0) /\ ~(k INTER {x | x = b} = {}))) 15266 ==> (b - a) * 15267 sum d (\k. content k / 15268 (interval_upperbound k - interval_lowerbound k)) 15269 <= content(interval[a,b])``, 15270 REPEAT GEN_TAC THEN DISCH_THEN(REPEAT_TCL CONJUNCTS_THEN ASSUME_TAC) THEN 15271 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 15272 ABBREV_TAC ``extend = (\k:real->bool. interval [a, b:real])`` THEN 15273 SUBGOAL_THEN ``!k. k IN d ==> k SUBSET interval[a:real,b]`` 15274 ASSUME_TAC THENL 15275 [RULE_ASSUM_TAC(REWRITE_RULE[division_of]) THEN ASM_SET_TAC[], 15276 ALL_TAC] THEN 15277 SUBGOAL_THEN ``!k:real->bool. k IN d ==> ~(k = {})`` ASSUME_TAC THENL 15278 [ASM_MESON_TAC[division_of], ALL_TAC] THEN 15279 SUBGOAL_THEN 15280 ``(!k. k IN d ==> ~((extend:(real->bool)->(real->bool)) k = {})) /\ 15281 (!k. k IN d ==> (extend k) SUBSET interval[a,b])`` 15282 STRIP_ASSUME_TAC THENL 15283 [FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 15284 CONJ_TAC THEN MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN 15285 (DISCH_TAC THEN EXPAND_TAC "extend" THEN 15286 SUBGOAL_THEN ``interval[u:real,v] SUBSET interval[a,b]`` MP_TAC THENL 15287 [ASM_SIMP_TAC std_ss [], ALL_TAC] THEN 15288 SUBGOAL_THEN ``~(interval[u:real,v] = {})`` MP_TAC THENL 15289 [ASM_SIMP_TAC std_ss [], ALL_TAC] THEN 15290 SIMP_TAC std_ss [SUBSET_INTERVAL, INTERVAL_NE_EMPTY, 15291 INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 15292 METIS_TAC[REAL_LE_TRANS, REAL_LE_REFL]), 15293 ALL_TAC] THEN 15294 SUBGOAL_THEN 15295 ``!k1 k2. k1 IN d /\ k2 IN d /\ ~(k1 = k2) 15296 ==> (interior((extend:(real->bool)->(real->bool)) k1) INTER 15297 interior(extend k2) = {})`` 15298 ASSUME_TAC THENL 15299 [ (* goal 1 (of 2) *) 15300 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 15301 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 15302 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN DISCH_TAC THEN 15303 MAP_EVERY X_GEN_TAC [``w:real``, ``z:real``] THEN DISCH_TAC THEN 15304 DISCH_TAC THEN 15305 UNDISCH_TAC ``d division_of s`` THEN DISCH_TAC THEN 15306 FIRST_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 15307 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 15308 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 15309 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 15310 DISCH_THEN(MP_TAC o SPECL 15311 [``interval[u:real,v]``, ``interval[w:real,z]``]) THEN 15312 ASM_REWRITE_TAC[INTERIOR_CLOSED_INTERVAL] THEN 15313 ONCE_REWRITE_TAC[MONO_NOT_EQ] THEN 15314 REWRITE_TAC[GSYM MEMBER_NOT_EMPTY, IN_INTER] THEN 15315 EXPAND_TAC "extend" THEN 15316 SIMP_TAC std_ss [INTERIOR_CLOSED_INTERVAL, IN_INTERVAL] THEN 15317 SUBGOAL_THEN ``~(interval[u:real,v] = {}) /\ 15318 ~(interval[w:real,z] = {})`` 15319 MP_TAC THENL [ASM_SIMP_TAC std_ss [], ALL_TAC] THEN 15320 SIMP_TAC std_ss [SUBSET_INTERVAL, INTERVAL_NE_EMPTY, 15321 INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 15322 STRIP_TAC THEN DISCH_THEN(X_CHOOSE_THEN ``x:real`` MP_TAC) THEN 15323 MP_TAC(MESON[] 15324 ``(!P. (!j:num. P j) <=> P i /\ (!j. ~(j = i) ==> P j))``) THEN 15325 DISCH_THEN(fn th => GEN_REWR_TAC 15326 (LAND_CONV o ONCE_DEPTH_CONV) [th]) THEN 15327 ASM_SIMP_TAC std_ss [AND_IMP_INTRO] THEN STRIP_TAC THEN 15328 UNDISCH_TAC ``(!k. k IN d ==> content k <> 0 /\ k INTER {x | x = a} <> {}) \/ 15329 !k. k IN d ==> content k <> 0 /\ k INTER {x | x = b} <> {}`` THEN 15330 DISCH_TAC THEN 15331 FIRST_X_ASSUM(DISJ_CASES_THEN 15332 (fn th => MP_TAC(SPEC ``interval[u:real,v]`` th) THEN 15333 MP_TAC(SPEC ``interval[w:real,z]`` th))) THEN 15334 ASM_SIMP_TAC std_ss [CONTENT_EQ_0_INTERIOR, INTERIOR_CLOSED_INTERVAL] THEN 15335 REWRITE_TAC [IMP_CONJ, GSYM MEMBER_NOT_EMPTY, IN_INTER] THEN 15336 SIMP_TAC std_ss [IN_INTERVAL, LEFT_IMP_EXISTS_THM] THEN 15337 X_GEN_TAC ``q:real`` THEN STRIP_TAC THEN 15338 X_GEN_TAC ``r:real`` THEN STRIP_TAC THEN 15339 X_GEN_TAC ``s':real`` THEN STRIP_TAC THEN 15340 X_GEN_TAC ``t:real`` THEN STRIP_TAC THEN 15341 FULL_SIMP_TAC std_ss [GSPECIFICATION] THENL 15342 [EXISTS_TAC ``min ((q:real)) ((s':real))``, 15343 EXISTS_TAC ``max ((q:real)) ((s':real))``] THEN 15344 (SUBGOAL_THEN ``interval[u:real,v] SUBSET interval[a,b] /\ 15345 interval[w:real,z] SUBSET interval[a,b]`` 15346 MP_TAC THENL [ASM_SIMP_TAC std_ss [], ALL_TAC] THEN 15347 SUBGOAL_THEN ``~(interval[u:real,v] = {}) /\ 15348 ~(interval[w:real,z] = {})`` 15349 MP_TAC THENL [ASM_SIMP_TAC std_ss [], ALL_TAC] THEN 15350 ASM_SIMP_TAC std_ss [INTERVAL_NE_EMPTY, SUBSET_INTERVAL] THEN 15351 rpt STRIP_TAC >> RW_TAC real_ss [min_def, max_def] THEN 15352 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 15353 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 15354 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 15355 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 15356 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 15357 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 15358 REAL_ARITH_TAC), 15359 ALL_TAC] THEN 15360 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 15361 ``sum (IMAGE (extend:(real->bool)->(real->bool)) d) content`` THEN 15362 CONJ_TAC THENL 15363 [W(MP_TAC o PART_MATCH (lhs o rand) SUM_IMAGE_NONZERO o rand o snd) THEN 15364 KNOW_TAC ``FINITE (d :(real -> bool) -> bool) /\ 15365 (!(x :real -> bool) (y :real -> bool). 15366 x IN d /\ y IN d /\ x <> y /\ 15367 ((extend :(real -> bool) -> real -> bool) x = extend y) ==> 15368 (content (extend x) = (0 :real)))`` THENL 15369 [ASM_REWRITE_TAC[] THEN 15370 MAP_EVERY X_GEN_TAC [``k1:real->bool``, ``k2:real->bool``] THEN 15371 STRIP_TAC THEN FIRST_X_ASSUM(MP_TAC o SPECL 15372 [``k1:real->bool``, ``k2:real->bool``]) THEN 15373 ASM_REWRITE_TAC[INTER_IDEMPOT] THEN 15374 EXPAND_TAC "extend" THEN REWRITE_TAC[CONTENT_EQ_0_INTERIOR], 15375 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 15376 DISCH_THEN SUBST1_TAC THEN REWRITE_TAC[GSYM SUM_LMUL] THEN 15377 MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [] THEN 15378 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 15379 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN DISCH_TAC THEN 15380 ASM_CASES_TAC ``content(interval[u:real,v]) = &0`` THENL 15381 [ASM_REWRITE_TAC[real_div, REAL_MUL_LZERO, REAL_MUL_RZERO, o_THM] THEN 15382 EXPAND_TAC "extend" THEN REWRITE_TAC[CONTENT_POS_LE], 15383 ALL_TAC] THEN 15384 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM CONTENT_LT_NZ]) THEN 15385 DISCH_THEN(fn th => ASSUME_TAC th THEN MP_TAC th) THEN 15386 REWRITE_TAC[CONTENT_POS_LT_EQ] THEN STRIP_TAC THEN 15387 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND, 15388 REAL_LT_IMP_LE, real_div, REAL_MUL_ASSOC] THEN 15389 ASM_SIMP_TAC std_ss [GSYM real_div, REAL_LE_LDIV_EQ, REAL_SUB_LT] THEN 15390 SUBGOAL_THEN 15391 ``~((extend:(real->bool)->(real->bool)) (interval[u,v]) = {})`` 15392 MP_TAC THENL [ASM_SIMP_TAC std_ss [], ALL_TAC] THEN 15393 EXPAND_TAC "extend" THEN ASM_SIMP_TAC std_ss [content, o_THM] THEN 15394 ASM_SIMP_TAC std_ss [INTERVAL_NE_EMPTY, INTERVAL_LOWERBOUND, 15395 INTERVAL_UPPERBOUND, REAL_LT_IMP_LE] THEN 15396 DISCH_THEN(K ALL_TAC) THEN REAL_ARITH_TAC], 15397 MATCH_MP_TAC SUBADDITIVE_CONTENT_DIVISION THEN EXISTS_TAC 15398 ``BIGUNION (IMAGE (extend:(real->bool)->(real->bool)) d)`` THEN 15399 ASM_SIMP_TAC std_ss [BIGUNION_SUBSET, division_of, IMAGE_FINITE] THEN 15400 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_IMAGE] THEN 15401 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 15402 REPEAT CONJ_TAC THEN MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN 15403 DISCH_TAC THENL 15404 [CONJ_TAC THENL [ASM_SET_TAC[], ASM_SIMP_TAC std_ss []] THEN 15405 EXPAND_TAC "extend" THEN SIMP_TAC std_ss [] THEN MESON_TAC[], 15406 ASM_MESON_TAC[], 15407 ASM_SIMP_TAC std_ss []]]); 15408 15409Theorem SUM_CONTENT_AREA_OVER_THIN_DIVISION : 15410 !d a b:real s c. 15411 d division_of s /\ s SUBSET interval[a,b] /\ 15412 a <= c /\ c <= b /\ 15413 (!k. k IN d ==> ~(k INTER {x | x = c} = {})) 15414 ==> (b - a) * 15415 sum d (\k. content k / 15416 (interval_upperbound k - interval_lowerbound k)) 15417 <= &2 * content(interval[a,b]) 15418Proof 15419 REPEAT STRIP_TAC THEN 15420 ASM_CASES_TAC ``content(interval[a:real,b]) = &0`` THENL 15421 [MATCH_MP_TAC(REAL_ARITH ``(x = &0) /\ &0 <= y ==> x <= &2 * y:real``) THEN 15422 SIMP_TAC std_ss [CONTENT_POS_LE, REAL_ENTIRE] THEN DISJ2_TAC THEN 15423 MATCH_MP_TAC SUM_EQ_0 THEN X_GEN_TAC ``k:real->bool`` THEN 15424 DISCH_TAC THEN SIMP_TAC std_ss [real_div, REAL_ENTIRE] THEN DISJ1_TAC THEN 15425 MATCH_MP_TAC CONTENT_0_SUBSET THEN 15426 MAP_EVERY EXISTS_TAC [``a:real``, ``b:real``] THEN 15427 METIS_TAC[division_of, SUBSET_TRANS], 15428 ALL_TAC] THEN 15429 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM CONTENT_LT_NZ]) THEN 15430 DISCH_THEN(fn th => ASSUME_TAC th THEN MP_TAC th) THEN 15431 REWRITE_TAC[CONTENT_POS_LT_EQ] THEN STRIP_TAC THEN 15432 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 15433 MP_TAC(ISPECL 15434 [``{k | k IN {l INTER {x | x <= c} | l | 15435 l IN d /\ ~(l INTER {x:real | x <= c} = {})} /\ 15436 ~(content k = &0)}``, 15437 ``a:real``, ``c:real``, 15438 ``BIGUNION {k | k IN {l INTER {x | x <= c} | l | 15439 l IN d /\ ~(l INTER {x:real | x <= c} = {})} /\ 15440 ~(content k = &0)}``] lemma1) THEN 15441 MP_TAC(ISPECL 15442 [``{k | k IN {l INTER {x | x >= c} | l | 15443 l IN d /\ ~(l INTER {x:real | x >= c} = {})} /\ 15444 ~(content k = &0)}``, 15445 ``c:real``, ``b:real``, 15446 ``BIGUNION {k | k IN {l INTER {x | x >= c} | l | 15447 l IN d /\ ~(l INTER {x:real | x >= c} = {})} /\ 15448 ~(content k = &0)}``] lemma1) THEN 15449 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC(TAUT 15450 `(p1 /\ p2) /\ (q1 /\ q2 ==> r) ==> (p2 ==> q2) ==> (p1 ==> q1) ==> r`) THEN 15451 CONJ_TAC THENL 15452 [ (* goal 1 (of 2) *) 15453 CONJ_TAC THENL 15454 [ (* goal 1.1 (of 2) *) 15455 REPEAT CONJ_TAC THENL (* 3 subgoals *) 15456 [ (* goal 1.1.1 (of 3) *) 15457 REWRITE_TAC[division_of] THEN CONJ_TAC THENL (* 2 subgoals *) 15458 [ (* goal 1.1.1.1 (of 2) *) 15459 ONCE_REWRITE_TAC [METIS [] 15460 ``{k | k IN 15461 {l INTER {x | x <= c} | l | l IN d /\ l INTER {x | x <= c} <> {}} /\ 15462 content k <> 0} = 15463 {k | k IN 15464 {l INTER {x | x <= c} | l | l IN d /\ l INTER {x | x <= c} <> {}} /\ 15465 (\k. content k <> 0) k}``] THEN 15466 MATCH_MP_TAC FINITE_RESTRICT THEN 15467 KNOW_TAC ``FINITE (IMAGE (\l. l INTER {x | x <= c:real}) 15468 {l | l IN d /\ ~(l INTER {x | x <= c} = {})})`` THENL 15469 [ALL_TAC, METIS_TAC [SIMPLE_IMAGE_GEN]] THEN 15470 MATCH_MP_TAC IMAGE_FINITE THEN METIS_TAC [FINITE_RESTRICT], 15471 (* goal 1.1.1.2 (of 2) *) 15472 ALL_TAC] THEN 15473 SIMP_TAC std_ss [FORALL_IN_GSPEC, IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 15474 CONJ_TAC THENL (* 2 subgoals *) 15475 [ (* goal 1.1.1.1 (of 2) *) 15476 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 15477 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN 15478 REPEAT DISCH_TAC THEN ASM_REWRITE_TAC[] THEN CONJ_TAC THENL 15479 [ SIMP_TAC std_ss [GSPECIFICATION, SUBSET_DEF, IN_BIGUNION] THEN ASM_MESON_TAC[], 15480 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN MESON_TAC[] ], 15481 (* goal 1.1.1.2 (of 2) *) 15482 X_GEN_TAC ``k:real->bool`` THEN REPEAT DISCH_TAC THEN 15483 X_GEN_TAC ``l:real->bool`` THEN REPEAT DISCH_TAC THEN 15484 UNDISCH_TAC ``d division_of s`` THEN DISCH_TAC THEN 15485 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 15486 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 15487 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 15488 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 15489 DISCH_THEN(MP_TAC o SPECL [``k:real->bool``, ``l:real->bool``]) THEN 15490 KNOW_TAC ``k IN d /\ l IN d /\ k <> l:real->bool`` THENL 15491 [ASM_MESON_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 15492 MATCH_MP_TAC(SET_RULE 15493 ``s SUBSET s' /\ t SUBSET t' 15494 ==> (s' INTER t' = {}) ==> (s INTER t = {})``) THEN 15495 CONJ_TAC THEN MATCH_MP_TAC SUBSET_INTERIOR THEN SET_TAC[] ], 15496 (* goal 1.1.2 (of 3) *) 15497 SIMP_TAC std_ss [BIGUNION_SUBSET, FORALL_IN_GSPEC, IMP_CONJ] THEN 15498 X_GEN_TAC ``k:real->bool`` THEN REPEAT DISCH_TAC THEN 15499 SUBGOAL_THEN ``k SUBSET interval[a:real,b]`` MP_TAC THENL 15500 [ASM_MESON_TAC[division_of, SUBSET_TRANS], ALL_TAC] THEN 15501 MATCH_MP_TAC(SET_RULE 15502 ``i INTER h SUBSET j ==> k SUBSET i ==> k INTER h SUBSET j``) THEN 15503 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, SUBSET_INTERVAL] THEN 15504 RW_TAC real_ss [REAL_LE_MIN, REAL_LE_REFL], 15505 (* goal 1.1.3 (of 3) *) 15506 ALL_TAC ], 15507 (* goal 1.2 (of 2) *) 15508 REPEAT CONJ_TAC THENL 15509 [ (* goal 1.2.1 (of 3) *) 15510 REWRITE_TAC[division_of] THEN CONJ_TAC THENL 15511 [ (* goal 1.2.1.1 (of 2) *) 15512 ONCE_REWRITE_TAC [METIS [] 15513 ``{k | k IN 15514 {l INTER {x | x >= c} | l | l IN d /\ l INTER {x | x >= c} <> {}} /\ 15515 content k <> 0} = 15516 {k | k IN 15517 {l INTER {x | x >= c} | l | l IN d /\ l INTER {x | x >= c} <> {}} /\ 15518 (\k. content k <> 0) k}``] THEN 15519 MATCH_MP_TAC FINITE_RESTRICT THEN 15520 KNOW_TAC ``FINITE (IMAGE (\l. l INTER {x | x >= c:real}) 15521 {l | l IN d /\ ~(l INTER {x | x >= c} = {})})`` THENL 15522 [ALL_TAC, METIS_TAC [SIMPLE_IMAGE_GEN]] THEN 15523 MATCH_MP_TAC IMAGE_FINITE THEN METIS_TAC [FINITE_RESTRICT], 15524 (* goal 1.2.1.2 (of 2) *) 15525 ALL_TAC ] THEN 15526 SIMP_TAC std_ss [FORALL_IN_GSPEC, IMP_CONJ, RIGHT_FORALL_IMP_THM] THEN 15527 CONJ_TAC THENL 15528 [ (* goal 1.2.1.1 (of 2) *) 15529 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 15530 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN 15531 REPEAT DISCH_TAC THEN ASM_REWRITE_TAC[] THEN CONJ_TAC THENL 15532 [SIMP_TAC std_ss [GSPECIFICATION, SUBSET_DEF, IN_BIGUNION] THEN ASM_MESON_TAC[], 15533 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN MESON_TAC[]], 15534 (* goal 1.2.1.2 (of 2) *) 15535 X_GEN_TAC ``k:real->bool`` THEN REPEAT DISCH_TAC THEN 15536 X_GEN_TAC ``l:real->bool`` THEN REPEAT DISCH_TAC THEN 15537 UNDISCH_TAC ``d division_of s`` THEN DISCH_TAC THEN 15538 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 15539 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 15540 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 15541 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 15542 DISCH_THEN(MP_TAC o SPECL [``k:real->bool``, ``l:real->bool``]) THEN 15543 KNOW_TAC ``k IN d /\ l IN d /\ k <> l:real->bool`` THENL 15544 [ASM_MESON_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 15545 MATCH_MP_TAC(SET_RULE 15546 ``s SUBSET s' /\ t SUBSET t' 15547 ==> (s' INTER t' = {}) ==> (s INTER t = {})``) THEN 15548 CONJ_TAC THEN MATCH_MP_TAC SUBSET_INTERIOR THEN SET_TAC[] ], 15549 (* goal 1.2.2 (of 3) *) 15550 SIMP_TAC std_ss [BIGUNION_SUBSET, FORALL_IN_GSPEC, IMP_CONJ] THEN 15551 X_GEN_TAC ``k:real->bool`` THEN REPEAT DISCH_TAC THEN 15552 SUBGOAL_THEN ``k SUBSET interval[a:real,b]`` MP_TAC THENL 15553 [ASM_MESON_TAC[division_of, SUBSET_TRANS], ALL_TAC] THEN 15554 MATCH_MP_TAC(SET_RULE 15555 ``i INTER h SUBSET j ==> k SUBSET i ==> k INTER h SUBSET j``) THEN 15556 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, SUBSET_INTERVAL] THEN 15557 RW_TAC real_ss [REAL_LE_MAX, REAL_LE_REFL], 15558 (* goal 1.2.3 (of 3) *) 15559 ALL_TAC ] ] THENL [DISJ2_TAC, DISJ1_TAC] THEN 15560 (* still in goal 1 *) 15561 SIMP_TAC std_ss [FORALL_IN_GSPEC, IMP_CONJ] THEN 15562 ASM_SIMP_TAC std_ss [real_ge] THEN X_GEN_TAC ``l:real->bool`` THEN 15563 DISCH_TAC THEN FIRST_ASSUM (MP_TAC o SPEC ``l:real->bool``) THEN 15564 FIRST_ASSUM (fn th => REWRITE_TAC [th]) THEN 15565 SIMP_TAC std_ss [IN_INTER, NOT_IN_EMPTY, EXTENSION, GSPECIFICATION] THEN 15566 SIMP_TAC std_ss [REAL_LE_REFL], 15567 (* goal 2 (of 2) *) 15568 ASM_SIMP_TAC std_ss [] ] THEN 15569 (* stage work *) 15570 SUBGOAL_THEN 15571 ``(sum {k | k IN 15572 { l INTER {x | x <= c} | l | 15573 l IN d /\ ~(l INTER {x:real | x <= c} = {})} /\ 15574 ~(content k = &0)} 15575 (\k. content k / 15576 (interval_upperbound k - interval_lowerbound k)) = 15577 sum d ((\k. content k / 15578 (interval_upperbound k - interval_lowerbound k)) o 15579 (\k. k INTER {x | x <= c}))) /\ 15580 (sum {k | k IN 15581 { l INTER {x | x >= c} | l | 15582 l IN d /\ ~(l INTER {x:real | x >= c} = {})} /\ 15583 ~(content k = &0)} 15584 (\k. content k / 15585 (interval_upperbound k - interval_lowerbound k)) = 15586 sum d ((\k. content k / 15587 (interval_upperbound k - interval_lowerbound k)) o 15588 (\k. k INTER {x | x >= c})))`` 15589 (CONJUNCTS_THEN SUBST1_TAC) THENL 15590 [ (* goal 1 (of 2) *) 15591 CONJ_TAC THENL 15592 [ (* goal 1.1 (of 2) *) 15593 W(MP_TAC o PART_MATCH (rand o rand) SUM_IMAGE_NONZERO o rand o snd) THEN 15594 ASM_SIMP_TAC std_ss [] THEN 15595 KNOW_TAC ``(!(x :real -> bool) (y :real -> bool). 15596 x IN (d :(real -> bool) -> bool) /\ y IN d /\ x <> y /\ 15597 (x INTER {x | x <= (c :real)} = y INTER {x | x <= c}) ==> 15598 (content (y INTER {x | x <= c}) / 15599 (interval_upperbound (y INTER {x | x <= c}) - 15600 interval_lowerbound (y INTER {x | x <= c})) = (0 : real)))`` THENL 15601 [ MAP_EVERY X_GEN_TAC [``k:real->bool``, ``l:real->bool``] THEN 15602 STRIP_TAC THEN 15603 SIMP_TAC std_ss [real_div, REAL_ENTIRE] THEN DISJ1_TAC THEN 15604 (MATCH_MP_TAC DIVISION_SPLIT_LEFT_INJ ORELSE 15605 MATCH_MP_TAC DIVISION_SPLIT_RIGHT_INJ) THEN METIS_TAC[], 15606 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 15607 DISCH_THEN(SUBST1_TAC o SYM) THEN CONV_TAC SYM_CONV THEN 15608 MATCH_MP_TAC SUM_SUPERSET THEN CONJ_TAC THENL [SET_TAC[], ALL_TAC] THEN 15609 GEN_TAC THEN DISCH_TAC THEN 15610 KNOW_TAC ``((!l:real->bool. (l INTER {x | x <= c} = {}) 15611 ==> (content ((\k. k INTER {x | x <= c}) l) = &0)) 15612 ==> (content x = &0)) 15613 ==> ((\k. content k / (interval_upperbound k - 15614 interval_lowerbound k)) x = &0)`` THENL 15615 [ALL_TAC, POP_ASSUM MP_TAC THEN SET_TAC []] THEN 15616 SIMP_TAC std_ss [CONTENT_EMPTY, real_div, REAL_MUL_LZERO] ], 15617 (* goal 1.2 (of 2) *) 15618 W(MP_TAC o PART_MATCH (rand o rand) SUM_IMAGE_NONZERO o rand o snd) THEN 15619 ASM_SIMP_TAC std_ss [] THEN 15620 KNOW_TAC ``(!(x :real -> bool) (y :real -> bool). 15621 x IN (d :(real -> bool) -> bool) /\ y IN d /\ x <> y /\ 15622 (x INTER {x | x >= (c :real)} = y INTER {x | x >= c}) ==> 15623 (content (y INTER {x | x >= c}) / 15624 (interval_upperbound (y INTER {x | x >= c}) - 15625 interval_lowerbound (y INTER {x | x >= c})) = (0 : real)))`` THENL 15626 [ MAP_EVERY X_GEN_TAC [``k:real->bool``, ``l:real->bool``] THEN 15627 STRIP_TAC THEN 15628 SIMP_TAC std_ss [real_div, REAL_ENTIRE] THEN DISJ1_TAC THEN 15629 (MATCH_MP_TAC DIVISION_SPLIT_LEFT_INJ ORELSE 15630 MATCH_MP_TAC DIVISION_SPLIT_RIGHT_INJ) THEN METIS_TAC[], 15631 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 15632 DISCH_THEN(SUBST1_TAC o SYM) THEN CONV_TAC SYM_CONV THEN 15633 MATCH_MP_TAC SUM_SUPERSET THEN CONJ_TAC THENL [SET_TAC[], ALL_TAC] THEN 15634 GEN_TAC THEN DISCH_TAC THEN 15635 KNOW_TAC ``((!l:real->bool. (l INTER {x | x >= c} = {}) 15636 ==> (content ((\k. k INTER {x | x >= c}) l) = &0)) 15637 ==> (content x = &0)) 15638 ==> ((\k. content k / (interval_upperbound k - 15639 interval_lowerbound k)) x = &0)`` THENL 15640 [ALL_TAC, POP_ASSUM MP_TAC THEN SET_TAC []] THEN 15641 SIMP_TAC std_ss [CONTENT_EMPTY, real_div, REAL_MUL_LZERO]] ], 15642 (* goal 2 (of 2) *) 15643 ALL_TAC] THEN 15644 ASM_CASES_TAC ``c = a:real`` THENL 15645 [ASM_SIMP_TAC std_ss [REAL_SUB_REFL, REAL_MUL_LZERO, CONTENT_POS_LE] THEN 15646 MATCH_MP_TAC(REAL_ARITH ``(x = y) /\ a <= b ==> x <= a ==> y <= b:real``) THEN 15647 CONJ_TAC THENL 15648 [AP_TERM_TAC THEN MATCH_MP_TAC SUM_EQ THEN 15649 X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 15650 PURE_REWRITE_TAC[o_THM] THEN AP_TERM_TAC THEN 15651 SIMP_TAC std_ss [real_ge] THEN 15652 ONCE_REWRITE_TAC [METIS [] ``({x | a <= x} = {x | (\x. a <= x) (x:real)}) /\ 15653 ({x | x <= a} = {x | (\x. x <= a) (x:real)})``] THEN 15654 SIMP_TAC std_ss [SET_RULE 15655 ``(k INTER {x | P x} = k) <=> (!x. x IN k ==> P x)``] THEN 15656 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 15657 SUBGOAL_THEN ``x IN interval[a:real,b]`` MP_TAC THENL 15658 [ASM_MESON_TAC[SUBSET_DEF, division_of], ALL_TAC] THEN 15659 ASM_SIMP_TAC std_ss [IN_INTERVAL], 15660 MATCH_MP_TAC(REAL_ARITH ``&0 <= y /\ x <= y ==> x <= &2 * y:real``) THEN 15661 REWRITE_TAC[CONTENT_POS_LE] THEN MATCH_MP_TAC CONTENT_SUBSET THEN 15662 SIMP_TAC std_ss [SUBSET_INTERVAL] THEN MESON_TAC[REAL_LE_REFL]], 15663 ALL_TAC] THEN 15664 ASM_CASES_TAC ``c = b:real`` THENL 15665 [ASM_SIMP_TAC std_ss [REAL_SUB_REFL, REAL_MUL_LZERO, CONTENT_POS_LE] THEN 15666 MATCH_MP_TAC(REAL_ARITH ``(x = y) /\ a <= b ==> x <= a ==> y <= b:real``) THEN 15667 CONJ_TAC THENL 15668 [AP_TERM_TAC THEN MATCH_MP_TAC SUM_EQ THEN 15669 X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 15670 PURE_REWRITE_TAC[o_THM] THEN AP_TERM_TAC THEN 15671 SIMP_TAC std_ss [real_ge] THEN 15672 ONCE_REWRITE_TAC [METIS [] ``({x | a <= x} = {x | (\x. a <= x) (x:real)}) /\ 15673 ({x | x <= a} = {x | (\x. x <= a) (x:real)})``] THEN 15674 SIMP_TAC std_ss [SET_RULE 15675 ``(k INTER {x | P x} = k) <=> (!x. x IN k ==> P x)``] THEN 15676 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 15677 SUBGOAL_THEN ``x IN interval[a:real,b]`` MP_TAC THENL 15678 [ASM_MESON_TAC[SUBSET_DEF, division_of], ALL_TAC] THEN 15679 ASM_SIMP_TAC std_ss [IN_INTERVAL], 15680 MATCH_MP_TAC(REAL_ARITH ``&0 <= y /\ x <= y ==> x <= &2 * y:real``) THEN 15681 REWRITE_TAC[CONTENT_POS_LE] THEN MATCH_MP_TAC CONTENT_SUBSET THEN 15682 SIMP_TAC std_ss [SUBSET_INTERVAL] THEN MESON_TAC[REAL_LE_REFL]], 15683 ALL_TAC] THEN 15684 SUBGOAL_THEN ``(a:real) < c /\ c < (b:real)`` STRIP_ASSUME_TAC THENL 15685 [FULL_SIMP_TAC real_ss [REAL_LE_LT], ALL_TAC] THEN 15686 ONCE_REWRITE_TAC[REAL_MUL_SYM] THEN 15687 ASM_SIMP_TAC real_ss [GSYM REAL_LE_RDIV_EQ, REAL_SUB_LT] THEN 15688 REWRITE_TAC[real_div, REAL_ARITH ``x * &2 * inv y = &2 * x * inv y:real``] THEN 15689 REWRITE_TAC [GSYM real_div, GSYM REAL_MUL_ASSOC] THEN 15690 MATCH_MP_TAC(REAL_ARITH 15691 ``s <= s1 + s2 /\ (c1 = c) /\ (c2 = c) 15692 ==> s1 <= c1 /\ s2 <= c2 ==> s <= &2 * c:real``) THEN 15693 CONJ_TAC THENL 15694 [ (* goal 1 (of 2) *) 15695 ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN MATCH_MP_TAC SUM_LE THEN 15696 ASM_SIMP_TAC std_ss [lemma0] THEN 15697 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 15698 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN DISCH_TAC THEN 15699 SUBGOAL_THEN 15700 ``~(interval[u:real,v] = {}) /\ interval[u,v] SUBSET interval[a,b]`` 15701 MP_TAC THENL [ASM_MESON_TAC[division_of, SUBSET_TRANS], ALL_TAC] THEN 15702 SIMP_TAC std_ss [INTERVAL_NE_EMPTY, SUBSET_INTERVAL, IMP_CONJ] THEN 15703 REPEAT STRIP_TAC THEN REWRITE_TAC[o_THM] THEN 15704 Know `!x x1 x2 c c1 c2. &0 <= x:real /\ (c1 + c2 = c:real) /\ 15705 (~(c1 = &0) ==> (x1 = x)) /\ (~(c2 = &0) ==> (x2 = x)) 15706 ==> (if c = &0 then &0 else x) <= 15707 (if c1 = &0 then &0 else x1) + 15708 (if c2 = &0 then &0 else x2)` 15709 >- (KILL_TAC >> rpt GEN_TAC \\ 15710 rpt COND_CASES_TAC >> REAL_ASM_ARITH_TAC) \\ 15711 DISCH_THEN MATCH_MP_TAC \\ 15712 ASM_SIMP_TAC std_ss [GSYM CONTENT_SPLIT, REAL_LE_01], 15713 SUBGOAL_THEN 15714 ``~(interval[a,b] = {}) /\ 15715 ~(interval[a:real,c] = {}) /\ 15716 ~(interval[c:real,b] = {})`` 15717 MP_TAC THENL 15718 [SIMP_TAC std_ss [INTERVAL_NE_EMPTY] THEN 15719 ASM_MESON_TAC[REAL_LT_IMP_LE, REAL_LE_REFL], 15720 ALL_TAC] THEN 15721 SIMP_TAC std_ss [content] THEN 15722 SIMP_TAC std_ss [INTERVAL_NE_EMPTY, INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND] THEN 15723 STRIP_TAC THEN UNDISCH_TAC ``c <> a:real`` THEN 15724 GEN_REWR_TAC LAND_CONV [REAL_ARITH ``(c <> a) <=> (c - a <> 0:real)``] THEN 15725 UNDISCH_TAC ``c <> b:real`` THEN 15726 GEN_REWR_TAC LAND_CONV [REAL_ARITH ``(c <> b) <=> (b - c <> 0:real)``] THEN 15727 UNDISCH_TAC ``a < b:real`` THEN 15728 GEN_REWR_TAC LAND_CONV [REAL_ARITH ``(a < b) <=> (0 < b - a:real)``] THEN 15729 DISCH_THEN (MP_TAC o ONCE_REWRITE_RULE [EQ_SYM_EQ] o MATCH_MP REAL_LT_IMP_NE) THEN 15730 SIMP_TAC std_ss [REAL_DIV_REFL] ] 15731QED 15732 15733Theorem BOUNDED_EQUIINTEGRAL_OVER_THIN_TAGGED_PARTIAL_DIVISION : 15734 !fs f:real->real a b e. 15735 fs equiintegrable_on interval[a,b] /\ f IN fs /\ 15736 (!h x. h IN fs /\ x IN interval[a,b] ==> abs(h x) <= abs(f x)) /\ 15737 &0 < e 15738 ==> ?d. gauge d /\ 15739 !c p h. c IN interval[a,b] /\ 15740 p tagged_partial_division_of interval[a,b] /\ 15741 d FINE p /\ 15742 h IN fs /\ 15743 (!x k. (x,k) IN p ==> ~(k INTER {x | x = c} = {})) 15744 ==> sum p(\(x,k). abs(integral k h)) < e 15745Proof 15746 REPEAT STRIP_TAC THEN 15747 ASM_CASES_TAC ``content(interval[a:real,b]) = &0`` THENL 15748 [EXISTS_TAC ``\x:real. ball(x,&1)`` THEN REWRITE_TAC[GAUGE_TRIVIAL] THEN 15749 REPEAT STRIP_TAC THEN FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REAL_ARITH 15750 ``&0 < e ==> (x = &0) ==> x < e:real``)) THEN 15751 MATCH_MP_TAC SUM_EQ_0 THEN SIMP_TAC std_ss [FORALL_PROD] THEN 15752 GEN_TAC THEN X_GEN_TAC ``k:real->bool`` THEN DISCH_TAC THEN 15753 SUBGOAL_THEN 15754 ``?u v:real. (k = interval[u,v]) /\ interval[u,v] SUBSET interval[a,b]`` 15755 STRIP_ASSUME_TAC THENL 15756 [METIS_TAC[tagged_partial_division_of], ALL_TAC] THEN 15757 ASM_REWRITE_TAC[ABS_ZERO] THEN MATCH_MP_TAC INTEGRAL_NULL THEN 15758 ASM_MESON_TAC[CONTENT_0_SUBSET], 15759 ALL_TAC] THEN 15760 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM CONTENT_LT_NZ]) THEN 15761 DISCH_THEN(fn th => ASSUME_TAC th THEN MP_TAC th) THEN 15762 REWRITE_TAC[CONTENT_POS_LT_EQ] THEN STRIP_TAC THEN 15763 SUBGOAL_THEN 15764 ``?d. gauge d /\ 15765 !p h. p tagged_partial_division_of interval [a,b] /\ 15766 d FINE p /\ (h:real->real) IN fs 15767 ==> sum p (\(x,k). abs(content k * h x - integral k h)) < 15768 e / &2`` 15769 (X_CHOOSE_THEN ``g0:real->real->bool`` STRIP_ASSUME_TAC) 15770 THENL 15771 [UNDISCH_TAC ``fs equiintegrable_on interval [(a,b)]`` THEN DISCH_TAC THEN 15772 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [equiintegrable_on]) THEN 15773 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o SPEC 15774 ``e / &5 / (&1 + &1:real)``)) THEN 15775 ASM_SIMP_TAC real_ss [REAL_LT_DIV, REAL_ARITH ``&0 < &5:real``, 15776 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 15777 DISCH_THEN (X_CHOOSE_TAC ``g:real->real->bool``) THEN 15778 EXISTS_TAC ``g:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 15779 STRIP_TAC THEN ASM_SIMP_TAC std_ss [] THEN MAP_EVERY X_GEN_TAC 15780 [``p:(real#(real->bool))->bool``, ``h:real->real``] THEN 15781 STRIP_TAC THEN 15782 MP_TAC(ISPECL [``h:real->real``, ``a:real``, ``b:real``, 15783 ``g:real->real->bool``, ``e / &5 / ((&1:real) + &1)``] 15784 HENSTOCK_LEMMA_PART2) THEN 15785 ASM_SIMP_TAC real_ss [REAL_LT_DIV, REAL_ARITH ``&0 < &5:real``, 15786 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 15787 DISCH_THEN(MP_TAC o SPEC ``p:(real#(real->bool))->bool``) THEN 15788 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC(REAL_ARITH 15789 ``a < b ==> x <= a ==> x < b:real``) THEN 15790 REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN 15791 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c * inv a = (a * inv a) * b * c:real``] THEN 15792 SIMP_TAC real_ss [REAL_MUL_RINV] THEN REWRITE_TAC [GSYM real_div] THEN 15793 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN ONCE_REWRITE_TAC [REAL_MUL_SYM] THEN 15794 REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN REWRITE_TAC [GSYM real_div] THEN 15795 SIMP_TAC real_ss [REAL_LT_LDIV_EQ] THEN UNDISCH_TAC ``0 < e:real`` THEN 15796 REAL_ARITH_TAC, 15797 ALL_TAC] THEN 15798 ABBREV_TAC 15799 ``g:real->real->bool = 15800 \x. g0(x) INTER 15801 ball(x,(e / &8 / (abs(f x:real) + &1)) * 15802 inf(IMAGE (\m. b - a) ((1:num)..(1:num))) / 15803 content(interval[a:real,b]))`` THEN 15804 SUBGOAL_THEN ``gauge(g:real->real->bool)`` ASSUME_TAC THENL 15805 [EXPAND_TAC "g" THEN 15806 KNOW_TAC ``(gauge (\(x :real). 15807 (g0 :real -> real -> bool) x INTER 15808 (\x. ball (x, (e :real) / (8 :real) / 15809 (abs ((f :real -> real) x) + (1 :real)) * 15810 inf (IMAGE (\(m :num). (b :real) - (a :real)) 15811 ((1 :num) .. (1 :num))) / content (interval [(a,b)]))) x) : bool)`` THENL 15812 [ALL_TAC, METIS_TAC []] THEN 15813 MATCH_MP_TAC GAUGE_INTER THEN ASM_REWRITE_TAC[] THEN 15814 SIMP_TAC std_ss [gauge_def, OPEN_BALL, CENTRE_IN_BALL] THEN 15815 X_GEN_TAC ``x:real`` THEN 15816 REWRITE_TAC [real_div, REAL_ARITH ``a * b * c * d * e = 15817 (a * b * c) * (d * e:real)``] THEN 15818 MATCH_MP_TAC REAL_LT_MUL THEN REWRITE_TAC [GSYM real_div] THEN 15819 ASM_SIMP_TAC real_ss [REAL_LT_DIV, REAL_ARITH 15820 ``&0 < &8:real /\ &0 < abs(x:real) + &1:real``] THEN 15821 MATCH_MP_TAC REAL_LT_DIV THEN ASM_REWRITE_TAC[] THEN 15822 REWRITE_TAC [NUMSEG_SING, IMAGE_SING, INF_SING] THEN 15823 UNDISCH_TAC ``a < b:real`` THEN REAL_ARITH_TAC, 15824 ALL_TAC] THEN 15825 EXISTS_TAC ``g:real->real->bool`` THEN ASM_REWRITE_TAC[] THEN 15826 MAP_EVERY X_GEN_TAC 15827 [``c:real``, ``p:(real#(real->bool))->bool``, 15828 ``h:real->real``] THEN 15829 STRIP_TAC THEN 15830 SUBGOAL_THEN 15831 ``interval[c:real,b] SUBSET interval[a,b]`` 15832 ASSUME_TAC THENL 15833 [UNDISCH_TAC ``c IN interval[a:real,b]`` THEN 15834 SIMP_TAC std_ss [IN_INTERVAL, SUBSET_INTERVAL, REAL_LE_REFL], 15835 ALL_TAC] THEN 15836 SUBGOAL_THEN ``FINITE(p:(real#(real->bool))->bool)`` ASSUME_TAC THENL 15837 [METIS_TAC[tagged_partial_division_of], ALL_TAC] THEN 15838 MP_TAC(ASSUME ``(g:real->real->bool) FINE p``) THEN EXPAND_TAC "g" THEN 15839 ONCE_REWRITE_TAC [METIS [] ``!x. 15840 (ball (x, 15841 e / 8 / (abs (f x) + 1) * inf (IMAGE (\m. b - a) (1 .. 1)) / 15842 content (interval [(a,b)]))) = 15843 (\x. ball (x, 15844 e / 8 / (abs (f x) + 1) * inf (IMAGE (\m. b - a) (1 .. 1)) / 15845 content (interval [(a,b)]))) x``] THEN 15846 REWRITE_TAC[FINE_INTER] THEN 15847 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC ASSUME_TAC) THEN 15848 FIRST_X_ASSUM(MP_TAC o SPEC ``p:(real#(real->bool))->bool``) THEN 15849 DISCH_THEN(MP_TAC o SPEC ``h:real->real``) THEN 15850 KNOW_TAC ``(p :real # (real -> bool) -> bool) tagged_partial_division_of 15851 interval [((a :real),(b :real))] /\ 15852 (g0 :real -> real -> bool) FINE p /\ 15853 (h :real -> real) IN (fs :(real -> real) -> bool)`` THENL 15854 [ASM_MESON_TAC[TAGGED_PARTIAL_DIVISION_OF_SUBSET], 15855 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 15856 GEN_REWR_TAC (RAND_CONV o RAND_CONV) [GSYM REAL_HALF] THEN 15857 MATCH_MP_TAC(REAL_ARITH 15858 ``x - y <= e / &2 ==> y < e / &2 ==> x < e / 2 + e / 2:real``) THEN 15859 ASM_SIMP_TAC std_ss [GSYM SUM_SUB] THEN 15860 SIMP_TAC std_ss [LAMBDA_PROD] THEN MATCH_MP_TAC REAL_LE_TRANS THEN 15861 EXISTS_TAC 15862 ``sum p (\(x:real,k:real->bool). abs(content k * h x:real))`` THEN 15863 CONJ_TAC THENL 15864 [MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 15865 REWRITE_TAC[REAL_ARITH ``abs y - abs(x - y:real) <= abs x``], 15866 ALL_TAC] THEN 15867 MATCH_MP_TAC REAL_LE_TRANS THEN 15868 EXISTS_TAC 15869 ``sum p (\(x:real,k). 15870 e / &4 * (b - a) / content(interval[a:real,b]) * 15871 content(k:real->bool) / 15872 (interval_upperbound k - interval_lowerbound k))`` THEN 15873 CONJ_TAC THENL 15874 [MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 15875 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 15876 ASM_CASES_TAC ``content(k:real->bool) = &0`` THENL 15877 [ASM_REWRITE_TAC[real_div, REAL_MUL_LZERO, ABS_0, 15878 REAL_MUL_RZERO, REAL_LE_REFL], 15879 ALL_TAC] THEN 15880 REWRITE_TAC [real_div] THEN 15881 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c * d * content k * f = 15882 content k * ((a * b) * (c * d) * f:real)``] THEN 15883 REWRITE_TAC [GSYM real_div] THEN REWRITE_TAC[ABS_MUL] THEN 15884 SUBGOAL_THEN ``&0 < content(k:real->bool)`` ASSUME_TAC THENL 15885 [METIS_TAC[CONTENT_LT_NZ, tagged_partial_division_of], ALL_TAC] THEN 15886 GEN_REWR_TAC (LAND_CONV o LAND_CONV) [abs] THEN 15887 ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE, REAL_LE_LMUL] THEN 15888 MATCH_MP_TAC(REAL_ARITH ``x + &1 <= y ==> x <= y:real``) THEN 15889 SUBGOAL_THEN ``?u v. k = interval[u:real,v]`` MP_TAC THENL 15890 [METIS_TAC[tagged_partial_division_of], ALL_TAC] THEN 15891 DISCH_THEN(REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) THEN 15892 MP_TAC(ISPECL [``u:real``, ``v:real``] CONTENT_POS_LT_EQ) THEN 15893 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND, REAL_LT_IMP_LE] THEN 15894 DISCH_TAC THEN 15895 W(MP_TAC o PART_MATCH (lhand o rand) REAL_LE_RDIV_EQ o snd) THEN 15896 ASM_SIMP_TAC std_ss [REAL_SUB_LT] THEN DISCH_THEN SUBST1_TAC THEN 15897 GEN_REWR_TAC LAND_CONV [REAL_MUL_SYM] THEN 15898 SIMP_TAC real_ss [GSYM REAL_LE_RDIV_EQ, REAL_ARITH ``&0 < abs(x:real) + &1``] THEN 15899 UNDISCH_TAC ``(\x. ball (x, 15900 e / 8 / (abs (f x) + 1) * 15901 inf (IMAGE (\m. b - a) (1 .. 1)) / 15902 content (interval [(a,b)]))) FINE p`` THEN 15903 REWRITE_TAC[FINE] THEN 15904 DISCH_THEN(MP_TAC o SPECL [``x:real``, ``interval[u:real,v]``]) THEN 15905 ASM_REWRITE_TAC[SUBSET_DEF] THEN 15906 DISCH_THEN(fn th => MP_TAC(SPEC ``v:real`` th) THEN 15907 MP_TAC(SPEC ``u:real`` th)) THEN 15908 ASM_SIMP_TAC std_ss [INTERVAL_NE_EMPTY, REAL_LT_IMP_LE, ENDS_IN_INTERVAL] THEN 15909 REWRITE_TAC[IN_BALL, AND_IMP_INTRO] THEN REWRITE_TAC [dist] THEN 15910 MATCH_MP_TAC(REAL_ARITH 15911 ``abs(vi - ui) <= abs(v - u:real) /\ &2 * a <= b 15912 ==> abs(x - u) < a /\ abs(x - v) < a ==> vi - ui <= b``) THEN 15913 ASM_SIMP_TAC real_ss [] THEN 15914 REWRITE_TAC [real_div] THEN ONCE_REWRITE_TAC [REAL_ARITH ``8 = 2 * 4:real``] THEN 15915 SIMP_TAC real_ss [REAL_INV_MUL] THEN 15916 ONCE_REWRITE_TAC [REAL_ARITH ``a * (b * (inv a * c) * d * f * g:real) = 15917 b * ((a *inv a) * c) * d * f * g``] THEN 15918 SIMP_TAC real_ss [REAL_MUL_RINV, REAL_MUL_LID] THEN 15919 REWRITE_TAC[GSYM REAL_MUL_ASSOC] THEN 15920 MATCH_MP_TAC REAL_LE_LMUL_IMP THEN ASM_SIMP_TAC real_ss [REAL_LT_IMP_LE] THEN 15921 MATCH_MP_TAC REAL_LE_LMUL_IMP THEN KNOW_TAC ``0 <= inv 4:real`` THENL 15922 [SIMP_TAC real_ss [REAL_INV_1OVER, REAL_LE_RDIV_EQ], 15923 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 15924 REWRITE_TAC [REAL_MUL_ASSOC] THEN 15925 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c <= e * f * g <=> 15926 (b * a) * c <= (e * g) * f:real``] THEN 15927 MATCH_MP_TAC REAL_LE_RMUL_IMP THEN 15928 ASM_SIMP_TAC real_ss [REAL_LE_INV_EQ, REAL_LT_IMP_LE] THEN 15929 REWRITE_TAC [GSYM real_div] THEN 15930 MATCH_MP_TAC(REAL_ARITH ``abs x <= e ==> x <= e:real``) THEN 15931 REWRITE_TAC[real_div, ABS_MUL] THEN MATCH_MP_TAC REAL_LE_MUL2 THEN 15932 REWRITE_TAC[REAL_ABS_POS] THEN CONJ_TAC THENL 15933 [MATCH_MP_TAC(REAL_ARITH ``&0 <= x /\ x <= y ==> abs x <= y:real``) THEN 15934 SIMP_TAC real_ss [NUMSEG_SING, IMAGE_SING, INF_SING, REAL_LE_REFL] THEN 15935 UNDISCH_TAC ``a < b:real`` THEN REAL_ARITH_TAC, 15936 KNOW_TAC ``abs ((f:real->real) x) + 1 <> 0:real`` THENL 15937 [REAL_ARITH_TAC, DISCH_TAC] THEN 15938 ASM_SIMP_TAC real_ss [ABS_INV] THEN MATCH_MP_TAC REAL_LE_INV2 THEN 15939 CONJ_TAC THENL [REAL_ARITH_TAC, ALL_TAC] THEN 15940 MATCH_MP_TAC(REAL_ARITH ``x <= y ==> x + &1 <= abs(y + &1:real)``) THEN 15941 FIRST_X_ASSUM MATCH_MP_TAC THEN 15942 METIS_TAC[tagged_partial_division_of, SUBSET_DEF]], 15943 ALL_TAC] THEN 15944 FIRST_ASSUM(MP_TAC o MATCH_MP TAGGED_PARTIAL_DIVISION_OF_UNION_SELF) THEN 15945 DISCH_THEN(MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 15946 SUM_OVER_TAGGED_DIVISION_LEMMA)) THEN 15947 ONCE_REWRITE_TAC [METIS [] 15948 ``(\(x,k). 15949 e / 4 * (b - a) / content (interval [(a,b)]) * content k / 15950 (interval_upperbound k - interval_lowerbound k)) = 15951 (\(x,k). 15952 (\k. e / 4 * (b - a) / content (interval [(a,b)]) * content k / 15953 (interval_upperbound k - interval_lowerbound k)) k)``] THEN 15954 DISCH_THEN(fn th => 15955 W(MP_TAC o PART_MATCH (lhs o rand) th o lhand o snd)) THEN 15956 SIMP_TAC std_ss [] THEN 15957 KNOW_TAC ``(!(u :real) (v :real). 15958 interval [(u,v)] <> ({} :real -> bool) ==> 15959 (content (interval [(u,v)]) = (0 :real)) ==> 15960 ((e :real) / (4 :real) * ((b :real) - (a :real)) / 15961 content (interval [(a,b)]) * (0 :real) / 15962 (interval_upperbound (interval [(u,v)]) - 15963 interval_lowerbound (interval [(u,v)])) = 15964 (0 : real)))`` THENL 15965 [SIMP_TAC std_ss [real_div, REAL_MUL_LZERO, REAL_MUL_RZERO], 15966 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 15967 DISCH_THEN SUBST1_TAC] THEN 15968 REWRITE_TAC [real_div] THEN 15969 KNOW_TAC ``sum 15970 (IMAGE (SND :real # (real -> bool) -> real -> bool) 15971 (p :real # (real -> bool) -> bool)) 15972 (\(k :real -> bool). 15973 ((e :real) * inv (4 :real) * ((b :real) - (a :real)) * 15974 inv (content (interval [(a,b)]))) * (\k. content k * 15975 inv (interval_upperbound k - interval_lowerbound k)) k) <= 15976 e * inv (2 :real)`` THENL 15977 [ALL_TAC, SIMP_TAC std_ss [] THEN REWRITE_TAC [REAL_MUL_ASSOC]] THEN 15978 REWRITE_TAC [SUM_LMUL] THEN 15979 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c * d * e = (a * c * d * e) * b:real``] THEN 15980 REWRITE_TAC [GSYM real_div] THEN SIMP_TAC real_ss [REAL_LE_LDIV_EQ] THEN 15981 REWRITE_TAC [REAL_ARITH ``4 = 2 * 2:real``, real_div, REAL_MUL_ASSOC] THEN 15982 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c * d = a * (b * c) * d:real``] THEN 15983 SIMP_TAC real_ss [REAL_MUL_LINV] THEN SIMP_TAC real_ss [REAL_MUL_ASSOC] THEN 15984 ASM_SIMP_TAC real_ss [GSYM REAL_MUL_ASSOC, REAL_LE_LMUL] THEN 15985 ONCE_REWRITE_TAC [REAL_ARITH ``a * (b * c) = (a * c) * b:real``] THEN 15986 REWRITE_TAC [GSYM real_div] THEN ASM_SIMP_TAC std_ss [REAL_LE_LDIV_EQ] THEN 15987 MATCH_MP_TAC SUM_CONTENT_AREA_OVER_THIN_DIVISION THEN 15988 EXISTS_TAC ``BIGUNION (IMAGE SND (p:(real#(real->bool))->bool))`` THEN 15989 EXISTS_TAC ``(c:real)`` THEN 15990 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_SIMP_TAC std_ss [] THEN 15991 REPEAT CONJ_TAC THENL 15992 [MATCH_MP_TAC DIVISION_OF_TAGGED_DIVISION THEN 15993 ASM_MESON_TAC[TAGGED_PARTIAL_DIVISION_OF_UNION_SELF], 15994 SIMP_TAC std_ss [BIGUNION_SUBSET, FORALL_IN_IMAGE, FORALL_PROD] THEN 15995 METIS_TAC[tagged_partial_division_of], 15996 ASM_SIMP_TAC std_ss [FORALL_IN_IMAGE, FORALL_PROD] THEN 15997 METIS_TAC []] 15998QED 15999 16000val lemma = prove ( 16001 ``(!x k. (x,k) IN IMAGE (\(x,k). f x k,g x k) s ==> Q x k) <=> 16002 (!x k. (x,k) IN s ==> Q (f x k) (g x k))``, 16003 SIMP_TAC std_ss [IN_IMAGE, PAIR_EQ, EXISTS_PROD] THEN SET_TAC[]); 16004 16005Theorem EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_LE : 16006 !fs f:real->real a b. 16007 fs equiintegrable_on interval[a,b] /\ f IN fs /\ 16008 (!h x. h IN fs /\ x IN interval[a,b] ==> abs(h x) <= abs(f x)) 16009 ==> { (\x. if x <= c then h x else 0) | c IN univ(:real) /\ h IN fs } 16010 equiintegrable_on interval[a,b] 16011Proof 16012 REPEAT STRIP_TAC THEN 16013 ASM_CASES_TAC ``content(interval[a:real,b]) = &0`` THEN 16014 ASM_SIMP_TAC std_ss [EQUIINTEGRABLE_ON_NULL] THEN 16015 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM CONTENT_LT_NZ]) THEN 16016 DISCH_THEN(fn th => ASSUME_TAC th THEN MP_TAC th) THEN 16017 REWRITE_TAC[CONTENT_POS_LT_EQ] THEN STRIP_TAC THEN 16018 REWRITE_TAC[equiintegrable_on] THEN 16019 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC] THEN 16020 SIMP_TAC std_ss [IN_UNIV, AND_IMP_INTRO, GSYM CONJ_ASSOC, RIGHT_IMP_FORALL_THM, 16021 IN_NUMSEG] THEN 16022 UNDISCH_TAC ``fs equiintegrable_on interval [(a,b)]`` THEN DISCH_TAC THEN 16023 FIRST_ASSUM(ASSUME_TAC o CONJUNCT1 o REWRITE_RULE[equiintegrable_on]) THEN 16024 MATCH_MP_TAC(TAUT `a /\ (a ==> b) ==> a /\ b`) THEN CONJ_TAC THENL 16025 [ (* goal 1 (of 2) *) 16026 REPEAT GEN_TAC THEN 16027 ONCE_REWRITE_TAC[SET_RULE ``x <= c <=> x IN {x:real | x <= c}``] THEN 16028 REWRITE_TAC[INTEGRABLE_RESTRICT_INTER] THEN 16029 ONCE_REWRITE_TAC[INTER_COMM] THEN SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 16030 REPEAT STRIP_TAC THEN MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 16031 EXISTS_TAC ``interval[a:real,b]`` THEN ASM_SIMP_TAC std_ss [] THEN 16032 SIMP_TAC std_ss [SUBSET_INTERVAL, REAL_LE_REFL] THEN 16033 rw [REAL_LE_MIN, REAL_MIN_LE, REAL_LE_REFL], 16034 (* goal 2 (of 2) *) 16035 DISCH_TAC ] THEN 16036 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 16037 MP_TAC(ISPECL [``fs:(real->real)->bool``, ``f:real->real``, 16038 ``a:real``, ``b:real``, ``e / &12:real``] 16039 BOUNDED_EQUIINTEGRAL_OVER_THIN_TAGGED_PARTIAL_DIVISION) THEN 16040 ASM_SIMP_TAC real_ss [REAL_LT_DIV, REAL_ARITH ``&0 < &12:real``] THEN 16041 DISCH_THEN(X_CHOOSE_THEN ``g0:real->real->bool`` STRIP_ASSUME_TAC) THEN 16042 SUBGOAL_THEN 16043 ``?d. gauge d /\ 16044 !p h. p tagged_partial_division_of interval [a,b] /\ 16045 d FINE p /\ (h:real->real) IN fs 16046 ==> sum p (\(x,k). abs(content k * h x - integral k h)) < 16047 e / &3`` 16048 (X_CHOOSE_THEN ``g1:real->real->bool`` STRIP_ASSUME_TAC) 16049 THENL 16050 [UNDISCH_TAC ``fs equiintegrable_on interval [(a,b)]`` THEN DISCH_TAC THEN 16051 FIRST_ASSUM(MP_TAC o CONJUNCT2 o REWRITE_RULE[equiintegrable_on]) THEN 16052 DISCH_THEN(MP_TAC o SPEC ``e / &7 / ((&1:real) + &1)``) THEN 16053 ASM_SIMP_TAC real_ss [REAL_LT_DIV, REAL_ARITH ``&0 < &7:real``, 16054 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 16055 DISCH_THEN (X_CHOOSE_TAC ``d:real->real->bool``) THEN 16056 EXISTS_TAC ``d:real->real->bool`` THEN POP_ASSUM MP_TAC THEN 16057 STRIP_TAC THEN ASM_SIMP_TAC std_ss [] THEN 16058 MAP_EVERY X_GEN_TAC 16059 [``p:(real#(real->bool))->bool``, ``h:real->real``] THEN 16060 STRIP_TAC THEN 16061 MP_TAC(ISPECL [``h:real->real``, ``a:real``, ``b:real``, 16062 ``d:real->real->bool``, ``e / &7 / ((&1:real) + &1)``] 16063 HENSTOCK_LEMMA_PART2) THEN 16064 ASM_SIMP_TAC real_ss [REAL_LT_DIV, REAL_ARITH ``&0 < &7:real``, 16065 METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] ``&0 < &n + &1:real``] THEN 16066 DISCH_THEN(MP_TAC o SPEC ``p:(real#(real->bool))->bool``) THEN 16067 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC(REAL_ARITH 16068 ``a < b ==> x <= a ==> x < b:real``) THEN 16069 REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN 16070 ONCE_REWRITE_TAC [REAL_ARITH ``a * b * c * inv a = (a * inv a) * b * c:real``] THEN 16071 SIMP_TAC real_ss [REAL_MUL_RINV] THEN REWRITE_TAC [GSYM real_div] THEN 16072 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN ONCE_REWRITE_TAC [REAL_MUL_SYM] THEN 16073 REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN REWRITE_TAC [GSYM real_div] THEN 16074 SIMP_TAC real_ss [REAL_LT_LDIV_EQ] THEN UNDISCH_TAC ``0 < e:real`` THEN 16075 REAL_ARITH_TAC, 16076 ALL_TAC] THEN 16077 EXISTS_TAC ``\x. (g0:real->real->bool) x INTER g1 x`` THEN 16078 ASM_SIMP_TAC std_ss [GAUGE_INTER, FINE_INTER] THEN 16079 KNOW_TAC ``!(c :real). (\c. !(h :real -> real) (p :real # (real -> bool) -> bool). 16080 h IN (fs :(real -> real) -> bool) /\ 16081 p tagged_division_of interval [((a :real),(b :real))] /\ 16082 (g0 :real -> real -> bool) FINE p /\ 16083 (g1 :real -> real -> bool) FINE p ==> 16084 abs 16085 (sum p 16086 (\((x :real),(k :real -> bool)). 16087 content k * if x <= c then h x else (0 :real)) - 16088 integral (interval [(a,b)]) 16089 (\(x :real). if x <= c then h x else (0 :real))) < (e :real)) c`` THENL 16090 [ALL_TAC, METIS_TAC []] THEN 16091 MP_TAC(MESON[] 16092 ``!P. ((!c. (a:real) <= c /\ c <= (b:real) ==> P c) ==> (!c. P c)) /\ 16093 (!c. (a:real) <= c /\ c <= (b:real) ==> P c) 16094 ==> !c. P c``) THEN 16095 DISCH_THEN MATCH_MP_TAC THEN CONJ_TAC THEN SIMP_TAC std_ss [] THENL 16096 [ (* goal 1 (of 2) *) 16097 DISCH_THEN(ASSUME_TAC) THEN 16098 X_GEN_TAC ``c:real`` THEN 16099 ASM_CASES_TAC ``(a:real) <= c /\ c <= (b:real)`` THENL 16100 [ UNDISCH_TAC ``!c. 16101 a <= c /\ c <= b ==> 16102 !h p. h IN fs /\ p tagged_division_of interval [(a,b)] /\ 16103 g0 FINE p /\ g1 FINE p ==> 16104 abs (sum p (\(x,k). content k * if x <= c then h x else 0) - 16105 integral (interval [(a,b)]) 16106 (\x. if x <= c then h x else 0)) < e`` THEN DISCH_TAC THEN 16107 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[], ALL_TAC ] THEN 16108 UNDISCH_TAC ``!c. 16109 a <= c /\ c <= b ==> 16110 !h p. h IN fs /\ p tagged_division_of interval [(a,b)] /\ 16111 g0 FINE p /\ g1 FINE p ==> 16112 abs (sum p (\(x,k). content k * if x <= c then h x else 0) - 16113 integral (interval [(a,b)]) 16114 (\x. if x <= c then h x else 0)) < e`` THEN DISCH_TAC THEN 16115 FIRST_X_ASSUM (MP_TAC o SPEC ``(b:real)``) THEN 16116 ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE, REAL_LE_REFL] THEN 16117 DISCH_TAC THEN X_GEN_TAC ``h:real->real`` THEN 16118 X_GEN_TAC ``p:real#(real->bool)->bool`` THEN 16119 POP_ASSUM (MP_TAC o SPECL [``h:real->real``,``p:real#(real->bool)->bool``]) THEN 16120 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_REWRITE_TAC[] THEN 16121 UNDISCH_TAC ``~(a <= c /\ c <= b:real)`` THEN DISCH_TAC THEN 16122 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [DE_MORGAN_THM]) THEN 16123 REWRITE_TAC[REAL_NOT_LE] THEN STRIP_TAC THENL 16124 [ (* goal 1.1 (of 2) *) 16125 DISCH_TAC THEN MATCH_MP_TAC(REAL_ARITH 16126 ``(x:real = 0) /\ (y = 0) /\ &0 < e ==> abs(x - y) < e:real``) THEN 16127 ASM_REWRITE_TAC[] THEN CONJ_TAC THENL 16128 [ MATCH_MP_TAC SUM_EQ_0 THEN SIMP_TAC std_ss [FORALL_PROD] THEN 16129 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 16130 COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [REAL_MUL_RZERO] THEN 16131 SUBGOAL_THEN ``(x:real) IN interval[a,b]`` MP_TAC THENL 16132 [ASM_MESON_TAC[TAGGED_DIVISION_OF, SUBSET_DEF], ALL_TAC] THEN 16133 REWRITE_TAC[IN_INTERVAL] THEN 16134 UNDISCH_TAC ``c < a:real`` THEN POP_ASSUM MP_TAC THEN 16135 REAL_ARITH_TAC, 16136 MATCH_MP_TAC EQ_TRANS THEN 16137 EXISTS_TAC ``integral(interval[a,b]) ((\x. 0):real->real)`` THEN 16138 CONJ_TAC THENL [ALL_TAC, SIMP_TAC std_ss [INTEGRAL_0]] THEN 16139 MATCH_MP_TAC INTEGRAL_EQ THEN SIMP_TAC std_ss [] THEN GEN_TAC THEN 16140 COND_CASES_TAC THEN ASM_REWRITE_TAC[IN_INTERVAL] THEN 16141 UNDISCH_TAC ``c < a:real`` THEN POP_ASSUM MP_TAC THEN 16142 REAL_ARITH_TAC], 16143 (* goal 1.2 (of 2) *) 16144 MATCH_MP_TAC(REAL_ARITH 16145 ``(x:real = y) /\ (w = z) ==> abs(x - w) < e ==> abs(y - z) < e``) THEN 16146 CONJ_TAC THENL 16147 [ (* goal 1.2.1 (of 2) *) 16148 MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [FORALL_PROD] THEN 16149 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 16150 SUBGOAL_THEN ``(x:real) IN interval[a,b]`` MP_TAC THENL 16151 [ASM_MESON_TAC[TAGGED_DIVISION_OF, SUBSET_DEF], ALL_TAC] THEN 16152 REWRITE_TAC[IN_INTERVAL] THEN 16153 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 16154 COND_CASES_TAC THEN ASM_REWRITE_TAC[REAL_MUL_RZERO] THEN 16155 UNDISCH_TAC ``b < c:real`` THEN POP_ASSUM MP_TAC THEN 16156 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 16157 (* goal 1.2.2 (of 2) *) 16158 MATCH_MP_TAC INTEGRAL_EQ THEN SIMP_TAC std_ss [] THEN GEN_TAC THEN 16159 rpt COND_CASES_TAC THEN ASM_SIMP_TAC real_ss [IN_INTERVAL] THEN 16160 NTAC 3 (POP_ASSUM MP_TAC) >> REAL_ARITH_TAC ] ], 16161 (* goal 2 (of 2) *) 16162 ALL_TAC ] THEN 16163 X_GEN_TAC ``c:real`` THEN DISCH_TAC THEN 16164 MAP_EVERY X_GEN_TAC [``h:real->real``, 16165 ``p:(real#(real->bool))->bool``] THEN STRIP_TAC THEN 16166 ABBREV_TAC 16167 ``q:(real#(real->bool))->bool = 16168 {(x,k) | (x,k) IN p /\ ~(k INTER {x | x <= c} = {})}`` THEN 16169 MP_TAC(ISPECL 16170 [``\x. if x <= c then (h:real->real) x else 0``, 16171 ``a:real``, ``b:real``, ``p:(real#(real->bool))->bool``] 16172 INTEGRAL_COMBINE_TAGGED_DIVISION_TOPDOWN) THEN 16173 ASM_SIMP_TAC std_ss [] THEN DISCH_THEN SUBST1_TAC THEN 16174 SUBGOAL_THEN ``FINITE(p:(real#(real->bool))->bool)`` ASSUME_TAC THENL 16175 [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 16176 SUBGOAL_THEN ``q SUBSET (p:(real#(real->bool))->bool)`` ASSUME_TAC THENL 16177 [EXPAND_TAC "q" THEN SIMP_TAC std_ss [SUBSET_DEF, FORALL_PROD, IN_ELIM_PAIR_THM], 16178 ALL_TAC] THEN 16179 SUBGOAL_THEN ``FINITE(q:(real#(real->bool))->bool)`` ASSUME_TAC THENL 16180 [ASM_MESON_TAC[FINITE_SUBSET], ALL_TAC] THEN 16181 ASM_SIMP_TAC std_ss [GSYM SUM_SUB] THEN SIMP_TAC std_ss [LAMBDA_PROD] THEN 16182 SUBGOAL_THEN ``q tagged_partial_division_of interval[a:real,b] /\ 16183 g0 FINE q /\ g1 FINE q`` 16184 STRIP_ASSUME_TAC THENL 16185 [ASM_MESON_TAC[TAGGED_PARTIAL_DIVISION_SUBSET, tagged_division_of, 16186 FINE_SUBSET], 16187 ALL_TAC] THEN 16188 MATCH_MP_TAC(MESON[] ``!q. (sum p s = sum q s) /\ abs(sum q s) < e 16189 ==> abs(sum p s:real) < e``) THEN 16190 EXISTS_TAC ``q:(real#(real->bool))->bool`` THEN CONJ_TAC THENL 16191 [ (* goal 1 (of 2) *) 16192 MATCH_MP_TAC SUM_SUPERSET THEN ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 16193 EXPAND_TAC "q" THEN SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN 16194 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN 16195 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN ASM_REWRITE_TAC[] THEN 16196 SUBGOAL_THEN ``(x:real) IN k`` ASSUME_TAC THENL 16197 [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 16198 DISCH_THEN(fn th => ASSUME_TAC th THEN MP_TAC th) THEN 16199 REWRITE_TAC[EXTENSION] THEN DISCH_THEN(MP_TAC o SPEC ``x:real``) THEN 16200 REWRITE_TAC[IN_INTER, NOT_IN_EMPTY] THEN ASM_SIMP_TAC std_ss [] THEN 16201 SIMP_TAC std_ss [GSPECIFICATION] THEN DISCH_TAC THEN 16202 ASM_REWRITE_TAC[REAL_MUL_RZERO] THEN 16203 REWRITE_TAC[REAL_NEG_EQ0, REAL_SUB_LZERO] THEN 16204 MATCH_MP_TAC EQ_TRANS THEN 16205 EXISTS_TAC ``integral k ((\x. 0):real->real)`` THEN 16206 CONJ_TAC THENL [ALL_TAC, REWRITE_TAC[INTEGRAL_0]] THEN 16207 MATCH_MP_TAC INTEGRAL_EQ THEN ASM_SET_TAC[], 16208 (* goal 2 (of 2) *) 16209 ALL_TAC ] THEN 16210 SUBGOAL_THEN 16211 ``abs(sum q (\(x,k). content k * h x - integral k (h:real->real))) 16212 < e / &3`` 16213 MP_TAC THENL 16214 [MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC ``sum q 16215 (\(x,k). abs(content k * h x - integral k (h:real->real)))`` THEN 16216 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC SUM_ABS_LE THEN 16217 ASM_SIMP_TAC std_ss [FORALL_PROD, REAL_LE_REFL], 16218 ALL_TAC] THEN 16219 SIMP_TAC real_ss [REAL_LT_RDIV_EQ] THEN 16220 MATCH_MP_TAC(REAL_ARITH 16221 ``abs(x - y:real) * 3 <= &2 * e 16222 ==> abs(x) * 3 < e ==> abs(y) < e``) THEN 16223 SIMP_TAC real_ss [GSYM REAL_LE_RDIV_EQ] THEN 16224 ASM_SIMP_TAC std_ss [GSYM SUM_SUB] THEN SIMP_TAC std_ss [LAMBDA_PROD] THEN 16225 ABBREV_TAC 16226 ``r:(real#(real->bool))->bool = 16227 {(x,k) | (x,k) IN q /\ ~(k SUBSET {x | x <= c})}`` THEN 16228 SUBGOAL_THEN ``r SUBSET (q:(real#(real->bool))->bool)`` ASSUME_TAC THENL 16229 [EXPAND_TAC "r" THEN SIMP_TAC std_ss [SUBSET_DEF, FORALL_PROD, IN_ELIM_PAIR_THM], 16230 ALL_TAC] THEN 16231 SUBGOAL_THEN ``FINITE(r:(real#(real->bool))->bool)`` ASSUME_TAC THENL 16232 [ASM_MESON_TAC[FINITE_SUBSET], ALL_TAC] THEN 16233 SUBGOAL_THEN ``r tagged_partial_division_of interval[a:real,b] /\ 16234 g0 FINE r /\ g1 FINE r`` 16235 STRIP_ASSUME_TAC THENL 16236 [ASM_MESON_TAC[TAGGED_PARTIAL_DIVISION_SUBSET, FINE_SUBSET], 16237 ALL_TAC] THEN 16238 MATCH_MP_TAC(MESON[] ``!r. (sum q s = sum r s) /\ abs(sum r s) <= e 16239 ==> abs(sum q s:real) <= e``) THEN 16240 EXISTS_TAC ``r:(real#(real->bool))->bool`` THEN CONJ_TAC THENL 16241 [ (* goal 1 (of 2) *) 16242 MATCH_MP_TAC SUM_SUPERSET THEN ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 16243 EXPAND_TAC "r" THEN SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN 16244 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN 16245 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN ASM_SIMP_TAC std_ss [] THEN 16246 SUBGOAL_THEN ``(x:real) IN k`` ASSUME_TAC THENL 16247 [ASM_MESON_TAC[tagged_partial_division_of], ALL_TAC] THEN 16248 DISCH_THEN(fn th => ASSUME_TAC th THEN MP_TAC th) THEN 16249 REWRITE_TAC[SUBSET_DEF] THEN DISCH_THEN(MP_TAC o SPEC ``x:real``) THEN 16250 ASM_SIMP_TAC std_ss [GSPECIFICATION] THEN DISCH_TAC THEN ASM_REWRITE_TAC[] THEN 16251 REWRITE_TAC[REAL_ARITH ``c - i - (c - j):real = j - i``] THEN 16252 REWRITE_TAC[REAL_SUB_0] THEN MATCH_MP_TAC INTEGRAL_EQ THEN 16253 ASM_SET_TAC[], 16254 (* goal 2 (of 2) *) 16255 ALL_TAC ] THEN 16256 W(MP_TAC o PART_MATCH (lhand o rand) SUM_ABS o lhand o snd) THEN 16257 ASM_SIMP_TAC std_ss [] THEN 16258 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] REAL_LE_TRANS) THEN 16259 ONCE_REWRITE_TAC[LAMBDA_PROD] THEN REWRITE_TAC[] THEN 16260 MAP_EVERY ABBREV_TAC 16261 [``s:(real#(real->bool))->bool = 16262 {(x,k) | (x,k) IN r /\ x IN {x | x <= c}}``, 16263 ``t:(real#(real->bool))->bool = 16264 {(x,k) | (x,k) IN r /\ ~(x IN {x | x <= c})}``] THEN 16265 SUBGOAL_THEN 16266 ``(s:(real#(real->bool))->bool) SUBSET r /\ 16267 (t:(real#(real->bool))->bool) SUBSET r`` 16268 STRIP_ASSUME_TAC THENL 16269 [MAP_EVERY EXPAND_TAC ["s", "t"] THEN 16270 SIMP_TAC std_ss [SUBSET_DEF, FORALL_PROD, IN_ELIM_PAIR_THM], 16271 ALL_TAC] THEN 16272 SUBGOAL_THEN 16273 ``FINITE(s:(real#(real->bool))->bool) /\ 16274 FINITE(t:(real#(real->bool))->bool)`` 16275 STRIP_ASSUME_TAC THENL [ASM_MESON_TAC[FINITE_SUBSET], ALL_TAC] THEN 16276 SUBGOAL_THEN ``DISJOINT (s:(real#(real->bool))->bool) t`` ASSUME_TAC THENL 16277 [MAP_EVERY EXPAND_TAC ["s", "t"] THEN 16278 SIMP_TAC std_ss [EXTENSION, DISJOINT_DEF, IN_INTER, FORALL_PROD, 16279 IN_ELIM_PAIR_THM] THEN SET_TAC[], 16280 ALL_TAC] THEN 16281 SUBGOAL_THEN ``r:(real#(real->bool))->bool = s UNION t`` SUBST1_TAC THENL 16282 [MAP_EVERY EXPAND_TAC ["s", "t"] THEN 16283 SIMP_TAC std_ss [EXTENSION, IN_UNION, FORALL_PROD, IN_ELIM_PAIR_THM] THEN 16284 SET_TAC[], 16285 ALL_TAC] THEN 16286 ASM_SIMP_TAC std_ss [SUM_UNION] THEN MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 16287 ``sum s (\(x:real,k). abs 16288 (integral k (h:real->real) - 16289 integral k (\x. if x <= c then h x else 0))) + 16290 sum t (\(x:real,k). abs 16291 ((content k * (h:real->real) x - integral k h) + 16292 integral k (\x. if x <= c then h x else 0)))`` THEN 16293 CONJ_TAC THENL 16294 [MATCH_MP_TAC REAL_EQ_IMP_LE THEN BINOP_TAC THEN 16295 MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [FORALL_PROD] THEN 16296 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN 16297 MAP_EVERY EXPAND_TAC ["s", "t"] THEN 16298 SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN SIMP_TAC std_ss [GSPECIFICATION] THEN 16299 STRIP_TAC THEN ASM_SIMP_TAC std_ss [] THENL 16300 [MATCH_MP_TAC(REAL_ARITH ``(a:real = -b) ==> (abs a = abs b)``) THEN 16301 REAL_ARITH_TAC, 16302 AP_TERM_TAC THEN REAL_ARITH_TAC], 16303 ALL_TAC] THEN 16304 SUBGOAL_THEN ``s tagged_partial_division_of interval[a:real,b] /\ 16305 t tagged_partial_division_of interval[a:real,b] /\ 16306 g0 FINE s /\ g1 FINE s /\ g0 FINE t /\ g1 FINE t`` 16307 STRIP_ASSUME_TAC THENL 16308 [ASM_MESON_TAC[TAGGED_PARTIAL_DIVISION_SUBSET, FINE_SUBSET], 16309 ALL_TAC] THEN 16310 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 16311 ``(sum s (\(x:real,k). abs(integral k (h:real->real))) + 16312 sum (IMAGE (\(x,k). (x,k INTER {x | x <= c})) s) 16313 (\(x:real,k). abs(integral k (h:real->real)))) + 16314 (sum t (\(x:real,k). abs(content k * h x - integral k h)) + 16315 sum t (\(x:real,k). abs(integral k (h:real->real))) + 16316 sum (IMAGE (\(x,k). (x,k INTER {x | x >= c})) t) 16317 (\(x:real,k). abs(integral k (h:real->real))))`` THEN 16318 CONJ_TAC THENL 16319 [ (* goal 1 (of 2) *) 16320 MATCH_MP_TAC REAL_LE_ADD2 THEN CONJ_TAC THENL 16321 [ (* goal 1.1 (of 2) *) 16322 W(MP_TAC o PART_MATCH (lhand o rand) SUM_IMAGE_NONZERO o 16323 rand o rand o snd) THEN 16324 KNOW_TAC ``FINITE (s :real # (real -> bool) -> bool) /\ 16325 (!(x :real # (real -> bool)) (y :real # (real -> bool)). 16326 x IN s /\ y IN s /\ x <> y /\ 16327 ((\((x :real),(k :real -> bool)). (x,k INTER {x | x <= (c :real)})) 16328 x = (\((x :real),(k :real -> bool)). (x,k INTER {x | x <= c})) y) ==> 16329 ((\((x :real),(k :real -> bool)). 16330 abs (integral k (h :real -> real))) 16331 ((\((x :real),(k :real -> bool)). (x,k INTER {x | x <= c})) x) = 16332 (0 : real)))`` THENL 16333 [ (* goal 1.1.1 (of 2) *) 16334 ASM_SIMP_TAC std_ss [FORALL_PROD] THEN 16335 MAP_EVERY X_GEN_TAC 16336 [``x:real``, ``k:real->bool``, ``l:real->bool``] THEN 16337 ASM_SIMP_TAC std_ss [PAIR_EQ] THEN 16338 REPEAT STRIP_TAC THEN MP_TAC(ISPECL 16339 [``s:real#(real->bool)->bool``, 16340 ``BIGUNION(IMAGE SND (s:real#(real->bool)->bool))``, 16341 ``x:real``, ``k:real->bool``, 16342 ``x:real``, ``l:real->bool``, ``c:real``] 16343 TAGGED_DIVISION_SPLIT_LEFT_INJ) THEN 16344 ASM_SIMP_TAC std_ss [] THEN 16345 KNOW_TAC ``s tagged_division_of BIGUNION (IMAGE SND s)`` THENL 16346 [ASM_MESON_TAC[TAGGED_PARTIAL_DIVISION_OF_UNION_SELF], 16347 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 16348 REWRITE_TAC[ABS_ZERO] THEN 16349 SUBGOAL_THEN ``?u v:real. l = interval[u,v]`` 16350 (REPEAT_TCL CHOOSE_THEN SUBST1_TAC) 16351 THENL [ASM_MESON_TAC[tagged_partial_division_of], ALL_TAC] THEN 16352 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, INTEGRAL_NULL], 16353 (* goal 1.1.2 (of 2) *) 16354 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 16355 DISCH_THEN SUBST1_TAC THEN 16356 ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN MATCH_MP_TAC SUM_LE THEN 16357 ASM_SIMP_TAC std_ss [o_THM, FORALL_PROD] THEN 16358 GEN_REWR_TAC (QUANT_CONV o QUANT_CONV o RAND_CONV o LAND_CONV o 16359 ONCE_DEPTH_CONV) [SET_RULE 16360 ``x <= c <=> x IN {x:real | x <= c}``] THEN 16361 SIMP_TAC std_ss [INTEGRAL_RESTRICT_INTER] THEN 16362 SIMP_TAC std_ss [GSPECIFICATION, INTER_COMM] THEN 16363 REWRITE_TAC[REAL_ARITH ``abs(a - b:real) <= abs a + abs b``] ], 16364 (* goal 1.2 (of 2) *) 16365 MP_TAC (ISPECL [``(\((x :real),(k :real -> bool)). abs (integral k h))``, 16366 ``(\((x :real),(k :real -> bool)). (x,k INTER {x | x >= c}))``, 16367 ``(t :real # (real -> bool) -> bool)``] SUM_IMAGE_NONZERO) THEN 16368 KNOW_TAC ``FINITE (t :real # (real -> bool) -> bool) /\ 16369 (!(x :real # (real -> bool)) (y :real # (real -> bool)). 16370 x IN t /\ y IN t /\ x <> y /\ 16371 ((\((x :real),(k :real -> bool)). (x,k INTER {x | x >= (c :real)})) 16372 x = (\((x :real),(k :real -> bool)). (x,k INTER {x | x >= c})) y) ==> 16373 ((\((x :real),(k :real -> bool)). 16374 abs (integral k (h :real -> real))) 16375 ((\((x :real),(k :real -> bool)). (x,k INTER {x | x >= c})) x) = 16376 (0 : real)))`` THENL 16377 [ (* goal 1.2.1 (of 2) *) 16378 ASM_SIMP_TAC std_ss [FORALL_PROD, PAIR_EQ] THEN 16379 MAP_EVERY X_GEN_TAC 16380 [``x:real``, ``k:real->bool``, ``l:real->bool``] THEN 16381 ASM_SIMP_TAC std_ss [PAIR_EQ] THEN 16382 REPEAT STRIP_TAC THEN MP_TAC(ISPECL 16383 [``t:real#(real->bool)->bool``, 16384 ``BIGUNION(IMAGE SND (t:real#(real->bool)->bool))``, 16385 ``x:real``, ``k:real->bool``, 16386 ``x:real``, ``l:real->bool``, ``c:real``] 16387 TAGGED_DIVISION_SPLIT_RIGHT_INJ) THEN 16388 ASM_SIMP_TAC std_ss [] THEN 16389 KNOW_TAC ``t tagged_division_of BIGUNION (IMAGE SND t)`` THENL 16390 [ASM_MESON_TAC[TAGGED_PARTIAL_DIVISION_OF_UNION_SELF], 16391 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 16392 REWRITE_TAC[ABS_ZERO] THEN 16393 SUBGOAL_THEN ``?u v:real. l = interval[u,v]`` 16394 (REPEAT_TCL CHOOSE_THEN SUBST1_TAC) 16395 THENL [ASM_MESON_TAC[tagged_partial_division_of], ALL_TAC] THEN 16396 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT, INTEGRAL_NULL], 16397 (* goal 1.2.2 (of 2) *) 16398 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 16399 DISCH_THEN SUBST1_TAC THEN 16400 ASM_SIMP_TAC std_ss [GSYM SUM_ADD] THEN MATCH_MP_TAC SUM_LE THEN 16401 ASM_SIMP_TAC std_ss [o_THM, FORALL_PROD] THEN 16402 MAP_EVERY X_GEN_TAC [``x:real``, ``k:real->bool``] THEN DISCH_TAC THEN 16403 MATCH_MP_TAC(REAL_ARITH 16404 ``(i = i1 + i2) 16405 ==> abs(c + i1:real) <= abs(c) + abs(i) + abs(i2)``) THEN 16406 ONCE_REWRITE_TAC[SET_RULE 16407 ``x <= c <=> x IN {x:real | x <= c}``] THEN 16408 SIMP_TAC std_ss [INTEGRAL_RESTRICT_INTER] THEN 16409 ONCE_REWRITE_TAC[SET_RULE 16410 ``{x | x <= c:real} INTER s = s INTER {x | x <= c}``] THEN 16411 SUBGOAL_THEN ``?u v:real. k = interval[u,v]`` 16412 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 16413 THENL [ASM_MESON_TAC[tagged_partial_division_of], ALL_TAC] THEN 16414 ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 16415 MATCH_MP_TAC (SIMP_RULE std_ss [] INTEGRAL_SPLIT) THEN 16416 ASM_REWRITE_TAC[] THEN MATCH_MP_TAC INTEGRABLE_ON_SUBINTERVAL THEN 16417 EXISTS_TAC ``interval[a:real,b]`` THEN 16418 ASM_SIMP_TAC std_ss [] THEN 16419 ASM_MESON_TAC[tagged_partial_division_of] ] ], 16420 (* goal 2 (of 2) *) 16421 ALL_TAC] THEN 16422 SUBGOAL_THEN 16423 ``!x:real k. (x,k) IN r ==> ~(k INTER {x:real | x = c} = {})`` 16424 ASSUME_TAC THENL 16425 [REPEAT GEN_TAC THEN MAP_EVERY EXPAND_TAC ["r", "q"] THEN 16426 SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN 16427 SIMP_TAC std_ss [GSYM CONJ_ASSOC, SUBSET_DEF, EXTENSION, NOT_FORALL_THM] THEN 16428 KNOW_TAC ``(x,k) IN (p :real # (real -> bool) -> bool) /\ 16429 (?x. x IN k /\ x <= c) /\ (?x. x IN k /\ ~(x <= c)) 16430 ==> (?x. x IN k /\ (x = c))`` THENL 16431 [ALL_TAC, 16432 SIMP_TAC std_ss [GSPECIFICATION, NOT_IN_EMPTY, IN_INTER, NOT_IMP]] THEN 16433 DISCH_TAC THEN MATCH_MP_TAC CONNECTED_IVT_COMPONENT THEN 16434 SIMP_TAC std_ss [RIGHT_EXISTS_AND_THM] THEN 16435 CONJ_TAC THENL [ALL_TAC, ASM_MESON_TAC[REAL_LE_TOTAL]] THEN 16436 SUBGOAL_THEN ``?u v:real. k = interval[u,v]`` 16437 (REPEAT_TCL CHOOSE_THEN SUBST_ALL_TAC) 16438 THENL [ASM_MESON_TAC[TAGGED_DIVISION_OF], ALL_TAC] THEN 16439 MATCH_MP_TAC CONVEX_CONNECTED THEN REWRITE_TAC[CONVEX_INTERVAL], 16440 ALL_TAC] THEN 16441 SIMP_TAC real_ss [REAL_LE_RDIV_EQ] THEN 16442 (* stage work *) 16443 MATCH_MP_TAC(REAL_ARITH 16444 ``x * 6 <= e /\ y * 2 <= e ==> (x + y) * 3 <= &2 * e:real``) THEN 16445 CONJ_TAC THENL 16446 [ (* goal 1 (of 2) *) 16447 MATCH_MP_TAC(REAL_ARITH 16448 ``x * 12 < e /\ y * 12 < e ==> (x + y) * 6 <= e:real``) THEN 16449 CONJ_TAC THEN SIMP_TAC real_ss [GSYM REAL_LT_RDIV_EQ] THEN 16450 FIRST_X_ASSUM MATCH_MP_TAC THEN 16451 EXISTS_TAC ``c:real`` THEN 16452 ASM_SIMP_TAC std_ss [IN_INTERVAL] THENL 16453 [ EXPAND_TAC "s" THEN SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN 16454 ASM_MESON_TAC[], 16455 REPEAT CONJ_TAC THENL 16456 [ UNDISCH_TAC ``s tagged_partial_division_of interval[a:real,b]``, 16457 UNDISCH_TAC ``(g0:real->real->bool) FINE s`` THEN 16458 SIMP_TAC std_ss [FINE, FORALL_IN_IMAGE, lemma] THEN SET_TAC[], 16459 SIMP_TAC std_ss [lemma] THEN 16460 REPEAT GEN_TAC THEN EXPAND_TAC "s" THEN 16461 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 16462 DISCH_TAC THEN MATCH_MP_TAC(SET_RULE 16463 ``~(k INTER t = {}) /\ t SUBSET s ==> ~((k INTER s) INTER t = {})``) THEN 16464 SIMP_TAC std_ss [SUBSET_DEF, GSPECIFICATION, REAL_LE_REFL, EXISTS_PROD] THEN 16465 FIRST_X_ASSUM MATCH_MP_TAC THEN METIS_TAC[] ] ], 16466 (* goal 2 (of 2) *) 16467 MATCH_MP_TAC(REAL_ARITH 16468 ``x * 3 < e /\ y * 12 < e /\ z * 12 < e ==> (x + y + z) * 2 <= e:real``) THEN 16469 REPEAT CONJ_TAC THEN SIMP_TAC real_ss [GSYM REAL_LT_RDIV_EQ] THEN 16470 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC std_ss [] THEN 16471 EXISTS_TAC ``c:real`` THEN 16472 ASM_SIMP_TAC std_ss [IN_INTERVAL] THENL 16473 [ EXPAND_TAC "t" THEN SIMP_TAC std_ss [IN_ELIM_PAIR_THM] THEN 16474 ASM_MESON_TAC[], 16475 REPEAT CONJ_TAC THENL 16476 [ UNDISCH_TAC ``t tagged_partial_division_of interval[a:real,b]``, 16477 UNDISCH_TAC ``(g0:real->real->bool) FINE t`` THEN 16478 SIMP_TAC std_ss [FINE, FORALL_IN_IMAGE, lemma] THEN SET_TAC[], 16479 SIMP_TAC std_ss [lemma] THEN 16480 REPEAT GEN_TAC THEN EXPAND_TAC "t" THEN 16481 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 16482 DISCH_TAC THEN MATCH_MP_TAC(SET_RULE 16483 ``~(k INTER t = {}) /\ t SUBSET s ==> ~((k INTER s) INTER t = {})``) THEN 16484 SIMP_TAC std_ss [SUBSET_DEF, GSPECIFICATION, REAL_LE_REFL, 16485 real_ge, EXISTS_PROD] THEN 16486 FIRST_X_ASSUM MATCH_MP_TAC THEN METIS_TAC[] ] ] ] THEN 16487 (* A shared tactic *) 16488 SIMP_TAC std_ss [tagged_partial_division_of] THENL 16489 [(* goal 1 (of 2) *) 16490 MATCH_MP_TAC MONO_AND THEN SIMP_TAC std_ss [IMAGE_FINITE] THEN 16491 MATCH_MP_TAC MONO_AND THEN 16492 SIMP_TAC std_ss [RIGHT_FORALL_IMP_THM, IMP_CONJ, FORALL_IN_GSPEC] THEN 16493 SIMP_TAC std_ss [lemma] THEN CONJ_TAC THEN 16494 DISCH_TAC THEN X_GEN_TAC ``x:real`` THEN X_GEN_TAC ``k:real->bool`` THEN 16495 POP_ASSUM (MP_TAC o SPECL [``x:real``,``k:real->bool``]) THEN 16496 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THENL 16497 [ MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 16498 [ SIMP_TAC std_ss [real_ge, IN_INTER, GSPECIFICATION] THEN 16499 ASM_SET_TAC[REAL_LE_TOTAL], 16500 MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 16501 [ SET_TAC[], 16502 STRIP_TAC THEN ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN 16503 MESON_TAC [] ] ], 16504 DISCH_TAC THEN X_GEN_TAC ``xx:real`` THEN X_GEN_TAC ``kk:real->bool`` THEN 16505 POP_ASSUM (MP_TAC o SPECL [``xx:real``,``kk:real->bool``]) THEN 16506 MATCH_MP_TAC MONO_IMP THEN REWRITE_TAC[] THEN 16507 MATCH_MP_TAC MONO_IMP THEN CONJ_TAC THENL 16508 [METIS_TAC [PAIR_EQ, GSYM MONO_NOT_EQ], ALL_TAC] THEN 16509 MATCH_MP_TAC(SET_RULE 16510 ``s SUBSET s' /\ t SUBSET t' 16511 ==> (s' INTER t' = {}) ==> (s INTER t = {})``) THEN CONJ_TAC THEN 16512 MATCH_MP_TAC SUBSET_INTERIOR THEN SIMP_TAC std_ss [INTER_SUBSET] ], 16513 (* goal 2 (of 2) *) 16514 MATCH_MP_TAC MONO_AND THEN SIMP_TAC std_ss [IMAGE_FINITE] THEN 16515 MATCH_MP_TAC MONO_AND THEN 16516 SIMP_TAC std_ss [RIGHT_FORALL_IMP_THM, IMP_CONJ, FORALL_IN_GSPEC] THEN 16517 SIMP_TAC std_ss [lemma] THEN CONJ_TAC THEN 16518 DISCH_TAC THEN X_GEN_TAC ``x:real`` THEN X_GEN_TAC ``k:real->bool`` THEN 16519 POP_ASSUM (MP_TAC o SPECL [``x:real``,``k:real->bool``]) THEN 16520 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THENL 16521 [MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 16522 [SIMP_TAC std_ss [real_ge, IN_INTER, GSPECIFICATION] THEN 16523 UNDISCH_TAC ``{(x,k) | (x:real,k:real->bool) IN r /\ 16524 x NOTIN {x | x <= c}} = t`` THEN 16525 REWRITE_TAC [EXTENSION] THEN 16526 DISCH_THEN (MP_TAC o SPECL [``(x:real, k:real->bool)``]) THEN 16527 DISCH_THEN (ASSUME_TAC o ONCE_REWRITE_RULE [EQ_SYM_EQ]) THEN 16528 UNDISCH_TAC ``(x:real,k:real->bool) IN t`` THEN ASM_REWRITE_TAC [] THEN 16529 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN REAL_ARITH_TAC, 16530 MATCH_MP_TAC MONO_AND THEN CONJ_TAC THENL 16531 [SET_TAC[], 16532 STRIP_TAC THEN ASM_SIMP_TAC std_ss [INTERVAL_SPLIT] THEN MESON_TAC[]]], 16533 DISCH_TAC THEN X_GEN_TAC ``xx:real`` THEN X_GEN_TAC ``kk:real->bool`` THEN 16534 POP_ASSUM (MP_TAC o SPECL [``xx:real``,``kk:real->bool``]) THEN 16535 MATCH_MP_TAC MONO_IMP THEN REWRITE_TAC[] THEN 16536 MATCH_MP_TAC MONO_IMP THEN CONJ_TAC THENL 16537 [METIS_TAC [PAIR_EQ, GSYM MONO_NOT_EQ], ALL_TAC] THEN 16538 MATCH_MP_TAC(SET_RULE 16539 ``s SUBSET s' /\ t SUBSET t' 16540 ==> (s' INTER t' = {}) ==> (s INTER t = {})``) THEN CONJ_TAC THEN 16541 MATCH_MP_TAC SUBSET_INTERIOR THEN SIMP_TAC std_ss [INTER_SUBSET] ] ] 16542QED 16543 16544val EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_GE = store_thm ("EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_GE", 16545 ``!fs f:real->real a b. 16546 fs equiintegrable_on interval[a,b] /\ f IN fs /\ 16547 (!h x. h IN fs /\ x IN interval[a,b] ==> abs(h x) <= abs(f x)) 16548 ==> { (\x. if x >= c then h x else 0) | 16549 c IN univ(:real) /\ h IN fs } 16550 equiintegrable_on interval[a,b]``, 16551 REPEAT STRIP_TAC THEN 16552 MP_TAC(ISPECL 16553 [``{\x. (f:real->real) (-x) | f IN fs}``, 16554 ``\x. (f:real->real)(-x)``, 16555 ``-b:real``, ``-a:real``] 16556 EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_LE) THEN 16557 ASM_SIMP_TAC std_ss [EQUIINTEGRABLE_REFLECT] THEN 16558 KNOW_TAC ``(\(x :real). (f :real -> real) (-x)) IN 16559 {(\(x :real). f (-x)) | f IN (fs :(real -> real) -> bool)} /\ 16560 (!(h :real -> real) (x :real). 16561 h IN {(\(x :real). f (-x)) | f IN fs} /\ 16562 x IN interval [(-(b :real),-(a :real))] ==> 16563 abs (h x) <= abs (f (-x)))`` THENL 16564 [ASM_SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC] THEN 16565 ONCE_REWRITE_TAC[GSYM IN_INTERVAL_REFLECT] THEN 16566 ASM_SIMP_TAC std_ss [REAL_NEG_NEG] THEN 16567 SIMP_TAC real_ss [GSYM IMAGE_DEF, IN_IMAGE] THEN 16568 EXISTS_TAC ``f:real->real`` THEN ASM_REWRITE_TAC[], 16569 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 16570 DISCH_THEN(MP_TAC o MATCH_MP EQUIINTEGRABLE_REFLECT) THEN 16571 REWRITE_TAC[REAL_NEG_NEG] THEN MATCH_MP_TAC 16572 (REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 16573 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC] THEN 16574 MAP_EVERY X_GEN_TAC [``c:real``, ``h:real->real``] THEN 16575 STRIP_TAC THEN SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN EXISTS_TAC 16576 ``(\x:real. if (-x) >= c then (h:real->real)(-x) else 0:real)`` THEN 16577 SIMP_TAC std_ss [REAL_NEG_NEG] THEN MAP_EVERY EXISTS_TAC 16578 [``-c:real``, ``\x. (h:real->real)(-x)``] THEN 16579 ASM_REWRITE_TAC[IN_UNIV] THEN 16580 SIMP_TAC std_ss [REAL_ARITH ``-x >= c <=> x <= -c:real``] THEN 16581 EXISTS_TAC ``h:real->real`` THEN ASM_REWRITE_TAC[]]); 16582 16583val EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_LT = store_thm ("EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_LT", 16584 ``!fs f:real->real a b. 16585 fs equiintegrable_on interval[a,b] /\ f IN fs /\ 16586 (!h x. h IN fs /\ x IN interval[a,b] ==> abs(h x) <= abs(f x)) 16587 ==> { (\x. if x < c then h x else 0) | c IN univ(:real) /\ h IN fs } 16588 equiintegrable_on interval[a,b]``, 16589 REPEAT STRIP_TAC THEN 16590 MP_TAC(ISPECL [``fs:(real->real)->bool``, ``f:real->real``, 16591 ``a:real``, ``b:real``] 16592 EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_GE) THEN 16593 ASM_SIMP_TAC std_ss [] THEN UNDISCH_TAC 16594 ``(fs:(real->real)->bool) equiintegrable_on interval[a,b]`` THEN 16595 REWRITE_TAC[AND_IMP_INTRO] THEN 16596 DISCH_THEN(MP_TAC o MATCH_MP EQUIINTEGRABLE_SUB) THEN 16597 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 16598 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC] THEN 16599 MAP_EVERY X_GEN_TAC [``c:real``, ``h:real->real``] THEN 16600 STRIP_TAC THEN SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 16601 EXISTS_TAC ``h:real->real`` THEN 16602 EXISTS_TAC ``\x:real. if x >= c then (h:real->real) x else 0:real`` THEN 16603 ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THENL 16604 [SIMP_TAC std_ss [FUN_EQ_THM, real_ge, GSYM REAL_NOT_LT] THEN 16605 GEN_TAC THEN COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [] THEN 16606 REAL_ARITH_TAC, 16607 MAP_EVERY EXISTS_TAC [``c:real``, ``h:real->real``] THEN 16608 ASM_SIMP_TAC std_ss []]); 16609 16610val EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_GT = store_thm ("EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_GT", 16611 ``!fs f:real->real a b. 16612 fs equiintegrable_on interval[a,b] /\ f IN fs /\ 16613 (!h x. h IN fs /\ x IN interval[a,b] ==> abs(h x) <= abs(f x)) 16614 ==> { (\x. if x > c then h x else 0) | c IN univ(:real) /\ h IN fs } 16615 equiintegrable_on interval[a,b]``, 16616 REPEAT STRIP_TAC THEN 16617 MP_TAC(ISPECL [``fs:(real->real)->bool``, ``f:real->real``, 16618 ``a:real``, ``b:real``] 16619 EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_LE) THEN 16620 ASM_SIMP_TAC std_ss [] THEN UNDISCH_TAC 16621 ``(fs:(real->real)->bool) equiintegrable_on interval[a,b]`` THEN 16622 REWRITE_TAC[AND_IMP_INTRO] THEN 16623 DISCH_THEN(MP_TAC o MATCH_MP EQUIINTEGRABLE_SUB) THEN 16624 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 16625 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC] THEN 16626 MAP_EVERY X_GEN_TAC [``c:real``, ``h:real->real``] THEN 16627 STRIP_TAC THEN SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 16628 EXISTS_TAC ``h:real->real`` THEN 16629 EXISTS_TAC ``\x. if x <= c then (h:real->real) x else 0`` THEN 16630 ASM_REWRITE_TAC[] THEN CONJ_TAC THENL 16631 [SIMP_TAC std_ss [FUN_EQ_THM, real_gt, GSYM REAL_NOT_LE] THEN 16632 GEN_TAC THEN COND_CASES_TAC THEN FULL_SIMP_TAC std_ss [] THEN 16633 REAL_ARITH_TAC, 16634 MAP_EVERY EXISTS_TAC [``c:real``, ``h:real->real``] THEN 16635 ASM_SIMP_TAC std_ss []]); 16636 16637val EQUIINTEGRABLE_OPEN_INTERVAL_RESTRICTIONS = store_thm ("EQUIINTEGRABLE_OPEN_INTERVAL_RESTRICTIONS", 16638 ``!f:real->real a b. 16639 f integrable_on interval[a,b] 16640 ==> { (\x. if x IN interval(c,d) then f x else 0) | 16641 c IN univ(:real) /\ d IN univ(:real) } 16642 equiintegrable_on interval[a,b]``, 16643 REPEAT STRIP_TAC THEN 16644 SUBGOAL_THEN 16645 ``!n. (\n. n <= (1:num) 16646 ==> f INSERT 16647 { (\x. if !i. 1 <= i /\ i <= n ==> c < x /\ x < d 16648 then (f:real->real) x else 0) | 16649 c IN univ(:real) /\ d IN univ(:real) } 16650 equiintegrable_on interval[a,b]) n`` 16651 MP_TAC THENL 16652 [MATCH_MP_TAC INDUCTION THEN 16653 SIMP_TAC std_ss [ARITH_PROVE ``~(1 <= i /\ i <= 0:num)``] THEN 16654 ASM_SIMP_TAC std_ss [ETA_AX, EQUIINTEGRABLE_ON_SING, SET_RULE 16655 ``f INSERT {f |(c,d)| c IN UNIV /\ d IN UNIV} = {f}``] THEN 16656 X_GEN_TAC ``n:num`` THEN ASM_CASES_TAC ``SUC n <= (1:num)`` THEN 16657 ASM_REWRITE_TAC[] THEN KNOW_TAC ``n <= 1:num`` THENL 16658 [ASM_ARITH_TAC, DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 16659 DISCH_THEN(MP_TAC o SPEC ``f:real->real`` o 16660 MATCH_MP (REWRITE_RULE[IMP_CONJ] 16661 EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_LT)) THEN 16662 REWRITE_TAC[IN_INSERT] THEN 16663 KNOW_TAC ``(!(h :real -> real) (x :real). 16664 (h = (f :real -> real)) \/ 16665 h IN {(\(x :real). 16666 if !(i :num). (1 :num) <= i /\ i <= (n :num) ==> c < x /\ x < d 16667 then f x 16668 else (0 :real)) | 16669 c IN univ((:real) :real itself) /\ 16670 d IN univ((:real) :real itself)} ==> 16671 x IN interval [((a :real),(b :real))] ==> 16672 abs (h x) <= abs (f x))`` THENL 16673 [REWRITE_TAC[TAUT 16674 `a \/ b ==> c ==> d <=> (a ==> c ==> d) /\ (b ==> c ==> d)`] THEN 16675 SIMP_TAC std_ss [REAL_LE_REFL, RIGHT_FORALL_IMP_THM] THEN 16676 SIMP_TAC std_ss [FORALL_IN_GSPEC] THEN 16677 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 16678 ASM_SIMP_TAC std_ss [ABS_0, REAL_LE_REFL, ABS_POS], 16679 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 16680 UNDISCH_TAC ``f integrable_on interval [(a,b)]`` THEN DISCH_TAC THEN 16681 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM EQUIINTEGRABLE_ON_SING]) THEN 16682 REWRITE_TAC[AND_IMP_INTRO] THEN 16683 DISCH_THEN(MP_TAC o MATCH_MP EQUIINTEGRABLE_UNION) THEN 16684 DISCH_THEN(MP_TAC o SPEC ``f:real->real`` o 16685 MATCH_MP (REWRITE_RULE[IMP_CONJ] 16686 EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_GT)) THEN 16687 ASM_SIMP_TAC std_ss [IN_UNION, IN_SING] THEN 16688 KNOW_TAC ``(!(h :real -> real) (x :real). 16689 (h = (f :real -> real)) \/ 16690 h IN {(\(x :real). if x < c then h x else (0 :real)) | 16691 c IN univ((:real) :real itself) /\ 16692 ((h = f) \/ 16693 h IN {(\(x :real). 16694 if !(i :num). (1 :num) <= i /\ i <= (n :num) ==> c < x /\ x < d 16695 then f x 16696 else (0 :real)) | 16697 c IN univ((:real) :real itself) /\ 16698 d IN univ((:real) :real itself)})} ==> 16699 x IN interval [((a :real),(b :real))] ==> 16700 abs (h x) <= abs (f x))`` THENL 16701 [REWRITE_TAC[TAUT 16702 `a \/ b ==> c ==> d <=> (a ==> c ==> d) /\ (b ==> c ==> d)`] THEN 16703 SIMP_TAC std_ss [REAL_LE_REFL, RIGHT_FORALL_IMP_THM] THEN 16704 SIMP_TAC std_ss [FORALL_IN_GSPEC, LEFT_AND_OVER_OR] THEN 16705 REWRITE_TAC[TAUT `a \/ b ==> c <=> (a ==> c) /\ (b ==> c)`] THEN 16706 SIMP_TAC std_ss [REAL_LE_REFL, RIGHT_FORALL_IMP_THM] THEN 16707 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC, 16708 FORALL_AND_THM] THEN 16709 SIMP_TAC std_ss [IN_UNIV] THEN 16710 REPEAT STRIP_TAC THEN 16711 REPEAT(COND_CASES_TAC THEN 16712 ASM_SIMP_TAC std_ss [ABS_0, REAL_LE_REFL, ABS_POS]), 16713 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 16714 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM EQUIINTEGRABLE_ON_SING]) THEN 16715 REWRITE_TAC[AND_IMP_INTRO] THEN 16716 DISCH_THEN(MP_TAC o MATCH_MP EQUIINTEGRABLE_UNION) THEN 16717 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 16718 MATCH_MP_TAC(SET_RULE 16719 ``s SUBSET t ==> (x INSERT s) SUBSET ({x} UNION t)``) THEN 16720 SIMP_TAC std_ss [SUBSET_DEF, real_gt, FORALL_IN_GSPEC, IN_UNIV, EXISTS_PROD] THEN 16721 MAP_EVERY X_GEN_TAC [``c:real``, ``d:real``] THEN 16722 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 16723 EXISTS_TAC ``(c:real)`` THEN ONCE_REWRITE_TAC [CONJ_SYM] THEN 16724 KNOW_TAC ``?(p_2 :real -> real). 16725 ((p_2 = (f :real -> real)) \/ 16726 ?(p_1 :real) (p_2' :real -> real). 16727 (\p_1 p_2'. (p_2' = f) \/ 16728 ?(p_1 :real) (p_2 :real). 16729 p_2' = 16730 (\(x :real). 16731 if 16732 !(i :num). 16733 (1 :num) <= i /\ i <= (n :num) ==> p_1 < x /\ x < p_2 16734 then 16735 f x 16736 else (0 :real))) p_1 p_2' /\ 16737 (p_2 = (\p_1 p_2'. (\(x :real). if x < p_1 then p_2' x else (0 :real))) p_1 p_2')) /\ 16738 (\p_2. ((\(x :real). 16739 if 16740 !(i :num). 16741 (1 :num) <= i /\ i <= SUC n ==> (c :real) < x /\ x < (d :real) 16742 then 16743 f x 16744 else (0 :real)) = 16745 (\(x :real). if c < x then p_2 x else (0 :real)))) p_2`` THENL 16746 [ALL_TAC, SIMP_TAC std_ss [CONJ_SYM]] THEN 16747 MATCH_MP_TAC(METIS[] 16748 ``(?c k. P c k /\ Q (g c k)) 16749 ==> ?h. ((h = f) \/ (?c k. P c k /\ (h = g c k))) /\ Q h``) THEN 16750 EXISTS_TAC ``(d:real)`` THEN 16751 EXISTS_TAC 16752 ``\x. if !i. 1 <= i /\ i <= n:num ==> (c:real) < x /\ x < (d:real) 16753 then (f:real->real) x else 0`` THEN 16754 SIMP_TAC std_ss [] THEN CONJ_TAC THENL 16755 [DISJ2_TAC THEN 16756 MAP_EVERY EXISTS_TAC [``c:real``, ``d:real``] THEN SIMP_TAC std_ss [], 16757 SIMP_TAC std_ss [FUN_EQ_THM, LE] THEN 16758 METIS_TAC[ARITH_PROVE ``1 <= SUC n``]], 16759 DISCH_THEN(MP_TAC o SPEC ``1:num``) THEN 16760 SIMP_TAC std_ss [IN_INTERVAL, LESS_EQ_REFL] THEN 16761 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 16762 SIMP_TAC std_ss [IN_INSERT, SUBSET_DEF, GSPECIFICATION, EXISTS_PROD] THEN 16763 REPEAT STRIP_TAC THEN ASM_CASES_TAC ``x = f:real->real`` THEN 16764 ASM_SIMP_TAC std_ss [] THEN EXISTS_TAC ``p_1:real`` THEN 16765 EXISTS_TAC ``p_2:real`` THEN ASM_SIMP_TAC std_ss [FUN_EQ_THM] THEN 16766 X_GEN_TAC ``y:real`` THEN COND_CASES_TAC THEN ASM_SIMP_TAC arith_ss []]); 16767 16768val EQUIINTEGRABLE_CLOSED_INTERVAL_RESTRICTIONS = store_thm ("EQUIINTEGRABLE_CLOSED_INTERVAL_RESTRICTIONS", 16769 ``!f:real->real a b. 16770 f integrable_on interval[a,b] 16771 ==> { (\x. if x IN interval[c,d] then f x else 0) | 16772 c IN univ(:real) /\ d IN univ(:real) } 16773 equiintegrable_on interval[a,b]``, 16774 REPEAT STRIP_TAC THEN 16775 SUBGOAL_THEN 16776 ``!n. (\n. n <= (1:num) 16777 ==> f INSERT 16778 { (\x. if !i. 1 <= i /\ i <= n ==> c <= x /\ x <= d 16779 then (f:real->real) x else 0) | 16780 c IN univ(:real) /\ d IN univ(:real) } 16781 equiintegrable_on interval[a,b]) n`` 16782 MP_TAC THENL 16783 [MATCH_MP_TAC INDUCTION THEN 16784 REWRITE_TAC[ARITH_PROVE ``~(1 <= i /\ i <= 0:num)``] THEN 16785 ASM_SIMP_TAC std_ss [ETA_AX, EQUIINTEGRABLE_ON_SING, SET_RULE 16786 ``f INSERT {f |(c,d)| c IN UNIV /\ d IN UNIV} = {f}``] THEN 16787 X_GEN_TAC ``n:num`` THEN ASM_CASES_TAC ``SUC n <= (1:num)`` THEN 16788 ASM_SIMP_TAC std_ss [] THEN KNOW_TAC ``n <= 1:num`` THENL 16789 [ASM_SIMP_TAC arith_ss [], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 16790 DISCH_THEN(MP_TAC o SPEC ``f:real->real`` o 16791 MATCH_MP (REWRITE_RULE[IMP_CONJ] 16792 EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_LE)) THEN 16793 SIMP_TAC std_ss [IN_INSERT] THEN 16794 KNOW_TAC ``(!(h :real -> real) (x :real). 16795 (h = (f :real -> real)) \/ 16796 h IN {(\(x :real). 16797 if !(i :num). (1 :num) <= i /\ i <= (n :num) ==> c <= x /\ x <= d 16798 then f x 16799 else (0 :real)) | 16800 c IN univ((:real) :real itself) /\ 16801 d IN univ((:real) :real itself)} ==> 16802 x IN interval [(a :real),(b :real)] ==> 16803 abs (h x) <= abs (f x))`` THENL 16804 [REWRITE_TAC[TAUT 16805 `a \/ b ==> c ==> d <=> (a ==> c ==> d) /\ (b ==> c ==> d)`] THEN 16806 SIMP_TAC std_ss [REAL_LE_REFL, RIGHT_FORALL_IMP_THM] THEN 16807 SIMP_TAC std_ss [FORALL_IN_GSPEC] THEN 16808 REPEAT STRIP_TAC THEN COND_CASES_TAC THEN 16809 ASM_SIMP_TAC std_ss [ABS_0, REAL_LE_REFL, ABS_POS], 16810 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 16811 UNDISCH_TAC ``f integrable_on interval [(a,b)]`` THEN DISCH_TAC THEN 16812 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM EQUIINTEGRABLE_ON_SING]) THEN 16813 REWRITE_TAC[AND_IMP_INTRO] THEN 16814 DISCH_THEN(MP_TAC o MATCH_MP EQUIINTEGRABLE_UNION) THEN 16815 DISCH_THEN(MP_TAC o SPEC ``f:real->real`` o 16816 MATCH_MP (REWRITE_RULE[IMP_CONJ] 16817 EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_GE)) THEN 16818 ASM_SIMP_TAC std_ss [IN_UNION, IN_SING] THEN 16819 KNOW_TAC ``(!(h :real -> real) (x :real). 16820 (h = (f :real -> real)) \/ 16821 h IN {(\(x :real). if x <= c then h x else (0 :real)) | 16822 c IN univ((:real) :real itself) /\ 16823 ((h = f) \/ 16824 h IN {(\(x :real). 16825 if !(i :num). (1 :num) <= i /\ i <= (n :num) ==> c <= x /\ x <= d 16826 then f x 16827 else (0 :real)) | 16828 c IN univ((:real) :real itself) /\ 16829 d IN univ((:real) :real itself)})} ==> 16830 x IN interval [((a :real),(b :real))] ==> 16831 abs (h x) <= abs (f x))`` THENL 16832 [REWRITE_TAC[TAUT 16833 `a \/ b ==> c ==> d <=> (a ==> c ==> d) /\ (b ==> c ==> d)`] THEN 16834 SIMP_TAC std_ss [REAL_LE_REFL, RIGHT_FORALL_IMP_THM] THEN 16835 SIMP_TAC std_ss [FORALL_IN_GSPEC, LEFT_AND_OVER_OR] THEN 16836 REWRITE_TAC[TAUT `a \/ b ==> c <=> (a ==> c) /\ (b ==> c)`] THEN 16837 SIMP_TAC std_ss [REAL_LE_REFL, RIGHT_FORALL_IMP_THM] THEN 16838 SIMP_TAC std_ss [IMP_CONJ, RIGHT_FORALL_IMP_THM, FORALL_IN_GSPEC, 16839 FORALL_AND_THM] THEN 16840 SIMP_TAC std_ss [IN_UNIV] THEN 16841 REPEAT STRIP_TAC THEN 16842 REPEAT(COND_CASES_TAC THEN 16843 ASM_SIMP_TAC std_ss [ABS_0, REAL_LE_REFL, ABS_POS]), 16844 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 16845 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM EQUIINTEGRABLE_ON_SING]) THEN 16846 REWRITE_TAC[AND_IMP_INTRO] THEN 16847 DISCH_THEN(MP_TAC o MATCH_MP EQUIINTEGRABLE_UNION) THEN 16848 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 16849 MATCH_MP_TAC(SET_RULE 16850 ``s SUBSET t ==> (x INSERT s) SUBSET ({x} UNION t)``) THEN 16851 SIMP_TAC std_ss [SUBSET_DEF, real_gt, FORALL_IN_GSPEC, IN_UNIV, EXISTS_PROD] THEN 16852 MAP_EVERY X_GEN_TAC [``c:real``, ``d:real``] THEN 16853 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 16854 EXISTS_TAC ``(c:real)`` THEN ONCE_REWRITE_TAC [CONJ_SYM] THEN 16855 KNOW_TAC ``?(p_2 :real -> real). 16856 ((p_2 = (f :real -> real)) \/ 16857 ?(p_1 :real) (p_2' :real -> real). 16858 (\p_1 p_2'. (p_2' = f) \/ 16859 ?(p_1 :real) (p_2 :real). 16860 p_2' = 16861 (\(x :real). 16862 if 16863 !(i :num). 16864 (1 :num) <= i /\ i <= (n :num) ==> p_1 <= x /\ x <= p_2 16865 then 16866 f x 16867 else (0 :real))) p_1 p_2' /\ 16868 (p_2 = (\p_1 p_2'. (\(x :real). if x <= p_1 then p_2' x else (0 :real))) p_1 p_2')) /\ 16869 (\p_2. ((\(x :real). 16870 if 16871 !(i :num). 16872 (1 :num) <= i /\ i <= SUC n ==> (c :real) <= x /\ x <= (d :real) 16873 then 16874 f x 16875 else (0 :real)) = 16876 (\(x :real). if x >= c then p_2 x else (0 :real)))) p_2`` THENL 16877 [ALL_TAC, SIMP_TAC std_ss [CONJ_SYM]] THEN 16878 MATCH_MP_TAC(METIS[] 16879 ``(?c k. P c k /\ Q (g c k)) 16880 ==> ?h. ((h = f) \/ ?c k. P c k /\ (h = g c k)) /\ Q h``) THEN 16881 EXISTS_TAC ``(d:real)`` THEN 16882 EXISTS_TAC 16883 ``\x. if !i. 1 <= i /\ i <= n:num ==> (c:real) <= x /\ x <= (d:real) 16884 then (f:real->real) x else 0`` THEN 16885 SIMP_TAC std_ss [] THEN CONJ_TAC THENL 16886 [DISJ2_TAC THEN 16887 MAP_EVERY EXISTS_TAC [``c:real``, ``d:real``] THEN SIMP_TAC std_ss [], 16888 SIMP_TAC std_ss [FUN_EQ_THM, LE, real_ge] THEN 16889 METIS_TAC[ARITH_PROVE ``1 <= SUC n``]], 16890 DISCH_THEN(MP_TAC o SPEC ``1:num``) THEN 16891 SIMP_TAC std_ss [IN_INTERVAL, LESS_EQ_REFL] THEN 16892 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 16893 SIMP_TAC std_ss [IN_INSERT, SUBSET_DEF, GSPECIFICATION, EXISTS_PROD] THEN 16894 REPEAT STRIP_TAC THEN ASM_CASES_TAC ``x = f:real->real`` THEN 16895 ASM_SIMP_TAC std_ss [] THEN EXISTS_TAC ``p_1:real`` THEN 16896 EXISTS_TAC ``p_2:real`` THEN ASM_SIMP_TAC std_ss [FUN_EQ_THM] THEN 16897 X_GEN_TAC ``y:real`` THEN COND_CASES_TAC THEN ASM_SIMP_TAC arith_ss []]); 16898 16899(* ------------------------------------------------------------------------- *) 16900(* Continuity of the indefinite integral. *) 16901(* ------------------------------------------------------------------------- *) 16902 16903val INDEFINITE_INTEGRAL_CONTINUOUS = store_thm ("INDEFINITE_INTEGRAL_CONTINUOUS", 16904 ``!f:real->real a b c d e. 16905 f integrable_on interval[a,b] /\ 16906 c IN interval[a,b] /\ d IN interval[a,b] /\ &0 < e 16907 ==> ?k. &0 < k /\ 16908 !c' d'. c' IN interval[a,b] /\ 16909 d' IN interval[a,b] /\ 16910 abs(c' - c) <= k /\ abs(d' - d) <= k 16911 ==> abs(integral(interval[c',d']) f - 16912 integral(interval[c,d]) f) < e``, 16913 REPEAT STRIP_TAC THEN 16914 KNOW_TAC ``~(!(k :real). 16915 (0 :real) < k ==> 16916 ~(!(c' :real) (d' :real). 16917 c' IN interval [((a :real),(b :real))] /\ d' IN interval [(a,b)] /\ 16918 abs (c' - (c :real)) <= k /\ abs (d' - (d :real)) <= k ==> 16919 abs 16920 (integral (interval [(c',d')]) (f :real -> real) - 16921 integral (interval [(c,d)]) f) < (e :real)))`` THENL 16922 [ALL_TAC, METIS_TAC []] THEN 16923 DISCH_THEN(MP_TAC o GEN ``n:num`` o SPEC ``inv(&n + &1:real)``) THEN 16924 DISCH_THEN (MP_TAC o SIMP_RULE std_ss [NOT_FORALL_THM, NOT_IMP]) THEN 16925 REWRITE_TAC [REAL_LT_INV_EQ, METIS [REAL_LT, REAL_OF_NUM_ADD, GSYM ADD1, LESS_0] 16926 ``&0 < &n + &1:real``] THEN 16927 KNOW_TAC ``!c' d'. 16928 ~(!n:num. (c' n IN interval [a,b] /\ 16929 d' n IN interval [a,b] /\ 16930 abs (c' n - c) <= inv (&n + &1) /\ 16931 abs (d' n - d) <= inv (&n + &1)) /\ 16932 ~(abs (integral (interval [c' n,d' n]) f - 16933 integral (interval [c,d]) f) < e:real))`` THENL 16934 [ALL_TAC, METIS_TAC [SKOLEM_THM]] THEN 16935 REWRITE_TAC [REAL_NOT_LT, GSYM CONJ_ASSOC] THEN 16936 MAP_EVERY X_GEN_TAC [``u:num->real``, ``v:num->real``] THEN 16937 DISCH_THEN (MP_TAC o SIMP_RULE std_ss [FORALL_AND_THM]) THEN 16938 STRIP_TAC THEN 16939 ABBREV_TAC 16940 ``k:real->bool = 16941 BIGUNION (IMAGE (\i. {x | x = (c:real)} UNION {x | x = (d:real)}) 16942 ((1:num)..(1:num)))`` THEN 16943 SUBGOAL_THEN ``negligible(k:real->bool)`` ASSUME_TAC THENL 16944 [EXPAND_TAC "k" THEN MATCH_MP_TAC NEGLIGIBLE_BIGUNION THEN 16945 SIMP_TAC std_ss [IMAGE_FINITE, FINITE_NUMSEG, FORALL_IN_IMAGE] THEN 16946 X_GEN_TAC ``i:num`` THEN REWRITE_TAC[IN_NUMSEG] THEN STRIP_TAC THEN 16947 ASM_SIMP_TAC std_ss [NEGLIGIBLE_UNION, NEGLIGIBLE_STANDARD_HYPERPLANE], 16948 ALL_TAC] THEN 16949 MP_TAC(ISPECL 16950 [``\n:num x. if x IN interval[u n,v n] then 16951 if x IN k then 0 else (f:real->real) x 16952 else 0``, 16953 ``\x. if x IN interval[c,d] then 16954 if x IN k then 0 else (f:real->real) x 16955 else 0``, 16956 ``a:real``, ``b:real``] EQUIINTEGRABLE_LIMIT) THEN 16957 SIMP_TAC std_ss [NOT_IMP] THEN REPEAT CONJ_TAC THENL 16958 [SUBGOAL_THEN 16959 ``(\x. if x IN k then 0 else (f:real->real) x) 16960 integrable_on interval[a,b]`` 16961 MP_TAC THENL 16962 [UNDISCH_TAC ``(f:real->real) integrable_on interval[a,b]`` THEN 16963 MATCH_MP_TAC INTEGRABLE_SPIKE THEN EXISTS_TAC ``k:real->bool`` THEN 16964 ASM_REWRITE_TAC[] THEN SET_TAC[], 16965 ALL_TAC] THEN 16966 DISCH_THEN(MP_TAC o MATCH_MP 16967 EQUIINTEGRABLE_CLOSED_INTERVAL_RESTRICTIONS) THEN 16968 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 16969 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC, IN_UNIV] THEN 16970 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 16971 X_GEN_TAC ``n:num`` THEN MAP_EVERY EXISTS_TAC 16972 [``(u:num->real) n``, ``(v:num->real) n``] THEN 16973 SIMP_TAC std_ss [], 16974 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN 16975 ASM_CASES_TAC ``(x:real) IN k`` THEN 16976 ASM_SIMP_TAC std_ss [COND_ID, LIM_CONST] THEN MATCH_MP_TAC LIM_EVENTUALLY THEN 16977 SIMP_TAC std_ss [EVENTUALLY_SEQUENTIALLY] THEN 16978 MP_TAC(SPEC ``inf (IMAGE (\i. min (abs((x:real) - (c:real))) 16979 (abs((x:real) - (d:real)))) 16980 ((1:num)..(1:num)))`` REAL_ARCH_INV) THEN 16981 SIMP_TAC std_ss [REAL_LT_INF_FINITE, IMAGE_FINITE, IMAGE_EQ_EMPTY, 16982 FINITE_NUMSEG, NUMSEG_EMPTY, NOT_LESS] THEN 16983 ASM_SIMP_TAC std_ss [FORALL_IN_IMAGE, REAL_LT_MIN, IN_NUMSEG] THEN 16984 UNDISCH_TAC ``~((x:real) IN k)`` THEN EXPAND_TAC "k" THEN 16985 SIMP_TAC std_ss [BIGUNION_IMAGE, GSPECIFICATION, NOT_EXISTS_THM] THEN 16986 REWRITE_TAC[IN_NUMSEG, SET_RULE 16987 ``~p \/ x NOTIN (s UNION t) <=> p ==> ~(x IN s) /\ ~(x IN t)``] THEN 16988 SIMP_TAC std_ss [GSPECIFICATION, REAL_ARITH ``&0 < abs(x - y) <=> ~(x = y:real)``] THEN 16989 DISCH_TAC THEN ASM_REWRITE_TAC[] THEN 16990 DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN EXISTS_TAC ``N:num`` THEN 16991 POP_ASSUM MP_TAC THEN STRIP_TAC THEN 16992 X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 16993 SUBGOAL_THEN ``x IN interval[(u:num->real) n,v n] <=> x IN interval[c,d]`` 16994 (fn th => SIMP_TAC std_ss [th]) THEN 16995 REWRITE_TAC[IN_INTERVAL] THEN 16996 POP_ASSUM MP_TAC THEN POP_ASSUM (MP_TAC o SPEC ``1:num``) THEN 16997 SIMP_TAC arith_ss [] THEN REPEAT STRIP_TAC THEN 16998 MATCH_MP_TAC(REAL_ARITH 16999 ``!N n. abs(u - c) <= n /\ abs(v - d) <= n /\ 17000 N < abs(x - c) /\ N < abs(x - d) /\ n <= N 17001 ==> (u <= x /\ x <= v <=> c <= x /\ x <= d:real)``) THEN 17002 MAP_EVERY EXISTS_TAC [``inv(&N:real)``, ``inv(&n + &1:real)``] THEN 17003 ASM_SIMP_TAC std_ss [] THEN 17004 MATCH_MP_TAC REAL_LE_INV2 THEN 17005 REWRITE_TAC[REAL_OF_NUM_ADD, REAL_OF_NUM_LE, REAL_LT] THEN 17006 ASM_SIMP_TAC arith_ss [], 17007 CCONTR_TAC THEN FULL_SIMP_TAC std_ss [] THEN POP_ASSUM MP_TAC THEN 17008 SIMP_TAC std_ss [INTEGRAL_RESTRICT_INTER] THEN 17009 SUBGOAL_THEN 17010 ``(interval[c:real,d] INTER interval[a,b] = interval[c,d]) /\ 17011 !n:num. interval[u n,v n] INTER interval[a,b] = interval[u n,v n]`` 17012 (fn th => SIMP_TAC std_ss [th]) 17013 THENL 17014 [REWRITE_TAC[SET_RULE ``(s INTER t = s) <=> s SUBSET t``] THEN 17015 REWRITE_TAC[SUBSET_INTERVAL] THEN 17016 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_MESON_TAC[], 17017 ALL_TAC] THEN 17018 REWRITE_TAC[LIM_SEQUENTIALLY] THEN 17019 DISCH_THEN(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 17020 DISCH_THEN(X_CHOOSE_THEN ``N:num`` (MP_TAC o SPEC ``N:num``)) THEN 17021 REWRITE_TAC[LESS_EQ_REFL, REAL_NOT_LT] THEN REWRITE_TAC [dist] THEN 17022 FIRST_ASSUM(fn th => MP_TAC(SPEC ``N:num`` th) THEN MATCH_MP_TAC 17023 (REAL_ARITH ``(x = a) /\ (y = b) ==> e <= abs(x - y) ==> e <= abs(a - b:real)``)) THEN 17024 CONJ_TAC THEN SIMP_TAC std_ss [] THEN MATCH_MP_TAC INTEGRAL_SPIKE THEN 17025 EXISTS_TAC ``k:real->bool`` THEN ASM_SIMP_TAC std_ss [IN_DIFF]]);; 17026 17027val INDEFINITE_INTEGRAL_CONTINUOUS_RIGHT = store_thm ("INDEFINITE_INTEGRAL_CONTINUOUS_RIGHT", 17028 ``!f:real->real a b. 17029 f integrable_on interval[a,b] 17030 ==> (\x. integral (interval[a,x]) f) continuous_on interval[a,b]``, 17031 REPEAT STRIP_TAC THEN REWRITE_TAC[CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN] THEN 17032 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN REWRITE_TAC[continuous_within] THEN 17033 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 17034 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, 17035 ``a:real``, ``x:real``, ``e:real``] 17036 INDEFINITE_INTEGRAL_CONTINUOUS) THEN 17037 ASM_SIMP_TAC std_ss [ENDS_IN_INTERVAL] THEN 17038 KNOW_TAC ``interval [(a,b:real)] <> {}`` THENL 17039 [ASM_SET_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 17040 POP_ASSUM K_TAC THEN REWRITE_TAC[dist]] THEN 17041 DISCH_THEN (X_CHOOSE_TAC ``d:real``) THEN EXISTS_TAC ``d:real`` THEN 17042 POP_ASSUM MP_TAC THEN REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 17043 FIRST_X_ASSUM MATCH_MP_TAC THEN 17044 ASM_SIMP_TAC std_ss [ENDS_IN_INTERVAL, REAL_SUB_REFL, ABS_0, REAL_LT_IMP_LE] THEN 17045 ASM_SET_TAC[]); 17046 17047val INDEFINITE_INTEGRAL_CONTINUOUS_LEFT = store_thm ("INDEFINITE_INTEGRAL_CONTINUOUS_LEFT", 17048 ``!f:real->real a b. 17049 f integrable_on interval[a,b] 17050 ==> (\x. integral(interval[x,b]) f) continuous_on interval[a,b]``, 17051 REPEAT STRIP_TAC THEN REWRITE_TAC[CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN] THEN 17052 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN REWRITE_TAC[continuous_within] THEN 17053 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 17054 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, 17055 ``x:real``, ``b:real``, ``e:real``] 17056 INDEFINITE_INTEGRAL_CONTINUOUS) THEN 17057 ASM_SIMP_TAC std_ss [ENDS_IN_INTERVAL] THEN 17058 KNOW_TAC ``interval [(a,b:real)] <> {}`` THENL 17059 [ASM_SET_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 17060 POP_ASSUM K_TAC THEN REWRITE_TAC[dist]] THEN 17061 DISCH_THEN (X_CHOOSE_TAC ``d:real``) THEN EXISTS_TAC ``d:real`` THEN 17062 POP_ASSUM MP_TAC THEN REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 17063 FIRST_X_ASSUM MATCH_MP_TAC THEN 17064 ASM_SIMP_TAC std_ss [ENDS_IN_INTERVAL, REAL_SUB_REFL, ABS_0, REAL_LT_IMP_LE] THEN 17065 ASM_SET_TAC[]); 17066 17067(* ------------------------------------------------------------------------- *) 17068(* Second mean value theorem and corollaries. *) 17069(* ------------------------------------------------------------------------- *) 17070 17071val lemma1 = prove ( 17072 ``!f:real->real s. 17073 (!x. x IN s ==> &0 <= f x /\ f x <= &1) 17074 ==> (!n x. x IN s /\ ~(n = 0) 17075 ==> abs(f x - 17076 sum((1:num)..n) (\k. if &k / &n <= f(x) 17077 then inv(&n) else &0)) < inv(&n))``, 17078 REPEAT STRIP_TAC THEN 17079 SUBGOAL_THEN ``?m. flr(&n * (f:real->real) x) = &m`` CHOOSE_TAC THENL 17080 [MATCH_MP_TAC FLOOR_POS THEN ASM_SIMP_TAC std_ss [REAL_LE_MUL, REAL_POS], 17081 ALL_TAC] THEN 17082 SUBGOAL_THEN ``!k. &k / &n <= (f:real->real) x <=> k <= m`` ASSUME_TAC THENL 17083 [FIRST_X_ASSUM(SUBST1_TAC o SYM) THEN 17084 KNOW_TAC ``0 <= &n * (f:real->real) x`` THENL 17085 [MATCH_MP_TAC REAL_LE_MUL THEN ASM_SIMP_TAC std_ss [REAL_POS], 17086 DISCH_TAC] THEN 17087 ASM_SIMP_TAC std_ss [NUM_FLOOR_LE2] THEN 17088 REWRITE_TAC[GSYM REAL_OF_NUM_LE] THEN 17089 ASM_SIMP_TAC std_ss [REAL_LE_LDIV_EQ, REAL_LT, LE_1] THEN 17090 SIMP_TAC std_ss [REAL_MUL_SYM], 17091 ALL_TAC] THEN 17092 ASM_REWRITE_TAC [] THEN 17093 ONCE_REWRITE_TAC [METIS [] 17094 ``sum (1 .. n) (\k. if k <= m then inv (&n) else 0) = 17095 sum (1 .. n) (\k. if (\k. k <= m) k then (\k. inv (&n)) k else 0)``] THEN 17096 ASM_REWRITE_TAC[GSYM SUM_RESTRICT_SET] THEN SIMP_TAC std_ss [] THEN 17097 FIRST_X_ASSUM(MP_TAC o SPEC ``n + 1:num``) THEN 17098 REWRITE_TAC [GSYM REAL_OF_NUM_ADD, real_div, REAL_ADD_RDISTRIB] THEN 17099 ASM_SIMP_TAC real_ss [REAL_MUL_RINV, REAL_MUL_LID, REAL_OF_NUM_EQ] THEN 17100 ASM_SIMP_TAC real_ss [REAL_ARITH ``y <= &1 /\ &0 < i ==> ~(&1 + i <= y:real)``, 17101 REAL_LT_INV_EQ, REAL_LT, LE_1, NOT_LESS_EQUAL] THEN 17102 SIMP_TAC arith_ss [IN_NUMSEG, ARITH_PROVE 17103 ``m < n + 1 ==> ((1 <= k /\ k <= n) /\ k <= m <=> 1 <= k /\ k <= m:num)``] THEN 17104 DISCH_TAC THEN REWRITE_TAC[GSYM numseg, SUM_CONST_NUMSEG, ADD_SUB] THEN 17105 MATCH_MP_TAC REAL_LT_LCANCEL_IMP THEN EXISTS_TAC ``abs(&n:real)`` THEN 17106 REWRITE_TAC[GSYM ABS_MUL] THEN 17107 ASM_SIMP_TAC real_ss [ABS_N, REAL_MUL_RINV, REAL_OF_NUM_EQ] THEN 17108 ASM_SIMP_TAC std_ss [REAL_LT, LE_1, REAL_SUB_LDISTRIB, GSYM real_div] THEN 17109 ASM_SIMP_TAC real_ss [REAL_DIV_LMUL, REAL_OF_NUM_EQ] THEN 17110 MATCH_MP_TAC(REAL_ARITH ``f <= x /\ x < f + &1 ==> abs(x - f) < &1:real``) THEN 17111 FIRST_X_ASSUM(SUBST1_TAC o SYM) THEN CONJ_TAC THENL 17112 [MATCH_MP_TAC NUM_FLOOR_LE THEN MATCH_MP_TAC REAL_LE_MUL THEN 17113 ASM_SIMP_TAC std_ss [REAL_POS], 17114 REWRITE_TAC [GSYM NUM_FLOOR_LET] THEN SIMP_TAC std_ss [REAL_LE_REFL]]); 17115 17116val lemma2 = prove ( 17117 ``!f:real->real g a b. 17118 f integrable_on interval[a,b] /\ 17119 (!x y. x <= y ==> g(x) <= g(y)) 17120 ==> {(\x. if c <= g(x) then f x else 0) | c IN univ(:real)} 17121 equiintegrable_on interval[a,b]``, 17122 REPEAT STRIP_TAC THEN 17123 UNDISCH_TAC ``f integrable_on interval [(a,b)]`` THEN DISCH_TAC THEN 17124 FIRST_ASSUM(MP_TAC o REWRITE_RULE [GSYM EQUIINTEGRABLE_ON_SING]) THEN 17125 DISCH_THEN(fn th => 17126 MP_TAC(SPEC ``f:real->real`` (MATCH_MP (REWRITE_RULE[IMP_CONJ] 17127 EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_GE) th)) THEN 17128 MP_TAC(SPEC ``f:real->real`` (MATCH_MP (REWRITE_RULE[IMP_CONJ] 17129 EQUIINTEGRABLE_HALFSPACE_RESTRICTIONS_GT) th)) THEN 17130 MP_TAC th) THEN 17131 SIMP_TAC std_ss [IN_SING, REAL_LE_REFL] THEN 17132 SUBGOAL_THEN ``{(\x. 0):real->real} equiintegrable_on interval[a,b]`` 17133 MP_TAC THENL 17134 [REWRITE_TAC[EQUIINTEGRABLE_ON_SING, INTEGRABLE_CONST], ALL_TAC] THEN 17135 REPEAT(ONCE_REWRITE_TAC[AND_IMP_INTRO] THEN 17136 DISCH_THEN(MP_TAC o MATCH_MP EQUIINTEGRABLE_UNION)) THEN 17137 SIMP_TAC std_ss [NUMSEG_SING, IN_SING] THEN 17138 REWRITE_TAC[SET_RULE `` 17139 {(\x. if x > c then h x else 0) | c IN univ(:real) /\ (h = f)} = 17140 {(\x. if x > c then (f:real->real) x else 0) | c IN univ(:real)}``] THEN 17141 REWRITE_TAC[SET_RULE `` 17142 {(\x. if x >= c then h x else 0) | c IN univ(:real) /\ (h = f)} = 17143 {(\x. if x >= c then (f:real->real) x else 0) | c IN univ(:real)}``] THEN 17144 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 17145 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC, IN_UNIV] THEN 17146 X_GEN_TAC ``y:real`` THEN 17147 ASM_CASES_TAC ``!x. y <= (g:real->real) x`` THENL 17148 [ASM_SIMP_TAC std_ss [ETA_AX, IN_UNION, IN_SING], ALL_TAC] THEN 17149 ASM_CASES_TAC ``!x. ~(y <= (g:real->real) x)`` THENL 17150 [ASM_SIMP_TAC std_ss [ETA_AX, IN_UNION, IN_SING], ALL_TAC] THEN 17151 MP_TAC (ISPEC ``IMAGE (\x. x) {x | y <= (g:real->real) x}`` INF) THEN 17152 SIMP_TAC std_ss [FORALL_IN_IMAGE, GSPECIFICATION, IMAGE_EQ_EMPTY] THEN 17153 KNOW_TAC ``({x | y <= (g:real->real) x} <> {}) /\ 17154 (?b. !x. y <= (g:real->real) x ==> b <= x)`` THENL 17155 [ASM_SIMP_TAC std_ss [EXTENSION, GSPECIFICATION, NOT_IN_EMPTY] THEN 17156 METIS_TAC[REAL_LE_TRANS, REAL_LE_TOTAL], 17157 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 17158 STRIP_TAC THEN REWRITE_TAC[real_gt, real_ge]] THEN 17159 REWRITE_TAC[IN_UNION, GSYM DISJ_ASSOC] THEN 17160 ASM_CASES_TAC ``y <= g((inf(IMAGE (\x. x) {x | y <= (g:real->real) x})))`` THENL 17161 [REPEAT DISJ2_TAC, DISJ2_TAC THEN DISJ2_TAC THEN DISJ1_TAC] THEN 17162 SIMP_TAC std_ss [GSPECIFICATION] THEN 17163 EXISTS_TAC ``inf(IMAGE (\x. x) {x | y <= (g:real->real) x})`` THEN 17164 SIMP_TAC std_ss [FUN_EQ_THM] THEN 17165 ONCE_REWRITE_TAC [METIS [] ``y <= g x <=> (\x. y <= (g:real->real) x) x``] THEN 17166 ONCE_REWRITE_TAC [METIS [] 17167 ``inf (IMAGE (\x. x) {x | (\x. y <= (g:real->real) x) x}) <= x <=> 17168 (\x. inf (IMAGE (\x. x) {x | (\x. y <= g x) x}) <= x) x``] THEN 17169 MATCH_MP_TAC(METIS [] 17170 ``(!x. P x <=> Q x) 17171 ==> !x. (if P x then f x else b) = (if Q x then f x else b)``) THEN 17172 X_GEN_TAC ``x:real`` THEN SIMP_TAC std_ss [GSYM REAL_NOT_LE] THEN 17173 METIS_TAC [REAL_LE_TOTAL, REAL_LT_ANTISYM, REAL_LE_TRANS]); 17174 17175val lemma3 = prove ( 17176 ``!f:real->real g:real->real a b. 17177 f integrable_on interval[a,b] /\ 17178 (!x y. x <= y ==> g(x) <= g(y)) 17179 ==> {(\x. sum ((1:num)..n) 17180 (\k. if &k / &n <= g x then inv(&n) * f(x) else 0)) | 17181 ~(n = 0)} 17182 equiintegrable_on interval[a,b]``, 17183 REPEAT GEN_TAC THEN DISCH_THEN(MP_TAC o 17184 MATCH_MP lemma2) THEN 17185 DISCH_THEN(MP_TAC o MATCH_MP 17186 (INST_TYPE [alpha |-> ``:num``] (EQUIINTEGRABLE_SUM))) THEN 17187 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] EQUIINTEGRABLE_SUBSET) THEN 17188 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC, IN_UNIV] THEN X_GEN_TAC ``n:num`` THEN 17189 DISCH_TAC THEN SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 17190 MAP_EVERY EXISTS_TAC [``((1:num)..n)``, ``(\k:num. inv(&n:real))``, 17191 ``(\k x. if &k / &n <= (g:real->real) x then (f:real->real) x else 0)``] THEN 17192 ASM_SIMP_TAC real_ss [SUM_CONST_NUMSEG, ADD_SUB, REAL_MUL_RINV, REAL_OF_NUM_EQ] THEN 17193 SIMP_TAC std_ss [FINITE_NUMSEG, COND_RAND, COND_RATOR, REAL_MUL_RZERO] THEN 17194 X_GEN_TAC ``k:num`` THEN 17195 REWRITE_TAC[IN_NUMSEG, REAL_LE_INV_EQ, REAL_POS] THEN STRIP_TAC THEN 17196 EXISTS_TAC ``&k / &n:real`` THEN SIMP_TAC std_ss []); 17197 17198val lemma4 = prove ( 17199 ``!f:real->real g:real->real a b. 17200 ~(interval[a,b] = {}) /\ 17201 f integrable_on interval[a,b] /\ 17202 (!x y. x <= y ==> g(x) <= g(y)) /\ 17203 (!x. x IN interval[a,b] ==> &0 <= g x /\ g x <= &1) 17204 ==> (\x. g(x) * f(x)) integrable_on interval[a,b] /\ 17205 ?c. c IN interval[a,b] /\ 17206 (integral (interval[a,b]) (\x. g(x) * f(x)) = 17207 integral (interval[c,b]) f)``, 17208 REPEAT GEN_TAC THEN STRIP_TAC THEN 17209 SUBGOAL_THEN 17210 ``?m M. IMAGE (\x. integral (interval[x,b]) (f:real->real)) 17211 (interval[a,b]) = interval[m,M]`` 17212 STRIP_ASSUME_TAC THENL 17213 [REWRITE_TAC[GSYM CONNECTED_COMPACT_INTERVAL_1] THEN CONJ_TAC THENL 17214 [MATCH_MP_TAC CONNECTED_CONTINUOUS_IMAGE, 17215 MATCH_MP_TAC COMPACT_CONTINUOUS_IMAGE] THEN 17216 ASM_SIMP_TAC std_ss [INDEFINITE_INTEGRAL_CONTINUOUS_LEFT, CONVEX_CONNECTED, 17217 CONVEX_INTERVAL, COMPACT_INTERVAL], 17218 ALL_TAC] THEN 17219 MP_TAC(ISPECL[``f:real->real``, ``g:real->real``, ``a:real``, ``b:real``] 17220 lemma3) THEN 17221 ASM_SIMP_TAC std_ss [] THEN DISCH_TAC THEN 17222 SUBGOAL_THEN 17223 ``!n. ?c. c IN interval[a,b] /\ 17224 (integral (interval[c,b]) (f:real->real) = 17225 integral (interval[a,b]) 17226 (\x. sum ((1:num)..n) 17227 (\k. if &k / &n <= (g:real->real) x then inv(&n) * f x else 0)))`` 17228 MP_TAC THENL 17229 [ (* goal 1 (of 2) *) 17230 X_GEN_TAC ``n:num`` THEN ASM_CASES_TAC ``n = 0:num`` THENL 17231 [ASM_SIMP_TAC arith_ss [SUM_CLAUSES_NUMSEG, INTEGRAL_0] THEN 17232 EXISTS_TAC ``b:real`` THEN ASM_SIMP_TAC std_ss [ENDS_IN_INTERVAL] THEN 17233 SIMP_TAC std_ss [INTEGRAL_NULL, CONTENT_EQ_0, REAL_LE_REFL], 17234 ALL_TAC] THEN 17235 MP_TAC(ISPECL [``f:real->real``, ``g:real->real``, 17236 ``a:real``, ``b:real``] lemma2) THEN 17237 ASM_SIMP_TAC std_ss [equiintegrable_on, FORALL_IN_GSPEC, IN_UNIV] THEN 17238 DISCH_THEN(ASSUME_TAC o CONJUNCT1) THEN 17239 REWRITE_TAC[METIS [REAL_MUL_RZERO] 17240 ``(if p then a * x else 0:real) = 17241 a * (if p then x else 0)``] THEN 17242 ASM_SIMP_TAC std_ss [SUM_LMUL, INTEGRAL_CMUL, INTEGRABLE_SUM, ETA_AX, 17243 FINITE_NUMSEG, INTEGRAL_SUM] THEN 17244 SUBGOAL_THEN 17245 ``!y:real. ?d:real. 17246 d IN interval[a,b] /\ 17247 (integral (interval[a,b]) (\x. if y <= (g:real->real) x then f x else 0) = 17248 integral (interval[d,b]) (f:real->real))`` 17249 MP_TAC THENL 17250 [ (* goal 1.1 (of 2) *) 17251 X_GEN_TAC ``y:real`` THEN 17252 SUBGOAL_THEN 17253 ``({x | y <= (g:real->real) x} = {}) \/ 17254 ({x | y <= (g:real->real) x} = univ(:real)) \/ 17255 (?a. {x | y <= (g:real->real) x} = {x | a <= x}) \/ 17256 (?a. {x | y <= (g:real->real) x} = {x | a < x})`` 17257 MP_TAC THENL 17258 [ (* goal 1.1.1 (of 2) *) 17259 MATCH_MP_TAC(TAUT `(~a /\ ~b ==> c \/ d) ==> a \/ b \/ c \/ d`) THEN 17260 DISCH_TAC THEN 17261 MP_TAC(ISPEC ``IMAGE (\x. x) {x | y <= (g:real->real) x}`` INF) THEN 17262 ASM_SIMP_TAC real_ss [FORALL_IN_IMAGE, GSPECIFICATION, IMAGE_EQ_EMPTY] THEN 17263 KNOW_TAC ``(?b'. !x. y <= (g:real->real) x ==> b' <= x)`` THENL 17264 [FIRST_ASSUM(MP_TAC o CONJUNCT2) THEN 17265 SIMP_TAC std_ss [EXTENSION, GSPECIFICATION, IN_UNIV, NOT_IN_EMPTY] THEN 17266 METIS_TAC[REAL_LE_TRANS, REAL_LE_TOTAL], 17267 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 17268 STRIP_TAC] THEN 17269 ASM_CASES_TAC ``y <= (g:real->real)((inf(IMAGE (\x. x) {x | y <= g x})))`` THENL 17270 [DISJ1_TAC, DISJ2_TAC] THEN 17271 SIMP_TAC std_ss [EXTENSION, GSPECIFICATION] THEN 17272 EXISTS_TAC ``inf(IMAGE (\x. x) {x | y <= (g:real->real) x})`` THEN 17273 SIMP_TAC std_ss [FUN_EQ_THM] THEN 17274 X_GEN_TAC ``x:real`` THEN 17275 REWRITE_TAC[GSYM REAL_NOT_LE] THEN 17276 METIS_TAC[REAL_LE_TOTAL, REAL_LT_ANTISYM, REAL_LE_TRANS], 17277 (* goal 1.1.2 (of 2) *) 17278 SIMP_TAC std_ss [EXTENSION, IN_UNIV, NOT_IN_EMPTY, GSPECIFICATION] THEN 17279 DISCH_THEN(DISJ_CASES_THEN2 ASSUME_TAC MP_TAC) THENL 17280 [EXISTS_TAC ``b:real`` THEN ASM_REWRITE_TAC[] THEN 17281 SIMP_TAC std_ss [INTEGRAL_NULL, CONTENT_EQ_0, REAL_LE_REFL] THEN 17282 ASM_SIMP_TAC std_ss [ENDS_IN_INTERVAL, INTEGRAL_0], 17283 ALL_TAC] THEN 17284 DISCH_THEN(DISJ_CASES_THEN2 ASSUME_TAC MP_TAC) THENL 17285 [EXISTS_TAC ``a:real`` THEN 17286 ASM_SIMP_TAC std_ss [ETA_AX, ENDS_IN_INTERVAL], 17287 ALL_TAC] THEN 17288 SIMP_TAC std_ss [METIS [OR_EXISTS_THM] 17289 ``(?(a :real). (!(x :real). (y :real) <= (g :real -> real) x <=> a <= x)) \/ 17290 (?(a :real). !(x :real). y <= g x <=> a < x) <=> 17291 ?a. ((\a. !x. y <= (g:real->real) x <=> a <= x) a \/ 17292 (\a. !x. y <= (g:real->real) x <=> a < x) a)``] THEN 17293 DISCH_THEN(X_CHOOSE_THEN ``d:real`` ASSUME_TAC) THEN 17294 ASM_CASES_TAC ``d < a:real`` THENL 17295 [EXISTS_TAC ``a:real`` THEN 17296 ASM_SIMP_TAC std_ss [ETA_AX, ENDS_IN_INTERVAL] THEN 17297 MATCH_MP_TAC INTEGRAL_EQ THEN 17298 SIMP_TAC std_ss [IN_DIFF, IN_INTERVAL, NOT_IN_EMPTY] THEN 17299 GEN_TAC THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN 17300 UNDISCH_TAC ``~(y <= (g:real->real) x)`` THEN 17301 FIRST_X_ASSUM DISJ_CASES_TAC THEN ASM_SIMP_TAC real_ss [] THEN 17302 UNDISCH_TAC ``d < a:real`` THEN REAL_ARITH_TAC, 17303 ALL_TAC] THEN 17304 ASM_CASES_TAC ``b < d:real`` THENL 17305 [EXISTS_TAC ``b:real`` THEN 17306 SIMP_TAC std_ss [INTEGRAL_NULL, CONTENT_EQ_0, REAL_LE_REFL] THEN 17307 ASM_SIMP_TAC std_ss [ENDS_IN_INTERVAL, INTEGRAL_0] THEN 17308 MATCH_MP_TAC INTEGRAL_EQ_0 THEN SIMP_TAC std_ss [IN_INTERVAL] THEN 17309 REPEAT STRIP_TAC THEN 17310 COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [] THEN 17311 UNDISCH_TAC ``y <= (g:real->real) x`` THEN 17312 FIRST_X_ASSUM DISJ_CASES_TAC THEN ASM_REWRITE_TAC[] THEN 17313 UNDISCH_TAC ``b < d:real`` THEN UNDISCH_TAC ``x <= b:real`` THEN 17314 REAL_ARITH_TAC, 17315 ALL_TAC] THEN 17316 EXISTS_TAC ``d:real`` THEN 17317 ASM_REWRITE_TAC[IN_INTERVAL, GSYM REAL_NOT_LT] THEN 17318 ONCE_REWRITE_TAC[SET_RULE 17319 ``~((g:real->real) x < y) <=> x IN {x | ~(g x < y)}``] THEN 17320 SIMP_TAC std_ss [INTEGRAL_RESTRICT_INTER] THEN 17321 MATCH_MP_TAC INTEGRAL_SPIKE_SET THEN 17322 MATCH_MP_TAC NEGLIGIBLE_SUBSET THEN EXISTS_TAC ``{d:real}`` THEN 17323 REWRITE_TAC[NEGLIGIBLE_SING, REAL_NOT_LT, SUBSET_DEF] THEN GEN_TAC THEN 17324 SIMP_TAC std_ss [SUBSET_DEF, IN_UNION, IN_INTER, IN_DIFF, IN_INTERVAL, 17325 GSPECIFICATION, IN_SING] THEN 17326 FIRST_X_ASSUM DISJ_CASES_TAC THEN ASM_REWRITE_TAC[] THEN 17327 UNDISCH_TAC ``~(d < a:real)`` THEN UNDISCH_TAC ``~(b < d:real)`` THEN 17328 REAL_ARITH_TAC ], 17329 (* goal 1.2 (of 2) *) 17330 DISCH_THEN(MP_TAC o GEN ``k:num`` o SPEC ``&k / &n:real``) THEN 17331 SIMP_TAC std_ss [SKOLEM_THM, FORALL_AND_THM, LEFT_IMP_EXISTS_THM] THEN 17332 X_GEN_TAC ``d:num->real`` THEN STRIP_TAC THEN 17333 FIRST_ASSUM(MP_TAC o MATCH_MP (SET_RULE 17334 ``(IMAGE f s = t) ==> !y. y IN t ==> ?x. x IN s /\ (f x = y)``)) THEN 17335 SIMP_TAC std_ss [GSYM SUM_LMUL] THEN DISCH_THEN MATCH_MP_TAC THEN 17336 ONCE_REWRITE_TAC [METIS [] 17337 ``(\k. inv (&n) * integral (interval [(d k,b)]) f) = 17338 (\k. (\k. inv (&n)) k * (\k. integral (interval [(d k,b)]) f) k)``] THEN 17339 MATCH_MP_TAC(REWRITE_RULE[CONVEX_INDEXED] 17340 (CONJUNCT1(SPEC_ALL CONVEX_INTERVAL))) THEN 17341 SIMP_TAC real_ss [SUM_CONST_NUMSEG, ADD_SUB, REAL_LE_INV_EQ, REAL_POS] THEN 17342 ASM_SIMP_TAC real_ss [REAL_MUL_RINV, REAL_OF_NUM_EQ] THEN ASM_SET_TAC[] ], 17343 (* goal 2 (of 2) *) 17344 SIMP_TAC std_ss [SKOLEM_THM, LEFT_IMP_EXISTS_THM, FORALL_AND_THM] THEN 17345 X_GEN_TAC ``c:num->real`` THEN DISCH_THEN(STRIP_ASSUME_TAC o GSYM) ] THEN 17346 (* stage work *) 17347 SUBGOAL_THEN ``compact(interval[a:real,b])`` MP_TAC THENL 17348 [REWRITE_TAC[COMPACT_INTERVAL], REWRITE_TAC[compact]] THEN 17349 DISCH_THEN(MP_TAC o SPEC ``c:num->real``) THEN 17350 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN MAP_EVERY X_GEN_TAC 17351 [``d:real``, ``s:num->num``] THEN STRIP_TAC THEN 17352 MP_TAC(ISPECL 17353 [``\n:num x. sum ((1:num)..(s n)) 17354 (\k. if &k / &((s:num->num) n):real <= (g:real->real) x 17355 then inv(&(s n)) * (f:real->real) x 17356 else 0)``, 17357 ``\x. (g:real->real) x * (f:real->real) x``, ``a:real``, ``b:real``] 17358 EQUIINTEGRABLE_LIMIT) THEN 17359 ASM_SIMP_TAC std_ss [] THEN 17360 KNOW_TAC ``{(\(x :real). 17361 sum ((1 :num) .. (s :num -> num) n) 17362 (\(k :num). 17363 if ((&k) :real) / ((&s n) :real) <= (g :real -> real) x then 17364 inv ((&s n) :real) * (f :real -> real) x 17365 else (0 :real))) | 17366 n IN univ((:num) :num itself)} equiintegrable_on 17367 interval [((a :real),(b :real))] /\ 17368 (!(x :real). x IN interval [(a,b)] ==> 17369 (((\(n :num). sum ((1 :num) .. s n) 17370 (\(k :num). 17371 if ((&k) :real) / ((&s n) :real) <= g x then 17372 inv ((&s n) :real) * f x 17373 else (0 :real))) --> (g x * f x)) sequentially :bool))`` THENL 17374 [CONJ_TAC THENL 17375 [MATCH_MP_TAC EQUIINTEGRABLE_SUBSET THEN 17376 EXISTS_TAC 17377 ``{\x. sum((1:num)..(0:num)) (\k. if &k / &0:real <= (g:real->real) x 17378 then inv(&0) * (f:real->real) x else 0)} 17379 UNION 17380 {\x. sum ((1:num)..(n:num)) 17381 (\k. if &k / &n <= g x then inv (&n) * f x else 0) 17382 | ~(n = 0)}`` THEN 17383 CONJ_TAC THENL 17384 [MATCH_MP_TAC EQUIINTEGRABLE_UNION THEN ASM_REWRITE_TAC[] THEN 17385 SIMP_TAC arith_ss [EQUIINTEGRABLE_ON_SING, SUM_CLAUSES_NUMSEG] THEN 17386 SIMP_TAC std_ss [INTEGRABLE_0], 17387 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_GSPEC, IN_UNIV, IN_UNION] THEN 17388 SIMP_TAC std_ss [GSPECIFICATION, IN_SING] THEN 17389 X_GEN_TAC ``n:num`` THEN ASM_CASES_TAC ``(s:num->num) n = 0`` THEN 17390 ASM_REWRITE_TAC[] THEN DISJ2_TAC THEN 17391 EXISTS_TAC ``(s:num->num) n`` THEN ASM_REWRITE_TAC[]], 17392 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN SIMP_TAC std_ss [] THEN 17393 ONCE_REWRITE_TAC[METIS [REAL_MUL_LZERO] 17394 ``(if p then a * x else 0:real) = (if p then a else &0) * x``] THEN 17395 SIMP_TAC std_ss [SUM_RMUL] THEN 17396 ONCE_REWRITE_TAC [METIS [] 17397 ``(\n. sum (1 .. s n) 17398 (\k. if &k / &s n <= (g:real->real) x then inv (&s n) else 0) * f x) = 17399 (\n. (\n. sum (1 .. s n) 17400 (\k. if &k / &s n <= g x then inv (&s n) else 0)) n * (\n. f x) n)``] THEN 17401 MATCH_MP_TAC LIM_MUL THEN 17402 SIMP_TAC std_ss [LIM_SEQUENTIALLY, o_DEF, DIST_REFL] THEN 17403 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 17404 MP_TAC(ISPEC ``e:real`` REAL_ARCH_INV) THEN 17405 ASM_REWRITE_TAC[] THEN DISCH_THEN (X_CHOOSE_TAC ``N:num``) THEN 17406 EXISTS_TAC ``N:num`` THEN POP_ASSUM MP_TAC THEN 17407 STRIP_TAC THEN X_GEN_TAC ``n:num`` THEN DISCH_TAC THEN 17408 REWRITE_TAC [dist] THEN ONCE_REWRITE_TAC[ABS_SUB] THEN 17409 MATCH_MP_TAC REAL_LT_TRANS THEN EXISTS_TAC ``inv(&n:real)`` THEN 17410 CONJ_TAC THENL 17411 [MP_TAC(ISPECL 17412 [``(g:real->real)``, ``IMAGE (\x. x) (interval[a,b])``] 17413 lemma1) THEN 17414 ASM_SIMP_TAC std_ss [FORALL_IN_IMAGE, o_DEF, IMP_CONJ, 17415 RIGHT_FORALL_IMP_THM] THEN 17416 REWRITE_TAC[AND_IMP_INTRO] THEN DISCH_TAC THEN 17417 MATCH_MP_TAC REAL_LTE_TRANS THEN 17418 EXISTS_TAC ``inv(&((s:num->num) n):real)`` THEN CONJ_TAC THENL 17419 [FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC std_ss [], 17420 MATCH_MP_TAC REAL_LE_INV2 THEN 17421 REWRITE_TAC[REAL_OF_NUM_LE, REAL_LT]] THEN 17422 FIRST_ASSUM(MP_TAC o SPEC ``n:num`` o MATCH_MP MONOTONE_BIGGER) THEN 17423 ASM_SIMP_TAC arith_ss [], 17424 MATCH_MP_TAC REAL_LET_TRANS THEN EXISTS_TAC ``inv(&N:real)`` THEN 17425 ASM_SIMP_TAC std_ss [] THEN MATCH_MP_TAC REAL_LE_INV2 THEN 17426 REWRITE_TAC[REAL_OF_NUM_LE, REAL_LT] THEN ASM_SIMP_TAC arith_ss []]], 17427 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 17428 STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 17429 EXISTS_TAC ``d:real`` THEN ASM_REWRITE_TAC[] THEN 17430 MATCH_MP_TAC(ISPEC ``sequentially`` LIM_UNIQUE) THEN 17431 EXISTS_TAC ``\n. integral (interval [c((s:num->num) n),b]) 17432 (f:real->real)`` THEN 17433 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_SEQUENTIALLY] THEN 17434 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``] 17435 INDEFINITE_INTEGRAL_CONTINUOUS_LEFT) THEN 17436 ASM_REWRITE_TAC[CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN] THEN 17437 DISCH_THEN(MP_TAC o SPEC ``d:real``) THEN ASM_REWRITE_TAC[] THEN 17438 REWRITE_TAC[CONTINUOUS_WITHIN_SEQUENTIALLY] THEN 17439 DISCH_THEN(MP_TAC o SPEC ``(c:num->real) o (s:num->num)``) THEN 17440 ASM_REWRITE_TAC[] THEN ASM_SIMP_TAC std_ss [o_DEF]]); 17441 17442val SECOND_MEAN_VALUE_THEOREM_FULL = store_thm ("SECOND_MEAN_VALUE_THEOREM_FULL", 17443 ``!f:real->real g a b. 17444 ~(interval[a,b] = {}) /\ 17445 f integrable_on interval [a,b] /\ 17446 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 17447 ==> g x <= g y) 17448 ==> ?c. c IN interval [a,b] /\ 17449 ((\x. g x * f x) has_integral 17450 (g(a) * integral (interval[a,c]) f + 17451 g(b) * integral (interval[c,b]) f)) (interval[a,b])``, 17452 REPEAT GEN_TAC THEN STRIP_TAC THEN 17453 SUBGOAL_THEN ``(g:real->real) a <= g b`` MP_TAC THENL 17454 [FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[ENDS_IN_INTERVAL] THEN 17455 ASM_MESON_TAC[GSYM INTERVAL_EQ_EMPTY, REAL_LET_TOTAL], 17456 ALL_TAC] THEN 17457 REWRITE_TAC[REAL_LE_LT] THEN STRIP_TAC THENL 17458 [ALL_TAC, 17459 SUBGOAL_THEN 17460 ``!x. x IN interval[a,b] ==> ((g:real->real)(x) * (f:real->real)(x) = g(a) * f x)`` 17461 ASSUME_TAC THENL 17462 [X_GEN_TAC ``x:real`` THEN 17463 REWRITE_TAC[IN_INTERVAL] THEN STRIP_TAC THEN 17464 AP_THM_TAC THEN AP_TERM_TAC THEN 17465 RULE_ASSUM_TAC(REWRITE_RULE 17466 [IN_INTERVAL, GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT]) THEN 17467 ASM_MESON_TAC[REAL_LE_ANTISYM, REAL_LE_TRANS, REAL_LE_TOTAL], 17468 ALL_TAC] THEN 17469 EXISTS_TAC ``a:real`` THEN ASM_REWRITE_TAC[ENDS_IN_INTERVAL] THEN 17470 MATCH_MP_TAC HAS_INTEGRAL_EQ THEN 17471 EXISTS_TAC ``\x. g(a:real) * (f:real->real) x`` THEN 17472 ASM_SIMP_TAC std_ss [INTEGRAL_NULL, CONTENT_EQ_0, REAL_LE_REFL] THEN 17473 ASM_SIMP_TAC std_ss [INTEGRAL_CMUL, REAL_MUL_RZERO, REAL_ADD_LID] THEN 17474 MATCH_MP_TAC HAS_INTEGRAL_CMUL THEN 17475 ASM_REWRITE_TAC[GSYM HAS_INTEGRAL_INTEGRAL]] THEN 17476 MP_TAC(ISPECL 17477 [``f:real->real``, 17478 ``(\x. if x < a then &0 17479 else if b < x then &1 17480 else (g(x) - g(a)) / (g(b) - (g:real->real)(a)))``, 17481 ``a:real``, ``b:real``] 17482 lemma4) THEN ASM_SIMP_TAC std_ss [] THEN 17483 KNOW_TAC ``(!(x :real) (y :real). 17484 x <= y ==> 17485 (if x < (a :real) then (0 :real) 17486 else if (b :real) < x then (1 :real) 17487 else ((g :real -> real) x - g a) / (g b - g a)) <= 17488 if y < a then (0 :real) 17489 else if b < y then (1 :real) 17490 else (g y - g a) / (g b - g a)) /\ 17491 (!(x :real). 17492 x IN interval [(a,b)] ==> 17493 (0 :real) <= 17494 (if x < a then (0 :real) 17495 else if b < x then (1 :real) 17496 else (g x - g a) / (g b - g a)) /\ 17497 (if x < a then (0 :real) 17498 else if b < x then (1 :real) 17499 else (g x - g a) / (g b - g a)) <= (1 :real))`` THENL 17500 [CONJ_TAC THEN 17501 REPEAT GEN_TAC THEN 17502 REPEAT(COND_CASES_TAC THEN ASM_REWRITE_TAC[REAL_POS, REAL_LE_REFL]) THEN 17503 TRY ASM_REAL_ARITH_TAC THEN 17504 ASM_SIMP_TAC real_ss [IN_INTERVAL, REAL_SUB_LT] THEN 17505 ASM_SIMP_TAC real_ss [REAL_LE_LDIV_EQ, REAL_LE_RDIV_EQ, REAL_SUB_LT] THEN 17506 ASM_REWRITE_TAC[REAL_MUL_LZERO, REAL_MUL_LID, REAL_SUB_LE, 17507 REAL_ARITH ``x - a <= y - a <=> x <= y:real``] THEN 17508 REPEAT STRIP_TAC THEN TRY (FIRST_X_ASSUM MATCH_MP_TAC) THEN 17509 REWRITE_TAC[IN_INTERVAL] THEN TRY (ASM_REAL_ARITH_TAC) THENL 17510 [POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 17511 REWRITE_TAC [REAL_ARITH ``a - b <= 0 <=> a <= b:real``] THEN 17512 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 17513 ASM_REAL_ARITH_TAC, 17514 UNDISCH_TAC ``g a < (g:real->real) b`` THEN 17515 GEN_REWR_TAC LAND_CONV [REAL_ARITH ``a < b <=> 0 < b - a:real``] THEN 17516 DISCH_THEN (MP_TAC o ONCE_REWRITE_RULE [EQ_SYM_EQ] o MATCH_MP REAL_LT_IMP_NE) THEN 17517 DISCH_TAC THEN REWRITE_TAC [real_div, GSYM REAL_MUL_ASSOC] THEN 17518 ASM_SIMP_TAC real_ss [REAL_MUL_LINV] THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 17519 REWRITE_TAC[IN_INTERVAL] THEN ASM_REAL_ARITH_TAC], 17520 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 17521 SIMP_TAC std_ss [GSYM RIGHT_EXISTS_AND_THM] THEN 17522 DISCH_THEN (X_CHOOSE_TAC ``c:real``) THEN EXISTS_TAC ``c:real`` THEN 17523 POP_ASSUM MP_TAC THEN 17524 ONCE_REWRITE_TAC[TAUT `a /\ b /\ c ==> d <=> b ==> a /\ c ==> d`] THEN 17525 DISCH_TAC THEN ASM_SIMP_TAC std_ss [GSYM HAS_INTEGRAL_INTEGRABLE_INTEGRAL] THEN 17526 DISCH_THEN(MP_TAC o SPEC ``(g:real->real) b - g a`` o 17527 MATCH_MP HAS_INTEGRAL_CMUL) THEN 17528 FIRST_ASSUM(MP_TAC o MATCH_MP INTEGRABLE_INTEGRAL) THEN 17529 DISCH_THEN(MP_TAC o SPEC ``(g:real->real)(a)`` o 17530 MATCH_MP HAS_INTEGRAL_CMUL) THEN REWRITE_TAC[AND_IMP_INTRO] THEN 17531 DISCH_THEN(MP_TAC o MATCH_MP HAS_INTEGRAL_ADD) THEN 17532 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, ``c:real``] 17533 INTEGRAL_COMBINE) THEN 17534 KNOW_TAC ``a <= c /\ c <= b:real /\ f integrable_on interval [(a,b)]`` THENL 17535 [ASM_MESON_TAC[IN_INTERVAL], 17536 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 17537 DISCH_THEN(SUBST1_TAC o SYM) THEN 17538 SIMP_TAC std_ss [REAL_ARITH 17539 ``ga * (i1 + i2) + (gb - ga) * i2:real = ga * i1 + gb * i2:real``] THEN 17540 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] HAS_INTEGRAL_EQ) THEN 17541 X_GEN_TAC ``x:real`` THEN REWRITE_TAC[IN_INTERVAL] THEN STRIP_TAC THEN 17542 ASM_SIMP_TAC std_ss [GSYM REAL_NOT_LE, REAL_MUL_ASSOC] THEN 17543 ASM_SIMP_TAC real_ss [REAL_DIV_LMUL, REAL_LT_IMP_NE, REAL_SUB_LT]); 17544 17545val SECOND_MEAN_VALUE_THEOREM = store_thm ("SECOND_MEAN_VALUE_THEOREM", 17546 ``!f:real->real g a b. 17547 ~(interval[a,b] = {}) /\ 17548 f integrable_on interval [a,b] /\ 17549 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 17550 ==> g x <= g y) 17551 ==> ?c. c IN interval [a,b] /\ 17552 (integral (interval[a,b]) (\x. g x * f x) = 17553 g(a) * integral (interval[a,c]) f + 17554 g(b) * integral (interval[c,b]) f)``, 17555 REPEAT GEN_TAC THEN 17556 DISCH_THEN(MP_TAC o MATCH_MP SECOND_MEAN_VALUE_THEOREM_FULL) THEN 17557 DISCH_THEN (X_CHOOSE_TAC ``c:real``) THEN EXISTS_TAC ``c:real`` THEN 17558 POP_ASSUM MP_TAC THEN REPEAT STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 17559 FIRST_X_ASSUM(SUBST1_TAC o MATCH_MP INTEGRAL_UNIQUE) THEN REWRITE_TAC[]); 17560 17561val SECOND_MEAN_VALUE_THEOREM_GEN_FULL = store_thm ("SECOND_MEAN_VALUE_THEOREM_GEN_FULL", 17562 ``!f:real->real g a b u v. 17563 ~(interval[a,b] = {}) /\ f integrable_on interval [a,b] /\ 17564 (!x. x IN interval(a,b) ==> u <= g x /\ g x <= v) /\ 17565 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 17566 ==> g x <= g y) 17567 ==> ?c. c IN interval [a,b] /\ 17568 ((\x. g x * f x) has_integral 17569 (u * integral (interval[a,c]) f + 17570 v * integral (interval[c,b]) f)) (interval[a,b])``, 17571 REPEAT STRIP_TAC THEN ASM_CASES_TAC ``b:real = a`` THENL 17572 [EXISTS_TAC ``a:real`` THEN ASM_REWRITE_TAC[INTERVAL_SING, IN_SING] THEN 17573 ASM_SIMP_TAC std_ss [GSYM INTERVAL_SING, INTEGRAL_NULL, CONTENT_EQ_0, 17574 REAL_ADD_LID, REAL_LE_REFL, REAL_MUL_RZERO, HAS_INTEGRAL_NULL], 17575 ALL_TAC] THEN 17576 SUBGOAL_THEN ``a < b:real`` ASSUME_TAC THENL 17577 [METIS_TAC[GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LE, REAL_LT_LE], 17578 ALL_TAC] THEN 17579 SUBGOAL_THEN ``u <= v:real`` ASSUME_TAC THENL 17580 [METIS_TAC[GSYM INTERVAL_EQ_EMPTY, MEMBER_NOT_EMPTY, REAL_NOT_LT, 17581 REAL_LE_TRANS], 17582 ALL_TAC] THEN 17583 MP_TAC(ISPECL 17584 [``f:real->real``, 17585 ``\x:real. if x = a then u else if x = b then v else g x:real``, 17586 ``a:real``, ``b:real``] SECOND_MEAN_VALUE_THEOREM_FULL) THEN 17587 ASM_SIMP_TAC std_ss [REAL_MUL_LZERO, REAL_ADD_LID] THEN 17588 KNOW_TAC ``(!x y. 17589 x IN interval [(a,b)] /\ y IN interval [(a,b)] /\ x <= y ==> 17590 (if x = a then u else if x = b then v else (g:real->real) x) <= 17591 if y = a then u else if y = b then v else g y)`` THENL 17592 [MAP_EVERY X_GEN_TAC [``x:real``, ``y:real``] THEN 17593 ASM_CASES_TAC ``x:real = a`` THEN ASM_REWRITE_TAC[] THENL 17594 [METIS_TAC[REAL_LE_REFL, INTERVAL_CASES], ALL_TAC] THEN 17595 ASM_CASES_TAC ``y:real = b`` THEN ASM_REWRITE_TAC[] THENL 17596 [METIS_TAC[REAL_LE_REFL, INTERVAL_CASES], ALL_TAC] THEN 17597 REPEAT(COND_CASES_TAC THEN ASM_SIMP_TAC std_ss []) THEN 17598 REWRITE_TAC[IN_INTERVAL] THEN POP_ASSUM MP_TAC THEN 17599 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 17600 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 17601 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 17602 TRY REAL_ARITH_TAC THEN UNDISCH_TAC ``b <= y:real`` THEN 17603 UNDISCH_TAC ``y <= b:real`` THEN UNDISCH_TAC ``y <> b:real`` THEN 17604 REAL_ARITH_TAC, 17605 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 17606 DISCH_THEN (X_CHOOSE_TAC ``c:real``) THEN EXISTS_TAC ``c:real`` THEN 17607 POP_ASSUM MP_TAC THEN MATCH_MP_TAC MONO_AND THEN 17608 REWRITE_TAC[] THEN MATCH_MP_TAC 17609 (REWRITE_RULE[TAUT `a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] 17610 HAS_INTEGRAL_SPIKE) THEN 17611 EXISTS_TAC ``{a:real;b}`` THEN 17612 SIMP_TAC std_ss [NEGLIGIBLE_EMPTY, NEGLIGIBLE_INSERT, IN_DIFF, IN_INSERT, 17613 NOT_IN_EMPTY, DE_MORGAN_THM]]); 17614 17615val SECOND_MEAN_VALUE_THEOREM_GEN = store_thm ("SECOND_MEAN_VALUE_THEOREM_GEN", 17616 ``!f:real->real g a b u v. 17617 ~(interval[a,b] = {}) /\ f integrable_on interval [a,b] /\ 17618 (!x. x IN interval(a,b) ==> u <= g x /\ g x <= v) /\ 17619 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 17620 ==> g x <= g y) 17621 ==> ?c. c IN interval [a,b] /\ 17622 (integral (interval[a,b]) (\x. g x * f x) = 17623 u * integral (interval[a,c]) f + 17624 v * integral (interval[c,b]) f)``, 17625 REPEAT GEN_TAC THEN 17626 DISCH_THEN(MP_TAC o MATCH_MP SECOND_MEAN_VALUE_THEOREM_GEN_FULL) THEN 17627 DISCH_THEN (X_CHOOSE_TAC ``c:real``) THEN EXISTS_TAC ``c:real`` THEN 17628 POP_ASSUM MP_TAC THEN REPEAT STRIP_TAC THEN ASM_SIMP_TAC std_ss [] THEN 17629 FIRST_X_ASSUM(SUBST1_TAC o MATCH_MP INTEGRAL_UNIQUE) THEN REWRITE_TAC[]); 17630 17631val SECOND_MEAN_VALUE_THEOREM_BONNET_FULL = store_thm ("SECOND_MEAN_VALUE_THEOREM_BONNET_FULL", 17632 ``!f:real->real g a b. 17633 ~(interval[a,b] = {}) /\ f integrable_on interval [a,b] /\ 17634 (!x. x IN interval[a,b] ==> &0 <= g x) /\ 17635 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 17636 ==> g x <= g y) 17637 ==> ?c. c IN interval [a,b] /\ 17638 ((\x. g x * f x) has_integral 17639 (g(b) * integral (interval[c,b]) f)) (interval[a,b])``, 17640 REPEAT STRIP_TAC THEN 17641 MP_TAC(ISPECL 17642 [``f:real->real``, ``g:real->real``, ``a:real``, ``b:real``, 17643 ``&0:real``, ``(g:real->real) b``] SECOND_MEAN_VALUE_THEOREM_GEN_FULL) THEN 17644 ASM_REWRITE_TAC[REAL_MUL_LZERO, REAL_ADD_LID] THEN 17645 DISCH_THEN MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 17646 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 17647 ASM_SIMP_TAC real_ss [IN_INTERVAL, REAL_LE_LT] THEN METIS_TAC [REAL_LT_TRANS]); 17648 17649val SECOND_MEAN_VALUE_THEOREM_BONNET = store_thm ("SECOND_MEAN_VALUE_THEOREM_BONNET", 17650 ``!f:real->real g a b. 17651 ~(interval[a,b] = {}) /\ f integrable_on interval[a,b] /\ 17652 (!x. x IN interval[a,b] ==> &0 <= g x) /\ 17653 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 17654 ==> g x <= g y) 17655 ==> ?c. c IN interval [a,b] /\ 17656 (integral (interval[a,b]) (\x. g x * f x) = 17657 g(b) * integral (interval[c,b]) f)``, 17658 REPEAT GEN_TAC THEN 17659 DISCH_THEN(MP_TAC o MATCH_MP SECOND_MEAN_VALUE_THEOREM_BONNET_FULL) THEN 17660 DISCH_THEN (X_CHOOSE_TAC ``c:real``) THEN EXISTS_TAC ``c:real`` THEN 17661 POP_ASSUM MP_TAC THEN REPEAT STRIP_TAC THEN ASM_SIMP_TAC std_ss [] THEN 17662 FIRST_X_ASSUM(SUBST1_TAC o MATCH_MP INTEGRAL_UNIQUE) THEN REWRITE_TAC[]); 17663 17664val INTEGRABLE_INCREASING_PRODUCT = store_thm ("INTEGRABLE_INCREASING_PRODUCT", 17665 ``!f:real->real g a b. 17666 f integrable_on interval[a,b] /\ 17667 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 17668 ==> g(x) <= g(y)) 17669 ==> (\x. g(x) * f(x)) integrable_on interval[a,b]``, 17670 REPEAT STRIP_TAC THEN ASM_CASES_TAC ``interval[a:real,b] = {}`` THEN 17671 ASM_REWRITE_TAC[INTEGRABLE_ON_EMPTY] THEN 17672 MP_TAC(ISPECL [``\x. ((f:real->real) x)``, 17673 ``g:real->real``, ``a:real``, ``b:real``] 17674 SECOND_MEAN_VALUE_THEOREM_FULL) THEN ASM_REWRITE_TAC[] THEN 17675 KNOW_TAC ``(\x. (f:real->real) x) integrable_on interval [(a,b)]`` THENL 17676 [RULE_ASSUM_TAC(ONCE_REWRITE_RULE[INTEGRABLE_COMPONENTWISE]) THEN 17677 ASM_SIMP_TAC std_ss [], 17678 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 17679 REWRITE_TAC[integrable_on] THEN MESON_TAC[]]); 17680 17681val lemma = prove ( 17682 ``!f:real->real g B. 17683 f integrable_on univ(:real) /\ 17684 (!x y. x <= y ==> g x <= g y) /\ 17685 (!x. abs(g x) <= B) 17686 ==> (\x. g x * f x) integrable_on univ(:real)``, 17687 REPEAT GEN_TAC THEN ONCE_REWRITE_TAC[INTEGRABLE_ALT_SUBSET] THEN 17688 SIMP_TAC std_ss [IN_UNIV, ETA_AX] THEN STRIP_TAC THEN 17689 MATCH_MP_TAC(TAUT `a /\ (a ==> b) ==> a /\ b`) THEN CONJ_TAC THENL 17690 [REPEAT GEN_TAC THEN MATCH_MP_TAC INTEGRABLE_INCREASING_PRODUCT THEN 17691 ASM_SIMP_TAC std_ss [], 17692 DISCH_TAC] THEN 17693 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 17694 UNDISCH_TAC ``!e. 0 < e ==> 17695 ?B. 0 < B /\ 17696 !a b c d. 17697 ball (0,B) SUBSET interval [(a,b)] /\ 17698 interval [(a,b)] SUBSET interval [(c,d)] ==> 17699 abs (integral (interval [(a,b)]) f - 17700 integral (interval [(c,d)]) f) < e`` THEN DISCH_TAC THEN 17701 FIRST_X_ASSUM(MP_TAC o SPEC ``e / (&8 * abs B + &8:real)``) THEN 17702 ASM_SIMP_TAC real_ss [REAL_LT_DIV, REAL_ARITH ``&0 < &8 * abs B + &8:real``] THEN 17703 DISCH_THEN (X_CHOOSE_TAC ``C:real``) THEN EXISTS_TAC ``C:real`` THEN 17704 POP_ASSUM MP_TAC THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 17705 SUBGOAL_THEN ``~(ball(0:real,C) = {})`` ASSUME_TAC THENL 17706 [ASM_REWRITE_TAC[BALL_EQ_EMPTY, REAL_NOT_LE], ALL_TAC] THEN 17707 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``, ``c:real``, ``d:real``] THEN 17708 STRIP_TAC THEN SUBGOAL_THEN 17709 ``~(interval[a:real,b] = {}) /\ ~(interval[c:real,d] = {})`` 17710 MP_TAC THENL [ASM_SET_TAC[], ALL_TAC] THEN 17711 SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT] THEN STRIP_TAC THEN 17712 UNDISCH_TAC ``interval [(a,b)] SUBSET interval [(c,d)]`` THEN DISCH_TAC THEN 17713 FIRST_ASSUM(MP_TAC o REWRITE_RULE [SUBSET_INTERVAL]) THEN 17714 ASM_REWRITE_TAC[GSYM REAL_NOT_LE] THEN STRIP_TAC THEN 17715 MP_TAC(ISPECL [``\x. (g:real->real) x * (f:real->real) x``, 17716 ``c:real``, ``b:real``, ``a:real``] INTEGRAL_COMBINE) THEN 17717 MP_TAC(ISPECL [``\x. (g:real->real) x * (f:real->real) x``, 17718 ``c:real``, ``d:real``, ``b:real``] INTEGRAL_COMBINE) THEN 17719 ASM_REWRITE_TAC[] THEN 17720 KNOW_TAC ``c <= b:real`` THENL 17721 [POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 17722 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 17723 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 17724 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 17725 DISCH_THEN(SUBST1_TAC o SYM)] THEN 17726 DISCH_THEN(SUBST1_TAC o SYM) THEN 17727 REWRITE_TAC[REAL_NOT_LE, REAL_ARITH 17728 ``abs(ab - ((ca + ab) + bd):real) = abs(ca + bd)``] THEN 17729 MP_TAC(ISPECL[``f:real->real``, ``g:real->real``, ``c:real``, ``a:real``] 17730 SECOND_MEAN_VALUE_THEOREM) THEN 17731 ASM_SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT] THEN 17732 DISCH_THEN(X_CHOOSE_THEN ``u:real`` STRIP_ASSUME_TAC) THEN 17733 MP_TAC(ISPECL[``f:real->real``, ``g:real->real``, ``b:real``, ``d:real``] 17734 SECOND_MEAN_VALUE_THEOREM) THEN 17735 ASM_SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT] THEN 17736 DISCH_THEN(X_CHOOSE_THEN ``v:real`` STRIP_ASSUME_TAC) THEN 17737 ASM_REWRITE_TAC[] THEN 17738 SUBGOAL_THEN 17739 ``!x y. y <= a 17740 ==> abs(integral (interval[x,y]) (f:real->real)) 17741 < e / (&4 * abs B + &4)`` 17742 ASSUME_TAC 17743 THENL 17744 [REPEAT STRIP_TAC THEN 17745 ASM_CASES_TAC ``x <= y:real`` THENL 17746 [FIRST_X_ASSUM(fn th => 17747 MP_TAC(SPECL[``a:real``, ``b:real``, ``y:real``, ``b:real``] th) THEN 17748 MP_TAC(SPECL[``a:real``, ``b:real``, ``x:real``, ``b:real``] th)) THEN 17749 ASM_SIMP_TAC std_ss [SUBSET_INTERVAL, REAL_LE_REFL] THEN 17750 KNOW_TAC ``x <= a:real`` THENL [METIS_TAC [REAL_LE_TRANS], 17751 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 17752 MP_TAC(ISPECL [``f:real->real``, ``x:real``, ``b:real``, ``y:real``] 17753 INTEGRAL_COMBINE) THEN 17754 ASM_REWRITE_TAC[] THEN KNOW_TAC ``y <= b:real`` THENL 17755 [METIS_TAC [REAL_LE_TRANS], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 17756 POP_ASSUM K_TAC THEN DISCH_THEN(SUBST1_TAC o SYM)] THEN 17757 MATCH_MP_TAC(REAL_ARITH 17758 ``(&2 * d = e:real) 17759 ==> abs(ab - (xy + yb)) < d 17760 ==> abs(ab - yb) < d 17761 ==> abs(xy:real) < e``) THEN 17762 REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN 17763 REWRITE_TAC [REAL_ARITH ``inv (8 * abs B + 8) = inv (8 * (abs B + 1:real))``] THEN 17764 REWRITE_TAC [REAL_ARITH ``inv (4 * abs B + 4) = inv (4 * (abs B + 1:real))``] THEN 17765 KNOW_TAC ``abs B + 1 <> 0:real`` THENL 17766 [ONCE_REWRITE_TAC [EQ_SYM_EQ] THEN MATCH_MP_TAC REAL_LT_IMP_NE THEN 17767 REAL_ARITH_TAC, DISCH_TAC] THEN REWRITE_TAC [REAL_ARITH ``8 = 2 * 4:real``] THEN 17768 ASM_SIMP_TAC real_ss [REAL_INV_MUL] THEN REWRITE_TAC [REAL_MUL_ASSOC] THEN 17769 ONCE_REWRITE_TAC [REAL_ARITH ``2 * a * inv 2 * b * c = 2 * inv 2 * a * b * c:real``] THEN 17770 SIMP_TAC real_ss [REAL_MUL_RINV], 17771 SUBGOAL_THEN ``interval[x:real,y] = {}`` SUBST1_TAC THENL 17772 [REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY] THEN FULL_SIMP_TAC std_ss [REAL_NOT_LE], 17773 REWRITE_TAC[INTEGRAL_EMPTY, ABS_0] THEN 17774 MATCH_MP_TAC REAL_LT_DIV THEN ASM_REWRITE_TAC [] THEN REAL_ARITH_TAC]], 17775 ALL_TAC] THEN 17776 SUBGOAL_THEN 17777 ``!x y. b <= x 17778 ==> abs(integral (interval[x,y]) (f:real->real)) 17779 < e / (&4 * abs B + &4)`` 17780 ASSUME_TAC 17781 THENL 17782 [REPEAT STRIP_TAC THEN 17783 ASM_CASES_TAC ``x <= y:real`` THENL 17784 [FIRST_X_ASSUM(fn th => 17785 MP_TAC(SPECL[``a:real``, ``b:real``, ``a:real``, ``x:real``] th) THEN 17786 MP_TAC(SPECL[``a:real``, ``b:real``, ``a:real``, ``y:real``] th)) THEN 17787 ASM_SIMP_TAC std_ss [SUBSET_INTERVAL, REAL_LE_REFL] THEN 17788 KNOW_TAC ``b <= y:real`` THENL [METIS_TAC [REAL_LE_TRANS], 17789 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 17790 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``y:real``, ``x:real``] 17791 INTEGRAL_COMBINE) THEN 17792 ASM_REWRITE_TAC[] THEN KNOW_TAC ``a <= x:real`` THENL 17793 [METIS_TAC [REAL_LE_TRANS], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 17794 POP_ASSUM K_TAC THEN DISCH_THEN(SUBST1_TAC o SYM)] THEN 17795 MATCH_MP_TAC(REAL_ARITH 17796 ``(&2 * d = e:real) 17797 ==> abs(ab - (ax + xy)) < d 17798 ==> abs(ab - ax) < d 17799 ==> abs(xy:real) < e``) THEN 17800 REWRITE_TAC [real_div, REAL_MUL_ASSOC] THEN 17801 REWRITE_TAC [REAL_ARITH 17802 ``inv (8 * abs B + 8) = inv (8 * (abs B + 1:real))``] THEN 17803 REWRITE_TAC [REAL_ARITH 17804 ``inv (4 * abs B + 4) = inv (4 * (abs B + 1:real))``] THEN 17805 KNOW_TAC ``abs B + 1 <> 0:real`` THENL 17806 [ONCE_REWRITE_TAC [EQ_SYM_EQ] THEN MATCH_MP_TAC REAL_LT_IMP_NE THEN 17807 REAL_ARITH_TAC, DISCH_TAC] THEN REWRITE_TAC [REAL_ARITH ``8 = 2 * 4:real``] THEN 17808 ASM_SIMP_TAC real_ss [REAL_INV_MUL] THEN REWRITE_TAC [REAL_MUL_ASSOC] THEN 17809 ONCE_REWRITE_TAC [REAL_ARITH 17810 ``2 * a * inv 2 * b * c = 2 * inv 2 * a * b * c:real``] THEN 17811 SIMP_TAC real_ss [REAL_MUL_RINV], 17812 SUBGOAL_THEN ``interval[x:real,y] = {}`` SUBST1_TAC THENL 17813 [REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY] THEN FULL_SIMP_TAC std_ss [REAL_NOT_LE], 17814 REWRITE_TAC[INTEGRAL_EMPTY, ABS_0] THEN 17815 MATCH_MP_TAC REAL_LT_DIV THEN ASM_REWRITE_TAC [] THEN REAL_ARITH_TAC]], 17816 ALL_TAC] THEN 17817 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 17818 MATCH_MP_TAC REAL_LET_TRANS THEN 17819 EXISTS_TAC ``&4 * B * e / (&4 * abs B + &4:real)`` THEN CONJ_TAC THENL 17820 [REWRITE_TAC [real_div, GSYM REAL_MUL_ASSOC] THEN 17821 MATCH_MP_TAC(REAL_ARITH 17822 ``(abs a <= e /\ abs b <= e) /\ (abs c <= e /\ abs d <= e) 17823 ==> abs((a + b) + (c + d):real) <= &4 * e:real``) THEN 17824 REWRITE_TAC[ABS_MUL] THEN CONJ_TAC THENL 17825 [CONJ_TAC THEN MATCH_MP_TAC REAL_LE_MUL2 THEN 17826 ASM_REWRITE_TAC[ABS_POS] THEN 17827 MATCH_MP_TAC REAL_LT_IMP_LE THEN 17828 UNDISCH_TAC ``!x y. y <= a ==> 17829 abs (integral (interval [(x,y)]) f) < e / (4 * abs B + 4:real)`` THEN 17830 DISCH_TAC THEN REWRITE_TAC [GSYM real_div] THEN 17831 FIRST_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC real_ss [], 17832 CONJ_TAC THEN MATCH_MP_TAC REAL_LE_MUL2 THEN 17833 ASM_REWRITE_TAC[ABS_POS] THEN 17834 MATCH_MP_TAC REAL_LT_IMP_LE THEN REWRITE_TAC [GSYM real_div] THEN 17835 FIRST_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC real_ss []], 17836 REWRITE_TAC [real_div] THEN 17837 REWRITE_TAC[REAL_ARITH 17838 ``&4 * B * e * y < e <=> e * ((&4 * B) * y) < e * &1:real``] THEN 17839 REWRITE_TAC [GSYM real_div] THEN 17840 ASM_SIMP_TAC real_ss [REAL_LT_LMUL, REAL_LT_LDIV_EQ, 17841 REAL_ARITH ``&0 < &4 * abs B + &4:real``] THEN 17842 REAL_ARITH_TAC]); 17843 17844val INTEGRABLE_INCREASING_PRODUCT_UNIV = store_thm ("INTEGRABLE_INCREASING_PRODUCT_UNIV", 17845 ``!f:real->real g B. 17846 f integrable_on univ(:real) /\ 17847 (!x y. x <= y ==> g x <= g y) /\ 17848 (!x. abs(g x) <= B) 17849 ==> (\x. g x * f x) integrable_on univ(:real)``, 17850 REWRITE_TAC [lemma]); 17851 17852val INTEGRABLE_INCREASING = store_thm ("INTEGRABLE_INCREASING", 17853 ``!f:real->real a b. 17854 (!x y i. x IN interval[a,b] /\ y IN interval[a,b] /\ 17855 x <= y ==> f(x) <= f(y)) 17856 ==> f integrable_on interval[a,b]``, 17857 REPEAT STRIP_TAC THEN 17858 ONCE_REWRITE_TAC[METIS [ETA_AX, REAL_MUL_RID] 17859 ``(f:real->real) = (\x. f x * (\x. 1) x)``] THEN 17860 MATCH_MP_TAC INTEGRABLE_INCREASING_PRODUCT THEN 17861 ASM_SIMP_TAC std_ss [INTEGRABLE_CONST]); 17862 17863val INTEGRABLE_DECREASING_PRODUCT = store_thm ("INTEGRABLE_DECREASING_PRODUCT", 17864 ``!f:real->real g a b. 17865 f integrable_on interval[a,b] /\ 17866 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 17867 ==> g(y) <= g(x)) 17868 ==> (\x. g(x) * f(x)) integrable_on interval[a,b]``, 17869 REPEAT STRIP_TAC THEN 17870 ONCE_REWRITE_TAC[REAL_ARITH ``x * y:real = -(-x * y)``] THEN 17871 ONCE_REWRITE_TAC [METIS [] ``(\x. -(-g x * f x)) = 17872 (\x. -(\x. (-(g:real->real) x * f x)) x)``] THEN 17873 MATCH_MP_TAC INTEGRABLE_NEG THEN 17874 ONCE_REWRITE_TAC [METIS [] ``(\x. -g x * f x) = 17875 (\x. (\x. -(g:real->real) x) x * f x)``] THEN 17876 MATCH_MP_TAC INTEGRABLE_INCREASING_PRODUCT THEN 17877 ASM_SIMP_TAC real_ss [REAL_LE_NEG2]); 17878 17879val INTEGRABLE_DECREASING_PRODUCT_UNIV = store_thm ("INTEGRABLE_DECREASING_PRODUCT_UNIV", 17880 ``!f:real->real g B. 17881 f integrable_on univ(:real) /\ 17882 (!x y. x <= y ==> g y <= g x) /\ 17883 (!x. abs(g x) <= B) 17884 ==> (\x. g x * f x) integrable_on univ(:real)``, 17885 REPEAT STRIP_TAC THEN 17886 ONCE_REWRITE_TAC[REAL_ARITH ``x * y:real = -(-x * y)``] THEN 17887 ONCE_REWRITE_TAC [METIS [] ``(\x. -(-g x * f x)) = 17888 (\x. -(\x. (-(g:real->real) x * f x)) x)``] THEN 17889 MATCH_MP_TAC INTEGRABLE_NEG THEN 17890 ONCE_REWRITE_TAC [METIS [] ``(\x. -g x * f x) = 17891 (\x. (\x. -(g:real->real) x) x * f x)``] THEN 17892 MATCH_MP_TAC INTEGRABLE_INCREASING_PRODUCT_UNIV THEN 17893 EXISTS_TAC ``B:real`` THEN ASM_SIMP_TAC real_ss [REAL_LE_NEG2, ABS_NEG]); 17894 17895val INTEGRABLE_DECREASING = store_thm ("INTEGRABLE_DECREASING", 17896 ``!f:real->real a b. 17897 (!x y i. x IN interval[a,b] /\ y IN interval[a,b] /\ 17898 x <= y ==> f(y) <= f(x)) 17899 ==> f integrable_on interval[a,b]``, 17900 REPEAT STRIP_TAC THEN GEN_REWR_TAC LAND_CONV [GSYM ETA_AX] THEN 17901 GEN_REWR_TAC (LAND_CONV o BINDER_CONV) [GSYM REAL_NEG_NEG] THEN 17902 ONCE_REWRITE_TAC [METIS [] ``(\x. --(f:real->real) x) = (\x. -((\x. -f x) x))``] THEN 17903 MATCH_MP_TAC INTEGRABLE_NEG THEN MATCH_MP_TAC INTEGRABLE_INCREASING THEN 17904 ASM_SIMP_TAC std_ss [REAL_LE_NEG2]); 17905 17906(* ------------------------------------------------------------------------- *) 17907(* Bounded variation and variation function, for real->real functions. *) 17908(* ------------------------------------------------------------------------- *) 17909 17910val _ = set_fixity "has_bounded_variation_on" (Infix(NONASSOC, 450)); 17911 17912val has_bounded_variation_on = new_definition ("has_bounded_variation_on", 17913 ``(f:real->real) has_bounded_variation_on s <=> 17914 (\k. f(interval_upperbound k) - f(interval_lowerbound k)) 17915 has_bounded_setvariation_on s``); 17916 17917val vector_variation = new_definition ("vector_variation", 17918 ``vector_variation s (f:real->real) = 17919 set_variation s (\k. f(interval_upperbound k) - f(interval_lowerbound k))``); 17920 17921val HAS_BOUNDED_VARIATION_ON_EQ = store_thm ("HAS_BOUNDED_VARIATION_ON_EQ", 17922 ``!f g:real->real s. 17923 (!x. x IN s ==> (f x = g x)) /\ f has_bounded_variation_on s 17924 ==> g has_bounded_variation_on s``, 17925 REPEAT GEN_TAC THEN 17926 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 17927 REWRITE_TAC[has_bounded_variation_on] THEN 17928 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] HAS_BOUNDED_SETVARIATION_ON_EQ) THEN 17929 SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND, 17930 GSYM INTERVAL_NE_EMPTY] THEN 17931 ASM_MESON_TAC[ENDS_IN_INTERVAL, SUBSET_DEF]); 17932 17933val VECTOR_VARIATION_EQ = store_thm ("VECTOR_VARIATION_EQ", 17934 ``!f g:real->real s. 17935 (!x. x IN s ==> (f x = g x)) 17936 ==> (vector_variation s f = vector_variation s g)``, 17937 REPEAT STRIP_TAC THEN REWRITE_TAC[vector_variation] THEN 17938 MATCH_MP_TAC SET_VARIATION_EQ THEN 17939 SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND, 17940 GSYM INTERVAL_NE_EMPTY] THEN 17941 ASM_MESON_TAC[ENDS_IN_INTERVAL, SUBSET_DEF]); 17942 17943val HAS_BOUNDED_VARIATION_ON_COMPONENTWISE = store_thm ("HAS_BOUNDED_VARIATION_ON_COMPONENTWISE", 17944 ``!f:real->real s. 17945 f has_bounded_variation_on s <=> 17946 (\x. f x) has_bounded_variation_on s``, 17947 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 17948 GEN_REWR_TAC LAND_CONV [HAS_BOUNDED_SETVARIATION_ON_COMPONENTWISE] THEN 17949 SIMP_TAC std_ss []); 17950 17951val VARIATION_EQUAL_LEMMA = store_thm ("VARIATION_EQUAL_LEMMA", 17952 ``!ms ms'. 17953 (!s. (ms'(ms s) = s) /\ (ms(ms' s) = s)) /\ 17954 (!d t. d division_of t 17955 ==> (IMAGE (IMAGE ms) d) division_of IMAGE ms t /\ 17956 (IMAGE (IMAGE ms') d) division_of IMAGE ms' t) /\ 17957 (!a b. ~(interval[a,b] = {}) 17958 ==> (IMAGE ms' (interval [a,b]) = interval[ms' a,ms' b]) \/ 17959 (IMAGE ms' (interval [a,b]) = interval[ms' b,ms' a])) 17960 ==> (!f:real->real s. 17961 (\x. f(ms' x)) has_bounded_variation_on (IMAGE ms s) <=> 17962 f has_bounded_variation_on s) /\ 17963 (!f:real->real s. 17964 vector_variation (IMAGE ms s) (\x. f(ms' x)) = 17965 vector_variation s f)``, 17966 REPEAT GEN_TAC THEN STRIP_TAC THEN 17967 REWRITE_TAC[has_bounded_variation_on, vector_variation] THEN 17968 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN X_GEN_TAC ``f:real->real`` THEN 17969 MP_TAC(ISPECL 17970 [``\f k. (f:(real->bool)->real) (IMAGE (ms':real->real) k)``, 17971 ``IMAGE (ms:real->real)``, 17972 ``IMAGE (ms':real->real)``] 17973 SETVARIATION_EQUAL_LEMMA) THEN 17974 KNOW_TAC ``(!(s :real -> bool). 17975 (IMAGE (ms' :real -> real) (IMAGE (ms :real -> real) s) = s) /\ 17976 (IMAGE ms (IMAGE ms' s) = s)) /\ 17977 (!(f :(real -> bool) -> real) (a :real) (b :real). 17978 interval [(a,b)] <> ({} :real -> bool) ==> 17979 ((\(f :(real -> bool) -> real) (k :real -> bool). f (IMAGE ms' k)) f 17980 (IMAGE ms (interval [(a,b)])) = 17981 f (interval [(a,b)])) /\ 17982 ?(a' :real) (b' :real). 17983 interval [(a',b')] <> ({} :real -> bool) /\ 17984 (IMAGE ms' (interval [(a,b)]) = interval [(a',b')])) /\ 17985 (!(t :real -> bool) (u :real -> bool). 17986 t SUBSET u ==> 17987 IMAGE ms t SUBSET IMAGE ms u /\ IMAGE ms' t SUBSET IMAGE ms' u) /\ 17988 (!(d :(real -> bool) -> bool) (t :real -> bool). 17989 d division_of t ==> 17990 IMAGE (IMAGE ms) d division_of IMAGE ms t /\ 17991 IMAGE (IMAGE ms') d division_of IMAGE ms' t)`` THENL 17992 [ASM_SIMP_TAC std_ss [GSYM IMAGE_COMPOSE, o_DEF, IMAGE_ID, IMAGE_SUBSET] THEN 17993 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN STRIP_TAC THEN 17994 FIRST_X_ASSUM(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 17995 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 17996 ASM_MESON_TAC[IMAGE_EQ_EMPTY], 17997 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 17998 SIMP_TAC std_ss [] THEN DISCH_TAC THEN 17999 POP_ASSUM (MP_TAC o SIMP_RULE std_ss [GSYM FORALL_AND_THM]) THEN 18000 DISCH_THEN(fn th => 18001 MP_TAC(SPEC ``\k. (f:real->real) (interval_upperbound k) - 18002 f (interval_lowerbound k)`` th)) THEN 18003 SIMP_TAC std_ss [] THEN DISCH_THEN(fn th => ONCE_REWRITE_TAC[GSYM th]) THEN 18004 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN X_GEN_TAC ``s:real->bool`` THEN 18005 REWRITE_TAC[has_bounded_setvariation_on, set_variation] THEN 18006 CONJ_TAC THENL 18007 [AP_TERM_TAC THEN ABS_TAC THEN AP_TERM_TAC THEN ABS_TAC THEN 18008 AP_TERM_TAC THEN ABS_TAC THEN 18009 REWRITE_TAC[TAUT `((p ==> q) <=> (p ==> r)) <=> p ==> (q <=> r)`] THEN 18010 STRIP_TAC THEN AP_THM_TAC THEN AP_TERM_TAC, 18011 AP_TERM_TAC THEN SIMP_TAC std_ss [] THEN 18012 ONCE_REWRITE_TAC [METIS [] ``{sum d f | 18013 ?t. d division_of t /\ t SUBSET IMAGE ms s} = 18014 {(\d. sum d f) d | 18015 (\d. ?t. d division_of t /\ t SUBSET IMAGE ms s) d}``] THEN 18016 MATCH_MP_TAC(SET_RULE 18017 ``(!x. P x ==> (f x = g x)) ==> ({f x | P x} = {g x | P x})``) THEN 18018 SIMP_TAC std_ss [] THEN GEN_TAC THEN STRIP_TAC] THEN MATCH_MP_TAC SUM_EQ THEN 18019 SIMP_TAC std_ss [] THENL 18020 [UNDISCH_TAC ``d division_of t``, UNDISCH_TAC ``x division_of t``] THEN 18021 DISCH_TAC THEN FIRST_ASSUM(fn th => 18022 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 18023 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN STRIP_TAC THEN 18024 FIRST_X_ASSUM(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 18025 ASM_REWRITE_TAC[] THEN DISCH_THEN(DISJ_CASES_THEN MP_TAC) THEN 18026 DISCH_THEN(MP_TAC o MATCH_MP (SET_RULE 18027 ``(IMAGE f s = s') ==> ~(s = {}) ==> (IMAGE f s = s') /\ ~(s' = {})``)) THEN 18028 ASM_REWRITE_TAC[] THEN STRIP_TAC THEN ASM_REWRITE_TAC[] THEN 18029 RULE_ASSUM_TAC(REWRITE_RULE[INTERVAL_NE_EMPTY]) THEN 18030 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND] THEN 18031 REAL_ARITH_TAC); 18032 18033val HAS_BOUNDED_VARIATION_COMPARISON = store_thm ("HAS_BOUNDED_VARIATION_COMPARISON", 18034 ``!f:real->real g:real->real s. 18035 f has_bounded_variation_on s /\ 18036 (!x y. x IN s /\ y IN s /\ x < y 18037 ==> dist(g x,g y) <= dist(f x,f y)) 18038 ==> g has_bounded_variation_on s``, 18039 REPEAT GEN_TAC THEN DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 18040 REWRITE_TAC[has_bounded_variation_on] THEN 18041 MATCH_MP_TAC(ONCE_REWRITE_RULE[IMP_CONJ_ALT] 18042 HAS_BOUNDED_SETVARIATION_COMPARISON) THEN 18043 REPEAT STRIP_TAC THEN SIMP_TAC std_ss [GSYM dist] THEN 18044 SUBGOAL_THEN 18045 ``!x y. x IN s /\ y IN s 18046 ==> dist((g:real->real) x,g y) 18047 <= dist((f:real->real) x,f y)`` 18048 MATCH_MP_TAC THENL 18049 [KNOW_TAC ``!x y. (\x y:real. x IN s /\ y IN s ==> dist (g x,g y) <= dist (f x,f y)) x y`` THENL 18050 [ALL_TAC, METIS_TAC []] THEN 18051 MATCH_MP_TAC REAL_WLOG_LT THEN 18052 ASM_SIMP_TAC std_ss [DIST_REFL, REAL_LE_REFL] THEN 18053 MESON_TAC[DIST_SYM], 18054 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, 18055 INTERVAL_UPPERBOUND_NONEMPTY] THEN 18056 ASM_MESON_TAC[ENDS_IN_INTERVAL, SUBSET_DEF]]); 18057 18058val HAS_BOUNDED_VARIATION_ON_ABS = store_thm ("HAS_BOUNDED_VARIATION_ON_ABS", 18059 ``!f:real->real. 18060 (\x. (f x)) has_bounded_variation_on s 18061 ==> (\x. (abs(f x))) has_bounded_variation_on s``, 18062 REPEAT GEN_TAC THEN 18063 MATCH_MP_TAC(ONCE_REWRITE_RULE[IMP_CONJ_ALT] 18064 HAS_BOUNDED_VARIATION_COMPARISON) THEN 18065 SIMP_TAC std_ss [dist] THEN REAL_ARITH_TAC); 18066 18067val VECTOR_VARIATION_COMPARISON = store_thm ("VECTOR_VARIATION_COMPARISON", 18068 ``!f:real->real g:real->real s. 18069 f has_bounded_variation_on s /\ 18070 (!x y. x IN s /\ y IN s /\ x < y 18071 ==> dist(g x,g y) <= dist(f x,f y)) 18072 ==> vector_variation s g <= vector_variation s f``, 18073 REPEAT STRIP_TAC THEN 18074 REWRITE_TAC[vector_variation] THEN 18075 MATCH_MP_TAC SET_VARIATION_COMPARISON THEN 18076 ASM_REWRITE_TAC[GSYM has_bounded_variation_on] THEN 18077 REPEAT STRIP_TAC THEN SIMP_TAC std_ss [GSYM dist] THEN 18078 SUBGOAL_THEN 18079 ``!x y. x IN s /\ y IN s 18080 ==> dist((g:real->real) x,g y) 18081 <= dist((f:real->real) x,f y)`` 18082 MATCH_MP_TAC THENL 18083 [KNOW_TAC ``!x y. (\x y:real. x IN s /\ y IN s ==> dist (g x,g y) <= dist (f x,f y)) x y`` THENL 18084 [ALL_TAC, METIS_TAC []] THEN 18085 MATCH_MP_TAC REAL_WLOG_LT THEN 18086 ASM_SIMP_TAC std_ss [DIST_REFL, REAL_LE_REFL] THEN 18087 MESON_TAC[DIST_SYM], 18088 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, 18089 INTERVAL_UPPERBOUND_NONEMPTY] THEN 18090 ASM_MESON_TAC[ENDS_IN_INTERVAL, SUBSET_DEF]]); 18091 18092val VECTOR_VARIATION_ABS = store_thm ("VECTOR_VARIATION_ABS", 18093 ``!f:real->real s. 18094 (\x. (f x)) has_bounded_variation_on s 18095 ==> vector_variation s (\x. (abs(f x))) 18096 <= vector_variation s (\x. (f x))``, 18097 REPEAT STRIP_TAC THEN 18098 MATCH_MP_TAC VECTOR_VARIATION_COMPARISON THEN 18099 ASM_SIMP_TAC std_ss [dist] THEN REAL_ARITH_TAC); 18100 18101val HAS_BOUNDED_VARIATION_ON_SUBSET = store_thm ("HAS_BOUNDED_VARIATION_ON_SUBSET", 18102 ``!f:real->real s t. 18103 f has_bounded_variation_on s /\ t SUBSET s 18104 ==> f has_bounded_variation_on t``, 18105 REWRITE_TAC[HAS_BOUNDED_SETVARIATION_ON_SUBSET, has_bounded_variation_on]); 18106 18107val HAS_BOUNDED_VARIATION_ON_CONST = store_thm ("HAS_BOUNDED_VARIATION_ON_CONST", 18108 ``!s c:real. (\x. c) has_bounded_variation_on s``, 18109 REWRITE_TAC[has_bounded_variation_on, REAL_SUB_REFL, 18110 HAS_BOUNDED_SETVARIATION_ON_0]); 18111 18112val VECTOR_VARIATION_CONST = store_thm ("VECTOR_VARIATION_CONST", 18113 ``!s c:real. vector_variation s (\x. c) = &0``, 18114 REWRITE_TAC[vector_variation, REAL_SUB_REFL, SET_VARIATION_0]); 18115 18116val HAS_BOUNDED_VARIATION_ON_CMUL = store_thm ("HAS_BOUNDED_VARIATION_ON_CMUL", 18117 ``!f:real->real c s. 18118 f has_bounded_variation_on s 18119 ==> (\x. c * f x) has_bounded_variation_on s``, 18120 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 18121 SIMP_TAC std_ss [GSYM REAL_SUB_LDISTRIB, HAS_BOUNDED_SETVARIATION_ON_CMUL]); 18122 18123val HAS_BOUNDED_VARIATION_ON_NEG = store_thm ("HAS_BOUNDED_VARIATION_ON_NEG", 18124 ``!f:real->real s. 18125 f has_bounded_variation_on s 18126 ==> (\x. -f x) has_bounded_variation_on s``, 18127 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 18128 SIMP_TAC std_ss [REAL_ARITH ``-a - -b:real = -(a - b)``, 18129 HAS_BOUNDED_SETVARIATION_ON_NEG]); 18130 18131val HAS_BOUNDED_VARIATION_ON_ADD = store_thm ("HAS_BOUNDED_VARIATION_ON_ADD", 18132 ``!f g:real->real s. 18133 f has_bounded_variation_on s /\ g has_bounded_variation_on s 18134 ==> (\x. f x + g x) has_bounded_variation_on s``, 18135 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 18136 SIMP_TAC std_ss [REAL_ARITH ``(f + g) - (f' + g'):real = (f - f') + (g - g')``, 18137 HAS_BOUNDED_SETVARIATION_ON_ADD]); 18138 18139val HAS_BOUNDED_VARIATION_ON_SUB = store_thm ("HAS_BOUNDED_VARIATION_ON_SUB", 18140 ``!f g:real->real s. 18141 f has_bounded_variation_on s /\ g has_bounded_variation_on s 18142 ==> (\x. f x - g x) has_bounded_variation_on s``, 18143 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 18144 SIMP_TAC std_ss [REAL_ARITH ``(f - g) - (f' - g'):real = (f - f') - (g - g')``, 18145 HAS_BOUNDED_SETVARIATION_ON_SUB]); 18146 18147val HAS_BOUNDED_VARIATION_ON_COMPOSE_LINEAR = store_thm ("HAS_BOUNDED_VARIATION_ON_COMPOSE_LINEAR", 18148 ``!f:real->real g:real->real s. 18149 f has_bounded_variation_on s /\ linear g 18150 ==> (g o f) has_bounded_variation_on s``, 18151 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 18152 SIMP_TAC std_ss [o_THM, GSYM LINEAR_SUB] THEN 18153 DISCH_THEN(MP_TAC o MATCH_MP HAS_BOUNDED_SETVARIATION_ON_COMPOSE_LINEAR) THEN 18154 SIMP_TAC std_ss [o_DEF]); 18155 18156val HAS_BOUNDED_VARIATION_ON_NULL = store_thm ("HAS_BOUNDED_VARIATION_ON_NULL", 18157 ``!f:real->real s. 18158 (content s = &0) /\ bounded s ==> f has_bounded_variation_on s``, 18159 REPEAT STRIP_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 18160 MATCH_MP_TAC HAS_BOUNDED_SETVARIATION_ON_NULL THEN 18161 ASM_SIMP_TAC std_ss [INTERVAL_BOUNDS_NULL, REAL_SUB_REFL]); 18162 18163val HAS_BOUNDED_VARIATION_ON_EMPTY = store_thm ("HAS_BOUNDED_VARIATION_ON_EMPTY", 18164 ``!f:real->real. f has_bounded_variation_on {}``, 18165 MESON_TAC[CONTENT_EMPTY, BOUNDED_EMPTY, HAS_BOUNDED_VARIATION_ON_NULL]); 18166 18167val VECTOR_VARIATION_ON_NULL = store_thm ("VECTOR_VARIATION_ON_NULL", 18168 ``!f s. (content s = &0) /\ bounded s ==> (vector_variation s f = &0)``, 18169 REPEAT STRIP_TAC THEN REWRITE_TAC[vector_variation] THEN 18170 MATCH_MP_TAC SET_VARIATION_ON_NULL THEN ASM_REWRITE_TAC[] THEN 18171 SIMP_TAC std_ss [INTERVAL_BOUNDS_NULL, REAL_SUB_REFL]); 18172 18173val HAS_BOUNDED_VARIATION_ON_ABS = store_thm ("HAS_BOUNDED_VARIATION_ON_ABS", 18174 ``!f:real->real s. 18175 f has_bounded_variation_on s 18176 ==> (\x. (abs(f x))) has_bounded_variation_on s``, 18177 REWRITE_TAC[has_bounded_variation_on, has_bounded_setvariation_on] THEN 18178 REPEAT GEN_TAC THEN DISCH_THEN (X_CHOOSE_TAC ``B:real``) THEN 18179 EXISTS_TAC ``B:real`` THEN POP_ASSUM MP_TAC THEN 18180 DISCH_TAC THEN GEN_TAC THEN GEN_TAC THEN 18181 POP_ASSUM (MP_TAC o SPECL [``d:(real->bool)->bool``,``t:real->bool``]) THEN 18182 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN ASM_SIMP_TAC std_ss [] THEN 18183 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LE_TRANS) THEN 18184 MATCH_MP_TAC SUM_LE THEN SIMP_TAC std_ss [] THEN 18185 CONJ_TAC THENL [ASM_MESON_TAC[DIVISION_OF_FINITE], REAL_ARITH_TAC]); 18186 18187Theorem HAS_BOUNDED_VARIATION_ON_MAX : 18188 !f g s. f has_bounded_variation_on s /\ g has_bounded_variation_on s 18189 ==> (\x. (max ((f x)) ((g x)))) 18190 has_bounded_variation_on s 18191Proof 18192 REPEAT STRIP_TAC THEN 18193 Know `!a b. max a b = inv(&2) * (a + b + abs(a - b:real))` 18194 >- (rpt GEN_TAC >> KILL_TAC \\ 18195 REWRITE_TAC [max_def] >> ONCE_REWRITE_TAC [REAL_MUL_SYM] \\ 18196 SIMP_TAC real_ss [GSYM real_div, REAL_EQ_RDIV_EQ] \\ 18197 Cases_on `a <= b` >> rw [] >> ASM_REAL_ARITH_TAC) \\ 18198 DISCH_TAC THEN 18199 FIRST_X_ASSUM (fn th => REWRITE_TAC [th]) THEN 18200 ONCE_REWRITE_TAC [METIS [] ``(\x. inv 2 * (f x + g x + abs (f x - g x:real))) = 18201 (\x. inv 2 * (\x. (f x + g x + abs (f x - g x))) x)``] THEN 18202 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_CMUL THEN 18203 ONCE_REWRITE_TAC [METIS [REAL_ADD_ASSOC] ``(\x. f x + g x + abs (f x - g x:real)) = 18204 (\x. f x + (\x. g x + abs (f x - g x)) x)``] THEN 18205 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_ADD THEN ASM_REWRITE_TAC[] THEN 18206 ONCE_REWRITE_TAC [METIS [REAL_ADD_ASSOC] ``(\x. g x + abs (f x - g x:real)) = 18207 (\x. g x + (\x. abs (f x - g x)) x)``] THEN 18208 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_ADD THEN ASM_REWRITE_TAC[] THEN 18209 ONCE_REWRITE_TAC [METIS [] ``(\x. abs (f x - g x:real)) = 18210 (\x. abs ((\x. (f x - g x)) x))``] THEN 18211 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_ABS THEN 18212 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_SUB THEN ASM_REWRITE_TAC[] 18213QED 18214 18215Theorem HAS_BOUNDED_VARIATION_ON_MIN : 18216 !f g s. f has_bounded_variation_on s /\ g has_bounded_variation_on s 18217 ==> (\x. (min ((f x)) ((g x)))) has_bounded_variation_on s 18218Proof 18219 REPEAT STRIP_TAC THEN 18220 Know `!a b. min a b = inv(&2) * ((a + b) - abs(a - b:real))` 18221 >- (rpt GEN_TAC >> KILL_TAC \\ 18222 REWRITE_TAC [min_def] >> ONCE_REWRITE_TAC [REAL_MUL_SYM] \\ 18223 SIMP_TAC real_ss [GSYM real_div, REAL_EQ_RDIV_EQ] \\ 18224 Cases_on `a <= b` >> rw [] >> ASM_REAL_ARITH_TAC) \\ 18225 DISCH_TAC THEN 18226 FIRST_X_ASSUM (fn th => REWRITE_TAC [th]) THEN 18227 ONCE_REWRITE_TAC [METIS [] ``(\x. inv 2 * (f x + g x - abs (f x - g x:real))) = 18228 (\x. inv 2 * (\x. (f x + g x - abs (f x - g x))) x)``] THEN 18229 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_CMUL THEN 18230 ONCE_REWRITE_TAC [METIS [REAL_ADD_ASSOC, real_sub] 18231 ``(\x. f x + g x - abs (f x - g x:real)) = 18232 (\x. (\x. f x + g x) x - (\x. abs (f x - g x)) x)``] THEN 18233 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_SUB THEN 18234 ASM_SIMP_TAC std_ss [HAS_BOUNDED_VARIATION_ON_ADD] THEN 18235 ONCE_REWRITE_TAC [METIS [] ``(\x. abs (f x - g x:real)) = 18236 (\x. abs ((\x. (f x - g x)) x))``] THEN 18237 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_ABS THEN 18238 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_SUB THEN ASM_REWRITE_TAC[] 18239QED 18240 18241val HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED_ON_SUBINTERVALS = store_thm ("HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED_ON_SUBINTERVALS", 18242 ``!f:real->real s. 18243 f has_bounded_variation_on s 18244 ==> bounded { f(d) - f(c) | interval[c,d] SUBSET s /\ 18245 ~(interval[c,d] = {})}``, 18246 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 18247 DISCH_THEN(MP_TAC o MATCH_MP 18248 HAS_BOUNDED_SETVARIATION_ON_IMP_BOUNDED_ON_SUBINTERVALS) THEN 18249 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] BOUNDED_SUBSET) THEN 18250 REWRITE_TAC [SUBSET_DEF] THEN SIMP_TAC std_ss [FORALL_IN_GSPEC] THEN 18251 MAP_EVERY X_GEN_TAC [``d:real``, ``c:real``] THEN 18252 FULL_SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT] THEN STRIP_TAC THEN 18253 SIMP_TAC std_ss [GSPECIFICATION, EXISTS_PROD] THEN 18254 MAP_EVERY EXISTS_TAC [``c:real``, ``d:real``] THEN 18255 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND]); 18256 18257val HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED = store_thm ("HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED", 18258 ``!f:real->real s. 18259 f has_bounded_variation_on s /\ is_interval s ==> bounded (IMAGE f s)``, 18260 REPEAT STRIP_TAC THEN ASM_CASES_TAC ``s:real->bool = {}`` THEN 18261 ASM_SIMP_TAC std_ss [IMAGE_EMPTY, IMAGE_INSERT, BOUNDED_EMPTY] THEN 18262 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [GSYM MEMBER_NOT_EMPTY]) THEN 18263 DISCH_THEN(X_CHOOSE_TAC ``a:real``) THEN FIRST_X_ASSUM(MP_TAC o MATCH_MP 18264 HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED_ON_SUBINTERVALS) THEN 18265 SIMP_TAC std_ss [bounded_def, FORALL_IN_GSPEC, FORALL_IN_IMAGE] THEN 18266 ASM_SIMP_TAC std_ss [INTERVAL_SUBSET_IS_INTERVAL, LEFT_IMP_EXISTS_THM, 18267 TAUT `(p \/ q) /\ ~p <=> ~p /\ q`] THEN 18268 X_GEN_TAC ``B:real`` THEN DISCH_TAC THEN 18269 EXISTS_TAC ``B + abs((f:real->real) a)`` THEN 18270 X_GEN_TAC ``b:real`` THEN DISCH_TAC THEN 18271 KNOW_TAC ``((!d c. ~(interval [c,d] = {}) \/ ~(interval [d,c] = {})) /\ 18272 (!d c. c IN s /\ d IN s ==> abs ((f:real->real) d - f c) <= B <=> 18273 d IN s /\ c IN s ==> abs (f c - f d) <= B) 18274 ==> (!d c. c IN s /\ d IN s ==> abs (f d - f c) <= B))`` THENL 18275 [METIS_TAC [], ALL_TAC] THEN 18276 FULL_SIMP_TAC std_ss [INTERVAL_NE_EMPTY, REAL_LE_TOTAL] THEN 18277 SIMP_TAC std_ss [ABS_SUB, CONJ_SYM] THEN 18278 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 18279 FULL_SIMP_TAC std_ss [] THEN REAL_ARITH_TAC); 18280 18281val HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED_ON_INTERVAL = store_thm ("HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED_ON_INTERVAL", 18282 ``!f:real->real a b. 18283 f has_bounded_variation_on interval[a,b] 18284 ==> bounded(IMAGE f (interval[a,b]))``, 18285 MESON_TAC[HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED, IS_INTERVAL_INTERVAL]); 18286 18287val HAS_BOUNDED_VARIATION_ON_MUL = store_thm ("HAS_BOUNDED_VARIATION_ON_MUL", 18288 ``!f g:real->real a b. 18289 f has_bounded_variation_on interval[a,b] /\ 18290 g has_bounded_variation_on interval[a,b] 18291 ==> (\x. (f x) * g x) has_bounded_variation_on interval[a,b]``, 18292 REPEAT GEN_TAC THEN DISCH_TAC THEN 18293 SUBGOAL_THEN 18294 ``bounded(IMAGE (f:real->real) (interval[a,b])) /\ 18295 bounded(IMAGE (g:real->real) (interval[a,b]))`` 18296 MP_TAC THENL 18297 [ASM_SIMP_TAC std_ss [HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED_ON_INTERVAL], 18298 SIMP_TAC std_ss [BOUNDED_POS_LT, FORALL_IN_IMAGE]] THEN 18299 DISCH_THEN(CONJUNCTS_THEN2 18300 (X_CHOOSE_THEN ``B1:real`` STRIP_ASSUME_TAC) 18301 (X_CHOOSE_THEN ``B2:real`` STRIP_ASSUME_TAC)) THEN 18302 FIRST_X_ASSUM(CONJUNCTS_THEN MP_TAC) THEN 18303 REWRITE_TAC[HAS_BOUNDED_SETVARIATION_ON_INTERVAL, 18304 has_bounded_variation_on] THEN 18305 DISCH_THEN(X_CHOOSE_THEN ``C2:real`` ASSUME_TAC) THEN 18306 DISCH_THEN(X_CHOOSE_THEN ``C1:real`` ASSUME_TAC) THEN 18307 EXISTS_TAC ``B1 * C2 + B2 * C1:real`` THEN 18308 X_GEN_TAC ``d:(real->bool)->bool`` THEN DISCH_TAC THEN 18309 FULL_SIMP_TAC std_ss [] THEN 18310 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 18311 ``B1 * sum d (\k. abs((g:real->real)(interval_upperbound k) - 18312 g(interval_lowerbound k))) + 18313 B2 * sum d (\k. abs((f:real->real)(interval_upperbound k) - 18314 f(interval_lowerbound k)))`` THEN 18315 CONJ_TAC THENL 18316 [ALL_TAC, MATCH_MP_TAC REAL_LE_ADD2 THEN ASM_SIMP_TAC std_ss [REAL_LE_LMUL]] THEN 18317 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 18318 ASM_SIMP_TAC std_ss [GSYM SUM_LMUL, GSYM SUM_ADD] THEN 18319 MATCH_MP_TAC SUM_LE THEN ASM_SIMP_TAC std_ss [] THEN 18320 UNDISCH_TAC ``d division_of interval [(a,b)]`` THEN DISCH_TAC THEN 18321 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 18322 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN DISCH_TAC THEN 18323 ONCE_REWRITE_TAC[REAL_ARITH 18324 ``f' * g' - f * g:real = f' * (g' - g) + (f' - f) * g``] THEN 18325 MATCH_MP_TAC(REAL_ARITH 18326 ``abs x <= a /\ abs y <= b ==> abs(x + y) <= a + b:real``) THEN 18327 SIMP_TAC std_ss [ABS_MUL] THEN 18328 SUBGOAL_THEN ``~(interval[u:real,v] = {})`` MP_TAC THENL 18329 [ASM_MESON_TAC[division_of], ALL_TAC] THEN 18330 REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT] THEN DISCH_TAC THEN 18331 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 18332 SUBGOAL_THEN ``interval[u:real,v] SUBSET interval[a,b]`` MP_TAC THENL 18333 [ASM_MESON_TAC[division_of], ALL_TAC] THEN 18334 ASM_SIMP_TAC std_ss [SUBSET_INTERVAL, GSYM REAL_NOT_LE] THEN 18335 STRIP_TAC THEN 18336 GEN_REWR_TAC (RAND_CONV o LAND_CONV) [REAL_MUL_SYM] THEN 18337 CONJ_TAC THEN MATCH_MP_TAC REAL_LE_RMUL_IMP THEN SIMP_TAC std_ss [ABS_POS] THEN 18338 MATCH_MP_TAC REAL_LT_IMP_LE THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 18339 REWRITE_TAC[IN_INTERVAL] THEN POP_ASSUM MP_TAC THEN 18340 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN REAL_ARITH_TAC); 18341 18342val VECTOR_VARIATION_POS_LE = store_thm ("VECTOR_VARIATION_POS_LE", 18343 ``!f:real->real s. 18344 f has_bounded_variation_on s ==> &0 <= vector_variation s f``, 18345 REWRITE_TAC[has_bounded_variation_on, vector_variation] THEN 18346 SIMP_TAC std_ss [SET_VARIATION_POS_LE]); 18347 18348val VECTOR_VARIATION_GE_ABS_FUNCTION = store_thm ("VECTOR_VARIATION_GE_ABS_FUNCTION", 18349 ``!f:real->real s a b. 18350 f has_bounded_variation_on s /\ segment[a,b] SUBSET s 18351 ==> abs(f b - f a) <= vector_variation s f``, 18352 GEN_TAC THEN GEN_TAC THEN 18353 ONCE_REWRITE_TAC [METIS [] ``(!a b. 18354 f has_bounded_variation_on s /\ segment [(a,b)] SUBSET s ==> 18355 abs (f b - f a) <= vector_variation s f) = 18356 (!a b. 18357 (\a b. f has_bounded_variation_on s /\ segment [(a,b)] SUBSET s ==> 18358 abs (f b - f a) <= vector_variation s f) a b)``] THEN 18359 MATCH_MP_TAC REAL_WLOG_LE THEN CONJ_TAC THENL 18360 [MESON_TAC[SEGMENT_SYM, ABS_SUB], ALL_TAC] THEN 18361 SIMP_TAC std_ss [has_bounded_variation_on] THEN 18362 REPEAT STRIP_TAC THEN MP_TAC(ISPECL 18363 [``\k. (f:real->real)(interval_upperbound k) - f(interval_lowerbound k)``, 18364 ``s:real->bool``, ``x:real``, ``y:real``] SET_VARIATION_GE_FUNCTION) THEN 18365 ASM_SIMP_TAC std_ss [vector_variation, INTERVAL_NE_EMPTY] THEN 18366 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND] THEN 18367 METIS_TAC[SEGMENT]); 18368 18369val VECTOR_VARIATION_GE_FUNCTION = store_thm ("VECTOR_VARIATION_GE_FUNCTION", 18370 ``!f s a b. 18371 f has_bounded_variation_on s /\ segment[a,b] SUBSET s 18372 ==> (f b) - (f a) <= vector_variation s f``, 18373 REPEAT STRIP_TAC THEN MATCH_MP_TAC REAL_LE_TRANS THEN 18374 EXISTS_TAC ``abs((f:real->real) b - f a)`` THEN 18375 ASM_SIMP_TAC std_ss [VECTOR_VARIATION_GE_ABS_FUNCTION] THEN 18376 SIMP_TAC std_ss [] THEN REAL_ARITH_TAC); 18377 18378val CONVEX_CONTAINS_SEGMENT = store_thm ("CONVEX_CONTAINS_SEGMENT", 18379 ``!s. convex s <=> !a b. a IN s /\ b IN s ==> segment[a,b] SUBSET s``, 18380 SIMP_TAC std_ss [CONVEX_ALT, segment, SUBSET_DEF, GSPECIFICATION] THEN 18381 MESON_TAC[]); 18382 18383val VECTOR_VARIATION_CONST_EQ = store_thm ("VECTOR_VARIATION_CONST_EQ", 18384 ``!f:real->real s. 18385 is_interval s /\ f has_bounded_variation_on s 18386 ==> ((vector_variation s f = &0) <=> ?c. !x. x IN s ==> (f x = c))``, 18387 REPEAT STRIP_TAC THEN EQ_TAC THENL 18388 [DISCH_TAC THEN REWRITE_TAC [SPECIFICATION] THEN 18389 REWRITE_TAC[METIS[] 18390 ``(?c. !x. P x ==> (f x = c)) <=> !a b. P a /\ P b ==> (f a = f b)``] THEN 18391 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN STRIP_TAC THEN 18392 MP_TAC(ISPECL [``f:real->real``, ``s:real->bool``, 18393 ``a:real``, ``b:real``] VECTOR_VARIATION_GE_ABS_FUNCTION) THEN 18394 KNOW_TAC ``f has_bounded_variation_on s /\ segment [(a,b)] SUBSET s`` THENL 18395 [ASM_SIMP_TAC std_ss [] THEN `convex s` by METIS_TAC [IS_INTERVAL_CONVEX] THEN 18396 FULL_SIMP_TAC std_ss [CONVEX_CONTAINS_SEGMENT] THEN 18397 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC std_ss [SPECIFICATION], 18398 DISCH_TAC THEN ASM_REWRITE_TAC[] THEN REAL_ARITH_TAC], 18399 ALL_TAC] THEN 18400 DISCH_THEN(X_CHOOSE_TAC ``c:real``) THEN 18401 MP_TAC(ISPECL [``f:real->real``, ``(\x. c):real->real``, 18402 ``s:real->bool``] VECTOR_VARIATION_EQ) THEN 18403 ASM_SIMP_TAC std_ss [VECTOR_VARIATION_CONST]); 18404 18405val VECTOR_VARIATION_MONOTONE = store_thm ("VECTOR_VARIATION_MONOTONE", 18406 ``!f s t. f has_bounded_variation_on s /\ t SUBSET s 18407 ==> vector_variation t f <= vector_variation s f``, 18408 REWRITE_TAC[has_bounded_variation_on, vector_variation] THEN 18409 REWRITE_TAC[SET_VARIATION_MONOTONE]); 18410 18411val VECTOR_VARIATION_NEG = store_thm ("VECTOR_VARIATION_NEG", 18412 ``!f:real->real s. 18413 vector_variation s (\x. -(f x)) = vector_variation s f``, 18414 REPEAT GEN_TAC THEN REWRITE_TAC[vector_variation, set_variation] THEN 18415 SIMP_TAC std_ss [REAL_ARITH ``abs(-x - -y:real) = abs(x - y)``]); 18416 18417val VECTOR_VARIATION_TRIANGLE = store_thm ("VECTOR_VARIATION_TRIANGLE", 18418 ``!f g:real->real s. 18419 f has_bounded_variation_on s /\ g has_bounded_variation_on s 18420 ==> vector_variation s (\x. f x + g x) 18421 <= vector_variation s f + vector_variation s g``, 18422 REPEAT GEN_TAC THEN 18423 REWRITE_TAC[has_bounded_variation_on, vector_variation] THEN 18424 DISCH_THEN(MP_TAC o MATCH_MP SET_VARIATION_TRIANGLE) THEN 18425 SIMP_TAC std_ss [REAL_ARITH ``(a + b) - (c + d):real = (a - c) + (b - d)``]); 18426 18427val HAS_BOUNDED_VARIATION_ON_SUM_AND_SUM_LE = store_thm ("HAS_BOUNDED_VARIATION_ON_SUM_AND_SUM_LE", 18428 ``(!f:'a->real->real s k. 18429 FINITE k /\ 18430 (!i. i IN k ==> f i has_bounded_variation_on s) 18431 ==> (\x. sum k (\i. f i x)) has_bounded_variation_on s) /\ 18432 (!f:'a->real->real s k. 18433 FINITE k /\ 18434 (!i. i IN k ==> f i has_bounded_variation_on s) 18435 ==> vector_variation s (\x. sum k (\i. f i x)) 18436 <= sum k (\i. vector_variation s (f i)))``, 18437 SIMP_TAC std_ss [GSYM FORALL_AND_THM, TAUT 18438 `(p ==> q) /\ (p ==> r) <=> p ==> q /\ r`] THEN 18439 GEN_TAC THEN GEN_TAC THEN REWRITE_TAC[IMP_CONJ] THEN 18440 ONCE_REWRITE_TAC [METIS [] 18441 ``!k. ((!i. i IN k ==> f i has_bounded_variation_on s) ==> 18442 (\x. sum k (\i. f i x)) has_bounded_variation_on s /\ 18443 vector_variation s (\x. sum k (\i. f i x)) <= 18444 sum k (\i. vector_variation s (f i))) = 18445 (\k. (!i. i IN k ==> f i has_bounded_variation_on s) ==> 18446 (\x. sum k (\i. f i x)) has_bounded_variation_on s /\ 18447 vector_variation s (\x. sum k (\i. f i x)) <= 18448 sum k (\i. vector_variation s (f i))) k``] THEN 18449 MATCH_MP_TAC FINITE_INDUCT THEN BETA_TAC THEN 18450 SIMP_TAC std_ss [SUM_CLAUSES, FORALL_IN_INSERT] THEN 18451 SIMP_TAC std_ss [VECTOR_VARIATION_CONST, REAL_LE_REFL, 18452 HAS_BOUNDED_VARIATION_ON_CONST, 18453 HAS_BOUNDED_VARIATION_ON_ADD, ETA_AX] THEN 18454 REPEAT STRIP_TAC THENL 18455 [ONCE_REWRITE_TAC [METIS [] `` (\x. f e x + sum s' (\i. f i x)) = 18456 (\x. (\x. f e x) x + (\x. sum s' (\i. f i x)) x)``] THEN 18457 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_ADD THEN 18458 METIS_TAC [HAS_BOUNDED_VARIATION_ON_ADD, ETA_AX], ALL_TAC] THEN 18459 ONCE_REWRITE_TAC [METIS [] `` (\x. f e x + sum s' (\i. f i x)) = 18460 (\x. (\x. f e x) x + (\x. sum s' (\i. f i x)) x)``] THEN 18461 W(MP_TAC o PART_MATCH (lhand o rand) 18462 VECTOR_VARIATION_TRIANGLE o lhand o snd) THEN 18463 ASM_SIMP_TAC std_ss [METIS [ETA_AX] ``(\x. (f:'a->real->real) e x) = f e``] THEN 18464 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] REAL_LE_TRANS) THEN 18465 ASM_SIMP_TAC std_ss [REAL_LE_LADD]); 18466 18467val HAS_BOUNDED_VARIATION_ON_SUM = store_thm ("HAS_BOUNDED_VARIATION_ON_SUM", 18468 ``(!f:'a->real->real s k. 18469 FINITE k /\ 18470 (!i. i IN k ==> f i has_bounded_variation_on s) 18471 ==> (\x. sum k (\i. f i x)) has_bounded_variation_on s)``, 18472 REWRITE_TAC [HAS_BOUNDED_VARIATION_ON_SUM_AND_SUM_LE]); 18473 18474val HAS_BOUNDED_VARIATION_SUM_LE = store_thm ("HAS_BOUNDED_VARIATION_SUM_LE", 18475 ``(!f:'a->real->real s k. 18476 FINITE k /\ 18477 (!i. i IN k ==> f i has_bounded_variation_on s) 18478 ==> vector_variation s (\x. sum k (\i. f i x)) 18479 <= sum k (\i. vector_variation s (f i)))``, 18480 REWRITE_TAC [HAS_BOUNDED_VARIATION_ON_SUM_AND_SUM_LE]); 18481 18482Theorem OPERATIVE_FUNCTION_ENDPOINT_DIFF : 18483 !f:real->real. 18484 operative (+) (\k. f (interval_upperbound k) - f (interval_lowerbound k)) 18485Proof 18486 GEN_TAC THEN 18487 SIMP_TAC std_ss [operative, INTERVAL_BOUNDS_NULL, REAL_SUB_REFL] THEN 18488 REWRITE_TAC[NEUTRAL_REAL_ADD] THEN 18489 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``, ``c:real``] THEN 18490 ASM_CASES_TAC ``interval[a:real,b] = {}`` THENL 18491 [ASM_REWRITE_TAC[INTER_EMPTY, INTERVAL_BOUNDS_EMPTY] THEN 18492 REAL_ARITH_TAC, 18493 ALL_TAC] THEN 18494 ASM_CASES_TAC ``interval[a,b] INTER {x | x <= c} = {}`` THENL 18495 [ASM_REWRITE_TAC[INTERVAL_BOUNDS_EMPTY, REAL_SUB_REFL] THEN 18496 SUBGOAL_THEN ``interval[a,b] INTER {x | x >= c} = interval[a,b]`` 18497 (fn th => REWRITE_TAC[th, REAL_ADD_LID]) THEN 18498 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (SET_RULE 18499 ``(i INTER s = {}) ==> (s UNION t = UNIV) ==> (i INTER t = i)``)) THEN 18500 SIMP_TAC std_ss [EXTENSION, IN_UNIV, IN_UNION, GSPECIFICATION] THEN 18501 REAL_ARITH_TAC, 18502 ALL_TAC] THEN 18503 ASM_CASES_TAC ``interval[a,b] INTER {x | x >= c} = {}`` THENL 18504 [ASM_REWRITE_TAC[INTERVAL_BOUNDS_EMPTY, REAL_SUB_REFL] THEN 18505 SUBGOAL_THEN ``interval[a,b] INTER {x | x <= c} = interval[a,b]`` 18506 (fn th => REWRITE_TAC[th, REAL_ADD_RID]) THEN 18507 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (SET_RULE 18508 ``(i INTER s = {}) ==> (s UNION t = UNIV) ==> (i INTER t = i)``)) THEN 18509 SIMP_TAC std_ss [EXTENSION, IN_UNIV, IN_UNION, GSPECIFICATION] THEN 18510 REAL_ARITH_TAC, 18511 ALL_TAC] THEN 18512 POP_ASSUM_LIST(MP_TAC o end_itlist CONJ) THEN 18513 SIMP_TAC std_ss [INTERVAL_SPLIT, LESS_EQ_REFL] THEN 18514 REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT] THEN 18515 SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND] THEN 18516 SIMP_TAC std_ss [LESS_EQ_REFL] THEN STRIP_TAC THEN 18517 MATCH_MP_TAC(REAL_ARITH 18518 ``(fx:real = fy) ==> (fb - fa = fx - fa + (fb - fy))``) THEN 18519 AP_TERM_TAC THEN 18520 FULL_SIMP_TAC std_ss [min_def, max_def] THEN 18521 Cases_on `b <= c` >> Cases_on `a <= c` >> fs [] \\ 18522 ASM_REAL_ARITH_TAC 18523QED 18524 18525val OPERATIVE_REAL_FUNCTION_ENDPOINT_DIFF = store_thm ("OPERATIVE_REAL_FUNCTION_ENDPOINT_DIFF", 18526 ``!f:real->real. 18527 operative (+) (\k. f (interval_upperbound k) - f (interval_lowerbound k))``, 18528 GEN_TAC THEN 18529 MP_TAC(ISPEC ``(f:real->real)`` OPERATIVE_FUNCTION_ENDPOINT_DIFF) THEN 18530 REWRITE_TAC[operative, NEUTRAL_REAL_ADD] THEN REWRITE_TAC[o_THM]); 18531 18532val OPERATIVE_LIFTED_VECTOR_VARIATION = store_thm ("OPERATIVE_LIFTED_VECTOR_VARIATION", 18533 ``!f:real->real. 18534 operative (lifted(+)) 18535 (\i. if f has_bounded_variation_on i 18536 then SOME(vector_variation i f) else NONE)``, 18537 GEN_TAC THEN REWRITE_TAC[has_bounded_variation_on, vector_variation] THEN 18538 MATCH_MP_TAC OPERATIVE_LIFTED_SETVARIATION THEN 18539 REWRITE_TAC[OPERATIVE_FUNCTION_ENDPOINT_DIFF]); 18540 18541val HAS_BOUNDED_VARIATION_ON_DIVISION = store_thm ("HAS_BOUNDED_VARIATION_ON_DIVISION", 18542 ``!f:real->real a b d. 18543 d division_of interval[a,b] 18544 ==> ((!k. k IN d ==> f has_bounded_variation_on k) <=> 18545 f has_bounded_variation_on interval[a,b])``, 18546 REPEAT STRIP_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 18547 MATCH_MP_TAC HAS_BOUNDED_SETVARIATION_ON_DIVISION THEN 18548 ASM_REWRITE_TAC[OPERATIVE_FUNCTION_ENDPOINT_DIFF]); 18549 18550val VECTOR_VARIATION_ON_DIVISION = store_thm ("VECTOR_VARIATION_ON_DIVISION", 18551 ``!f:real->real a b d. 18552 d division_of interval[a,b] /\ 18553 f has_bounded_variation_on interval[a,b] 18554 ==> (sum d (\k. vector_variation k f) = 18555 vector_variation (interval[a,b]) f)``, 18556 REPEAT STRIP_TAC THEN REWRITE_TAC[vector_variation] THEN 18557 MATCH_MP_TAC SET_VARIATION_ON_DIVISION THEN 18558 ASM_REWRITE_TAC[OPERATIVE_FUNCTION_ENDPOINT_DIFF, GSYM 18559 has_bounded_variation_on]); 18560 18561val HAS_BOUNDED_VARIATION_ON_COMBINE = store_thm ("HAS_BOUNDED_VARIATION_ON_COMBINE", 18562 ``!f:real->real a b c. 18563 a <= c /\ c <= b 18564 ==> (f has_bounded_variation_on interval[a,b] <=> 18565 f has_bounded_variation_on interval[a,c] /\ 18566 f has_bounded_variation_on interval[c,b])``, 18567 REPEAT STRIP_TAC THEN MP_TAC 18568 (ISPEC ``f:real->real`` OPERATIVE_LIFTED_VECTOR_VARIATION) THEN 18569 REWRITE_TAC[operative] THEN 18570 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``, ``c:real``] o 18571 CONJUNCT2) THEN ASM_SIMP_TAC std_ss [] THEN 18572 SUBGOAL_THEN 18573 ``(interval[a,b] INTER {x:real | x <= c} = interval[a,c]) /\ 18574 (interval[a,b] INTER {x:real | x >= c} = interval[c,b])`` 18575 (fn th => REWRITE_TAC[th]) 18576 THENL 18577 [SIMP_TAC std_ss [EXTENSION, IN_INTER, IN_INTERVAL, GSPECIFICATION] THEN 18578 ASM_REAL_ARITH_TAC, 18579 REPEAT(COND_CASES_TAC THEN 18580 ASM_SIMP_TAC std_ss [NOT_NONE_SOME, lifted])]); 18581 18582Theorem VECTOR_VARIATION_COMBINE : 18583 !f:real->real a b c. 18584 a <= c /\ c <= b /\ 18585 f has_bounded_variation_on interval[a,b] 18586 ==> (vector_variation (interval[a,c]) f + 18587 vector_variation (interval[c,b]) f = 18588 vector_variation (interval[a,b]) f) 18589Proof 18590 REPEAT STRIP_TAC THEN MP_TAC 18591 (ISPEC ``f:real->real`` OPERATIVE_LIFTED_VECTOR_VARIATION) THEN 18592 REWRITE_TAC[operative] THEN 18593 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``, ``c:real``] o 18594 CONJUNCT2) THEN ASM_SIMP_TAC std_ss [] THEN REPEAT(COND_CASES_TAC THENL 18595 [ALL_TAC, 18596 ASM_MESON_TAC[HAS_BOUNDED_VARIATION_ON_SUBSET, INTER_SUBSET]]) THEN 18597 REWRITE_TAC[lifted, SOME_11] THEN DISCH_THEN SUBST1_TAC THEN 18598 SIMP_TAC std_ss [INTERVAL_SPLIT, LESS_EQ_REFL] THEN 18599 BINOP_TAC THEN AP_THM_TAC THEN AP_TERM_TAC THEN 18600 SIMP_TAC std_ss [EXTENSION, IN_INTERVAL, LESS_EQ_REFL] THEN 18601 RW_TAC real_ss [min_def, max_def] THEN ASM_REAL_ARITH_TAC 18602QED 18603 18604val VECTOR_VARIATION_MINUS_FUNCTION_MONOTONE = store_thm ("VECTOR_VARIATION_MINUS_FUNCTION_MONOTONE", 18605 ``!f a b c d. 18606 f has_bounded_variation_on interval[a,b] /\ 18607 interval[c,d] SUBSET interval[a,b] /\ ~(interval[c,d] = {}) 18608 ==> vector_variation (interval[c,d]) f - (f d - f c) <= 18609 vector_variation (interval[a,b]) f - (f b - f a)``, 18610 REWRITE_TAC[SUBSET_INTERVAL, GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT] THEN 18611 REPEAT STRIP_TAC THEN 18612 SUBGOAL_THEN 18613 ``(f c) - (f a) <= vector_variation(interval[a,c]) f /\ 18614 (f b) - (f d) <= vector_variation(interval[d,b]) f`` 18615 MP_TAC THENL 18616 [CONJ_TAC THEN MATCH_MP_TAC VECTOR_VARIATION_GE_FUNCTION THEN 18617 ASM_SIMP_TAC std_ss [SEGMENT, SUBSET_INTERVAL, GSYM INTERVAL_EQ_EMPTY] THEN 18618 (CONJ_TAC THENL [ALL_TAC, ASM_REAL_ARITH_TAC]) THEN 18619 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 18620 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 18621 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_REAL_ARITH_TAC, 18622 ALL_TAC] THEN 18623 MP_TAC(ISPEC ``f:real->real`` VECTOR_VARIATION_COMBINE) THEN 18624 DISCH_THEN(fn th => 18625 MP_TAC(SPECL [``a:real``, ``b:real``, ``d:real``] th) THEN 18626 MP_TAC(SPECL [``a:real``, ``d:real``, ``c:real``] th)) THEN 18627 ASM_SIMP_TAC std_ss [] THEN 18628 KNOW_TAC ``(f :real -> real) has_bounded_variation_on 18629 interval [((a :real),(d :real))]`` THENL 18630 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 18631 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 18632 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_REAL_ARITH_TAC, 18633 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 18634 ASM_REAL_ARITH_TAC]); 18635 18636val HAS_BOUNDED_VARIATION_NONTRIVIAL = store_thm ("HAS_BOUNDED_VARIATION_NONTRIVIAL", 18637 ``!f:real->real s. 18638 f has_bounded_variation_on s <=> 18639 ?B. !d t. 18640 d division_of t /\ t SUBSET s /\ 18641 (!k. k IN d ==> ~(interior k = {})) 18642 ==> sum d (\k. abs(f(interval_upperbound k) - 18643 f (interval_lowerbound k))) <= B``, 18644 REPEAT GEN_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 18645 REWRITE_TAC[has_bounded_setvariation_on] THEN 18646 AP_TERM_TAC THEN GEN_REWR_TAC I [FUN_EQ_THM] THEN 18647 X_GEN_TAC ``B:real`` THEN SIMP_TAC std_ss [] THEN 18648 EQ_TAC THENL [METIS_TAC[], DISCH_TAC] THEN 18649 MAP_EVERY X_GEN_TAC [``d:(real->bool)->bool``, ``t:real->bool``] THEN 18650 STRIP_TAC THEN 18651 ABBREV_TAC ``d' = {k:real->bool | k IN d /\ ~(interior k = {})}`` THEN 18652 FIRST_X_ASSUM(MP_TAC o SPECL 18653 [``d':(real->bool)->bool``, ``BIGUNION d':real->bool``]) THEN 18654 KNOW_TAC ``(d' :(real -> bool) -> bool) division_of BIGUNION d' /\ 18655 BIGUNION d' SUBSET (s :real -> bool) /\ 18656 (!(k :real -> bool). k IN d' ==> interior k <> ({} :real -> bool))`` THENL 18657 [EXPAND_TAC "d'" THEN SIMP_TAC std_ss [GSPECIFICATION] THEN CONJ_TAC THENL 18658 [MATCH_MP_TAC DIVISION_OF_SUBSET THEN 18659 EXISTS_TAC ``d:(real->bool)->bool`` THEN 18660 SIMP_TAC std_ss [SUBSET_RESTRICT] THEN ASM_MESON_TAC[DIVISION_OF_UNION_SELF], 18661 MATCH_MP_TAC SUBSET_TRANS THEN EXISTS_TAC ``t:real->bool`` THEN ASM_SIMP_TAC std_ss [] THEN 18662 MATCH_MP_TAC SUBSET_TRANS THEN EXISTS_TAC ``BIGUNION d:real->bool`` THEN CONJ_TAC THENL 18663 [MATCH_MP_TAC SUBSET_BIGUNION THEN ASM_SET_TAC[], 18664 ASM_MESON_TAC[division_of, SUBSET_REFL]]], 18665 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 18666 MATCH_MP_TAC(REAL_ARITH ``(y:real = x) ==> x <= b ==> y <= b``) THEN 18667 MATCH_MP_TAC SUM_SUPERSET THEN EXPAND_TAC "d'" THEN 18668 ASM_SIMP_TAC real_ss [SUBSET_RESTRICT, GSPECIFICATION, TAUT 18669 `p /\ ~(p /\ ~q) ==> r <=> p ==> q ==> r`] THEN 18670 GEN_TAC THEN STRIP_TAC THEN POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 18671 UNDISCH_TAC ``d division_of t`` THEN DISCH_TAC THEN 18672 SPEC_TAC (``x:real->bool``,``x:real->bool``) THEN 18673 FIRST_ASSUM(fn th => 18674 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 18675 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, INTERVAL_UPPERBOUND_NONEMPTY] THEN 18676 SIMP_TAC std_ss [INTERIOR_INTERVAL, INTERVAL_NE_EMPTY] THEN 18677 SIMP_TAC std_ss [GSYM INTERVAL_EQ_EMPTY, AND_IMP_INTRO, GSYM CONJ_ASSOC] THEN 18678 SIMP_TAC std_ss [REAL_LE_ANTISYM, REAL_SUB_REFL, ABS_0]]); 18679 18680val INCREASING_BOUNDED_VARIATION_GEN = store_thm ("INCREASING_BOUNDED_VARIATION_GEN", 18681 ``!f s. 18682 bounded(IMAGE f s) /\ 18683 (!x y. x IN s /\ y IN s /\ x <= y ==> (f x) <= (f y)) 18684 ==> f has_bounded_variation_on s``, 18685 REPEAT STRIP_TAC THEN REWRITE_TAC[HAS_BOUNDED_VARIATION_NONTRIVIAL] THEN 18686 UNDISCH_TAC ``(bounded (IMAGE (f :real -> real) (s :real -> bool)) :bool)`` THEN 18687 DISCH_TAC THEN FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [BOUNDED_POS]) THEN 18688 SIMP_TAC std_ss [FORALL_IN_IMAGE] THEN 18689 DISCH_THEN(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) THEN 18690 EXISTS_TAC ``&2 * B:real`` THEN REPEAT STRIP_TAC THEN 18691 MP_TAC(ISPECL [``d:(real->bool)->bool``, ``t:real->bool``] 18692 DIVISION_1_SORT) THEN 18693 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 18694 MAP_EVERY X_GEN_TAC [``n:num``, ``t:num->real->bool``] THEN STRIP_TAC THEN 18695 EXPAND_TAC "d" THEN 18696 KNOW_TAC ``sum ((1:num)..n) 18697 ((\k. abs (f (interval_upperbound k) - f (interval_lowerbound k))) o t) <= 18698 &2 * (B:real) /\ 18699 (!x y. x IN ((1:num)..n) /\ y IN ((1:num)..n) /\ (t x = t y) ==> (x = y))`` THENL 18700 [ALL_TAC, METIS_TAC [SUM_IMAGE]] THEN 18701 CONJ_TAC THENL [SIMP_TAC std_ss [o_DEF], ASM_MESON_TAC[LT_CASES]] THEN 18702 SUBGOAL_THEN 18703 ``!k. k IN d 18704 ==> interval_lowerbound (k:real->bool) IN k INTER s /\ 18705 interval_upperbound k IN k INTER s /\ 18706 (interval_lowerbound k) <= (interval_upperbound k)`` 18707 MP_TAC THENL 18708 [UNDISCH_TAC ``d division_of t`` THEN DISCH_TAC THEN 18709 FIRST_ASSUM(fn th => 18710 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 18711 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, INTERVAL_UPPERBOUND_NONEMPTY] THEN 18712 REWRITE_TAC[IN_INTER] THEN 18713 ASM_MESON_TAC[division_of, ENDS_IN_INTERVAL, SUBSET_DEF, INTERVAL_NE_EMPTY], 18714 EXPAND_TAC "d" THEN SIMP_TAC std_ss [FORALL_IN_IMAGE, IN_INTER] THEN 18715 STRIP_TAC] THEN 18716 SUBGOAL_THEN 18717 ``!m. 1 <= m /\ m <= n 18718 ==> sum((1:num)..m) (\i. abs(f(interval_upperbound(t i)) - 18719 (f:real->real)(interval_lowerbound(t i)))) 18720 <= (f(interval_upperbound(t m))) - (f(interval_lowerbound(t 1)))`` 18721 (MP_TAC o SPEC ``n:num``) 18722 THENL 18723 [KNOW_TAC ``!(m :num). 18724 (\m. (1 :num) <= m /\ m <= (n :num) ==> 18725 sum ((1 :num) .. m) 18726 (\(i :num). abs 18727 ((f :real -> real) 18728 (interval_upperbound ((t :num -> real -> bool) i)) - 18729 f (interval_lowerbound (t i)))) <= 18730 f (interval_upperbound (t m)) - f (interval_lowerbound (t (1 :num)))) m`` THENL 18731 [ALL_TAC, METIS_TAC []] THEN 18732 MATCH_MP_TAC INDUCTION THEN 18733 SIMP_TAC arith_ss [SUM_CLAUSES_NUMSEG] THEN 18734 X_GEN_TAC ``m:num`` THEN 18735 ASM_CASES_TAC ``m = 0:num`` THEN ASM_SIMP_TAC arith_ss [SUM_CLAUSES_NUMSEG] THENL 18736 [DISCH_TAC THEN MATCH_MP_TAC(REAL_ARITH ``(x = y) ==> &0 + x <= y:real``) THEN 18737 MATCH_MP_TAC(REAL_ARITH 18738 ``y <= x ==> (abs(x - y) = x - y:real)``) THEN 18739 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_MESON_TAC[IN_NUMSEG, LESS_EQ_REFL], 18740 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 18741 KNOW_TAC ``1 <= SUC m:num`` THENL [ASM_SIMP_TAC arith_ss [], DISCH_TAC] THEN 18742 KNOW_TAC ``m <= n:num`` THENL 18743 [ASM_SIMP_TAC arith_ss [], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 18744 POP_ASSUM K_TAC] THEN MATCH_MP_TAC(REAL_ARITH 18745 ``b + x <= y ==> s <= b ==> s + x <= y:real``) THEN 18746 MATCH_MP_TAC(REAL_ARITH 18747 ``um <= ls /\ ls <= us ==> (um - l1) + abs(us - ls) <= us - l1:real``) THEN 18748 CONJ_TAC THENL 18749 [FIRST_X_ASSUM MATCH_MP_TAC, METIS_TAC[IN_NUMSEG]] THEN 18750 REPEAT(CONJ_TAC THENL 18751 [ASM_MESON_TAC[IN_NUMSEG, LE_1, ARITH_PROVE ``SUC m <= n ==> m <= n``], 18752 ALL_TAC]) THEN 18753 FIRST_X_ASSUM(MP_TAC o SPECL [``m:num``, ``SUC m``]) THEN 18754 REWRITE_TAC[IN_NUMSEG] THEN 18755 KNOW_TAC ``(1 <= m /\ m <= n) /\ (1 <= SUC m /\ SUC m <= n) /\ m < SUC m`` THENL 18756 [ASM_SIMP_TAC arith_ss [], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 18757 POP_ASSUM K_TAC THEN DISCH_THEN(MATCH_MP_TAC o CONJUNCT2)] THEN 18758 ASM_MESON_TAC[IN_NUMSEG, LE_1, ARITH_PROVE ``SUC m <= n ==> m <= n``]], 18759 ASM_CASES_TAC ``n = 0:num`` THENL 18760 [ASM_SIMP_TAC arith_ss [SUM_CLAUSES_NUMSEG] THEN 18761 UNDISCH_TAC ``0 < B:real`` THEN REAL_ARITH_TAC, 18762 ASM_SIMP_TAC std_ss [LE_1, LESS_EQ_REFL]] THEN 18763 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] REAL_LE_TRANS) THEN 18764 MATCH_MP_TAC(REAL_ARITH ``(abs(x) <= B /\ abs(y) <= B) 18765 ==> x - y <= &2 * B:real``) THEN 18766 CONJ_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 18767 ASM_MESON_TAC[IN_NUMSEG, LESS_EQ_REFL, LE_1]]); 18768 18769val DECREASING_BOUNDED_VARIATION_GEN = store_thm ("DECREASING_BOUNDED_VARIATION_GEN", 18770 ``!f s. 18771 bounded(IMAGE f s) /\ 18772 (!x y. x IN s /\ y IN s /\ x <= y ==> (f y) <= (f x)) 18773 ==> f has_bounded_variation_on s``, 18774 REPEAT STRIP_TAC THEN 18775 MP_TAC(SPECL [``(\x. -x) o (f:real->real)``, ``s:real->bool``] 18776 INCREASING_BOUNDED_VARIATION_GEN) THEN 18777 ASM_SIMP_TAC std_ss [REAL_LE_NEG2] THEN 18778 ASM_SIMP_TAC std_ss [BOUNDED_NEGATIONS, IMAGE_COMPOSE] THEN 18779 DISCH_THEN(MP_TAC o MATCH_MP HAS_BOUNDED_VARIATION_ON_NEG) THEN 18780 METIS_TAC[o_DEF, REAL_NEG_NEG, ETA_AX]); 18781 18782Theorem INCREASING_BOUNDED_VARIATION : 18783 !f a b. 18784 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 18785 ==> (f x) <= (f y)) 18786 ==> f has_bounded_variation_on interval[a,b] 18787Proof 18788 REPEAT STRIP_TAC THEN MATCH_MP_TAC INCREASING_BOUNDED_VARIATION_GEN THEN 18789 ASM_SIMP_TAC std_ss [bounded_def, FORALL_IN_IMAGE] THEN EXISTS_TAC 18790 ``max (abs((f:real->real) a)) (abs((f:real->real) b))`` THEN 18791 X_GEN_TAC ``x:real`` THEN DISCH_TAC THEN FIRST_X_ASSUM(fn th => 18792 MP_TAC(SPECL [``a:real``, ``x:real``] th) THEN 18793 MP_TAC(SPECL [``x:real``, ``b:real``] th)) THEN 18794 ASM_SIMP_TAC std_ss [ENDS_IN_INTERVAL, INTERVAL_NE_EMPTY] THEN 18795 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [IN_INTERVAL]) THEN 18796 RW_TAC real_ss [max_def] THEN 18797 `a <= b` by PROVE_TAC [REAL_LE_TRANS] >> RES_TAC \\ 18798 REAL_ASM_ARITH_TAC 18799QED 18800 18801val DECREASING_BOUNDED_VARIATION = store_thm ("DECREASING_BOUNDED_VARIATION", 18802 ``!f a b. 18803 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 18804 ==> (f y) <= (f x)) 18805 ==> f has_bounded_variation_on interval[a,b]``, 18806 REPEAT GEN_TAC THEN 18807 GEN_REWR_TAC (LAND_CONV o BINDER_CONV o BINDER_CONV o RAND_CONV) 18808 [GSYM REAL_LE_NEG2] THEN 18809 SIMP_TAC std_ss [] THEN 18810 GEN_REWR_TAC (LAND_CONV o BINDER_CONV o BINDER_CONV o RAND_CONV) 18811 [METIS [] ``-f x <= -f y <=> (\x. -f x) x <= (\y. -f y) y:real``] THEN 18812 DISCH_THEN(MP_TAC o MATCH_MP INCREASING_BOUNDED_VARIATION) THEN 18813 DISCH_THEN(MP_TAC o MATCH_MP HAS_BOUNDED_VARIATION_ON_NEG) THEN 18814 SIMP_TAC std_ss [REAL_NEG_NEG] THEN METIS_TAC [ETA_AX]); 18815 18816val INCREASING_VECTOR_VARIATION = store_thm ("INCREASING_VECTOR_VARIATION", 18817 ``!f a b. 18818 ~(interval[a,b] = {}) /\ 18819 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 18820 ==> (f x) <= (f y)) 18821 ==> (vector_variation (interval[a,b]) f = (f b) - (f a))``, 18822 REPEAT STRIP_TAC THEN REWRITE_TAC[vector_variation] THEN 18823 REWRITE_TAC[SET_VARIATION_ON_INTERVAL] THEN 18824 SUBGOAL_THEN 18825 ``{sum d (\k. abs (f (interval_upperbound k) - f (interval_lowerbound k))) | 18826 d division_of interval[a:real,b]} = 18827 {(f b) - (f a)}`` 18828 (fn th => SIMP_TAC std_ss [SUP_INSERT_FINITE, FINITE_EMPTY, th]) THEN 18829 ONCE_REWRITE_TAC [METIS [] ``{sum d f | d division_of interval [(a,b)]} = 18830 {(\d. sum d f) d | (\d. d division_of interval [(a,b)]) d}``] THEN 18831 MATCH_MP_TAC(SET_RULE 18832 ``(?x. P x) /\ (!x. P x ==> (f x = a)) ==> ({f x | P x} = {a})``) THEN 18833 CONJ_TAC THENL [ASM_MESON_TAC[DIVISION_OF_SELF], ALL_TAC] THEN 18834 MP_TAC(MATCH_MP (REWRITE_RULE 18835 [TAUT `a /\ b /\ c ==> d <=> b ==> a /\ c ==> d`] 18836 OPERATIVE_DIVISION) (SPEC ``(f:real->real)`` 18837 OPERATIVE_REAL_FUNCTION_ENDPOINT_DIFF)) THEN 18838 DISCH_TAC THEN GEN_TAC THEN POP_ASSUM (MP_TAC o SPEC ``x:(real->bool)->bool``) THEN 18839 DISCH_THEN(MP_TAC o SPECL [``a:real``, ``b:real``]) THEN 18840 DISCH_THEN(fn th => STRIP_TAC THEN MP_TAC th) THEN 18841 ASM_REWRITE_TAC[GSYM sum_def, MONOIDAL_REAL_ADD] THEN 18842 RULE_ASSUM_TAC(REWRITE_RULE[GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT]) THEN 18843 FULL_SIMP_TAC std_ss [o_THM, INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 18844 DISCH_THEN(SUBST1_TAC o SYM) THEN 18845 MATCH_MP_TAC SUM_EQ THEN SIMP_TAC std_ss [] THEN 18846 FIRST_ASSUM(fn th => SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 18847 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN DISCH_TAC THEN 18848 SUBGOAL_THEN ``~(interval[u:real,v] = {})`` ASSUME_TAC THENL 18849 [ASM_MESON_TAC[division_of], ALL_TAC] THEN 18850 RULE_ASSUM_TAC(REWRITE_RULE[GSYM INTERVAL_EQ_EMPTY, REAL_NOT_LT]) THEN 18851 ASM_SIMP_TAC std_ss [INTERVAL_LOWERBOUND, INTERVAL_UPPERBOUND] THEN 18852 MATCH_MP_TAC(REAL_ARITH ``x <= y ==> (abs(y - x) = y - x:real)``) THEN 18853 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 18854 SUBGOAL_THEN ``interval[u:real,v] SUBSET interval[a,b]`` MP_TAC THENL 18855 [ASM_MESON_TAC[division_of], REWRITE_TAC[SUBSET_INTERVAL]] THEN 18856 ASM_REAL_ARITH_TAC); 18857 18858val DECREASING_VECTOR_VARIATION = store_thm ("DECREASING_VECTOR_VARIATION", 18859 ``!f a b. 18860 ~(interval[a,b] = {}) /\ 18861 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 18862 ==> (f y) <= (f x)) 18863 ==> (vector_variation (interval[a,b]) f = (f a) - (f b))``, 18864 REPEAT GEN_TAC THEN GEN_REWR_TAC 18865 (LAND_CONV o RAND_CONV o BINDER_CONV o BINDER_CONV o RAND_CONV) 18866 [GSYM REAL_LE_NEG2] THEN 18867 GEN_REWR_TAC 18868 (LAND_CONV o RAND_CONV o BINDER_CONV o BINDER_CONV o RAND_CONV) 18869 [METIS [] ``-f x <= -f y <=> (\x. -f x) x <= (\y. -(f:real->real) y) y``] THEN 18870 DISCH_THEN(MP_TAC o MATCH_MP INCREASING_VECTOR_VARIATION) THEN 18871 SIMP_TAC std_ss [VECTOR_VARIATION_NEG] THEN 18872 DISCH_TAC THEN REAL_ARITH_TAC); 18873 18874val HAS_BOUNDED_VARIATION_TRANSLATION2_EQ_AND_VECTOR_VARIATION_TRANSLATION2 = store_thm ("HAS_BOUNDED_VARIATION_TRANSLATION2_EQ_AND_VECTOR_VARIATION_TRANSLATION2", 18875 ``(!a f:real->real s. 18876 (\x. f(a + x)) has_bounded_variation_on (IMAGE (\x. -a + x) s) <=> 18877 f has_bounded_variation_on s) /\ 18878 (!a f:real->real s. 18879 vector_variation (IMAGE (\x. -a + x) s) (\x. f(a + x)) = 18880 vector_variation s f)``, 18881 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN X_GEN_TAC ``a:real`` THEN 18882 SIMP_TAC std_ss [FORALL_AND_THM] THEN 18883 ONCE_REWRITE_TAC [METIS [] ``(\x. f (a + x:real)) = (\x. f ((\x. (a + x)) x))``] THEN 18884 MATCH_MP_TAC VARIATION_EQUAL_LEMMA THEN 18885 SIMP_TAC std_ss [] THEN CONJ_TAC THENL [REAL_ARITH_TAC, ALL_TAC] THEN 18886 SIMP_TAC std_ss [DIVISION_OF_TRANSLATION, GSYM INTERVAL_TRANSLATION]); 18887 18888val HAS_BOUNDED_VARIATION_TRANSLATION2_EQ = store_thm ("HAS_BOUNDED_VARIATION_TRANSLATION2_EQ", 18889 ``(!a f:real->real s. 18890 (\x. f(a + x)) has_bounded_variation_on (IMAGE (\x. -a + x) s) <=> 18891 f has_bounded_variation_on s)``, 18892 REWRITE_TAC [HAS_BOUNDED_VARIATION_TRANSLATION2_EQ_AND_VECTOR_VARIATION_TRANSLATION2]); 18893 18894val VECTOR_VARIATION_TRANSLATION2 = store_thm ("VECTOR_VARIATION_TRANSLATION2", 18895 ``(!a f:real->real s. 18896 vector_variation (IMAGE (\x. -a + x) s) (\x. f(a + x)) = 18897 vector_variation s f)``, 18898 REWRITE_TAC [HAS_BOUNDED_VARIATION_TRANSLATION2_EQ_AND_VECTOR_VARIATION_TRANSLATION2]); 18899 18900val HAS_BOUNDED_VARIATION_AFFINITY2_EQ_AND_VECTOR_VARIATION_AFFINITY2 = store_thm ("HAS_BOUNDED_VARIATION_AFFINITY2_EQ_AND_VECTOR_VARIATION_AFFINITY2", 18901 ``(!m c f:real->real s. 18902 (\x. f (m * x + c)) has_bounded_variation_on 18903 IMAGE (\x. inv m * x + -(inv m * c)) s <=> 18904 (m = &0) \/ f has_bounded_variation_on s) /\ 18905 (!m c f:real->real s. 18906 vector_variation (IMAGE (\x. inv m * x + -(inv m * c)) s) 18907 (\x. f (m * x + c)) = 18908 if m = &0 then &0 else vector_variation s f)``, 18909 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN X_GEN_TAC ``m:real`` THEN 18910 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN X_GEN_TAC ``c:real`` THEN 18911 ASM_CASES_TAC ``m = &0:real`` THEN ASM_SIMP_TAC std_ss [] THENL 18912 [ASM_SIMP_TAC std_ss [REAL_MUL_LZERO, HAS_BOUNDED_VARIATION_ON_CONST] THEN 18913 SIMP_TAC std_ss [VECTOR_VARIATION_CONST], 18914 SIMP_TAC std_ss [FORALL_AND_THM] THEN 18915 ONCE_REWRITE_TAC [METIS [] ``(\x:real. f (m * x + c)) = (\x. f ((\x. (m * x + c)) x))``] THEN 18916 MATCH_MP_TAC VARIATION_EQUAL_LEMMA THEN 18917 ASM_SIMP_TAC std_ss [SIMP_RULE std_ss [FUN_EQ_THM, o_DEF] AFFINITY_INVERSES] THEN 18918 ASM_SIMP_TAC std_ss [IMAGE_AFFINITY_INTERVAL] THEN 18919 ASM_SIMP_TAC real_ss [DIVISION_OF_AFFINITY, REAL_INV_EQ_0] THEN 18920 METIS_TAC[]]); 18921 18922val HAS_BOUNDED_VARIATION_AFFINITY2_EQ = store_thm ("HAS_BOUNDED_VARIATION_AFFINITY2_EQ", 18923 ``(!m c f:real->real s. 18924 (\x. f (m * x + c)) has_bounded_variation_on 18925 IMAGE (\x. inv m * x + -(inv m * c)) s <=> 18926 (m = &0) \/ f has_bounded_variation_on s)``, 18927 REWRITE_TAC [HAS_BOUNDED_VARIATION_AFFINITY2_EQ_AND_VECTOR_VARIATION_AFFINITY2]); 18928 18929val VECTOR_VARIATION_AFFINITY2 = store_thm ("VECTOR_VARIATION_AFFINITY2", 18930 `` (!m c f:real->real s. 18931 vector_variation (IMAGE (\x. inv m * x + -(inv m * c)) s) 18932 (\x. f (m * x + c)) = 18933 if m = &0 then &0 else vector_variation s f)``, 18934 REWRITE_TAC [HAS_BOUNDED_VARIATION_AFFINITY2_EQ_AND_VECTOR_VARIATION_AFFINITY2]); 18935 18936val HAS_BOUNDED_VARIATION_AFFINITY_EQ_AND_VECTOR_VARIATION_AFFINITY = store_thm ("HAS_BOUNDED_VARIATION_AFFINITY_EQ_AND_VECTOR_VARIATION_AFFINITY", 18937 ``(!m c f:real->real s. 18938 (\x. f(m * x + c)) has_bounded_variation_on s <=> 18939 (m = &0) \/ f has_bounded_variation_on (IMAGE (\x. m * x + c) s)) /\ 18940 (!m c f:real->real s. 18941 vector_variation s (\x. f(m * x + c)) = 18942 if m = &0 then &0 else vector_variation (IMAGE (\x. m * x + c) s) f)``, 18943 SIMP_TAC std_ss [GSYM FORALL_AND_THM] THEN REPEAT GEN_TAC THEN 18944 ASM_CASES_TAC ``m = &0:real`` THEN 18945 ASM_SIMP_TAC real_ss [REAL_MUL_LZERO, HAS_BOUNDED_VARIATION_ON_CONST, 18946 VECTOR_VARIATION_CONST] THEN 18947 CONJ_TAC THENL 18948 [MP_TAC(ISPECL[``m:real``, ``c:real``, ``f:real->real``, 18949 ``IMAGE (\x:real. m * x + c) s``] 18950 HAS_BOUNDED_VARIATION_AFFINITY2_EQ), 18951 MP_TAC(ISPECL[``m:real``, ``c:real``, ``f:real->real``, 18952 ``IMAGE (\x:real. m * x + c) s``] 18953 VECTOR_VARIATION_AFFINITY2)] THEN 18954 ASM_SIMP_TAC std_ss [AFFINITY_INVERSES, GSYM IMAGE_COMPOSE, IMAGE_ID]); 18955 18956val HAS_BOUNDED_VARIATION_AFFINITY_EQ = store_thm ("HAS_BOUNDED_VARIATION_AFFINITY_EQ", 18957 ``(!m c f:real->real s. 18958 (\x. f(m * x + c)) has_bounded_variation_on s <=> 18959 (m = &0) \/ f has_bounded_variation_on (IMAGE (\x. m * x + c) s))``, 18960 REWRITE_TAC [HAS_BOUNDED_VARIATION_AFFINITY_EQ_AND_VECTOR_VARIATION_AFFINITY]); 18961 18962val VECTOR_VARIATION_AFFINITY = store_thm ("VECTOR_VARIATION_AFFINITY", 18963 ``(!m c f:real->real s. 18964 vector_variation s (\x. f(m * x + c)) = 18965 if m = &0 then &0 else vector_variation (IMAGE (\x. m * x + c) s) f)``, 18966 REWRITE_TAC [HAS_BOUNDED_VARIATION_AFFINITY_EQ_AND_VECTOR_VARIATION_AFFINITY]); 18967 18968val HAS_BOUNDED_VARIATION_TRANSLATION_EQ_AND_VECTOR_VARIATION_TRANSLATION = store_thm ("HAS_BOUNDED_VARIATION_TRANSLATION_EQ_AND_VECTOR_VARIATION_TRANSLATION", 18969 ``(!a f:real->real s. 18970 (\x. f(a + x)) has_bounded_variation_on s <=> 18971 f has_bounded_variation_on (IMAGE (\x. a + x) s)) /\ 18972 (!a f:real->real s. 18973 vector_variation s (\x. f(a + x)) = 18974 vector_variation (IMAGE (\x. a + x) s) f)``, 18975 REPEAT STRIP_TAC THENL 18976 [MP_TAC(ISPECL[``a:real``, ``f:real->real``, ``IMAGE (\x:real. a + x) s``] 18977 HAS_BOUNDED_VARIATION_TRANSLATION2_EQ), 18978 MP_TAC(ISPECL[``a:real``, ``f:real->real``, ``IMAGE (\x:real. a + x) s``] 18979 VECTOR_VARIATION_TRANSLATION2)] THEN 18980 SIMP_TAC std_ss [GSYM IMAGE_COMPOSE, o_DEF] THEN 18981 SIMP_TAC real_ss [IMAGE_ID, REAL_ARITH ``-a + (a + x):real = x``, 18982 REAL_ARITH ``a + -a + x:real = x``]); 18983 18984val HAS_BOUNDED_VARIATION_TRANSLATION_EQ = store_thm ("HAS_BOUNDED_VARIATION_TRANSLATION_EQ", 18985 ``(!a f:real->real s. 18986 (\x. f(a + x)) has_bounded_variation_on s <=> 18987 f has_bounded_variation_on (IMAGE (\x. a + x) s))``, 18988 REWRITE_TAC [HAS_BOUNDED_VARIATION_TRANSLATION_EQ_AND_VECTOR_VARIATION_TRANSLATION]); 18989 18990val VECTOR_VARIATION_TRANSLATION = store_thm ("VECTOR_VARIATION_TRANSLATION", 18991 ``(!a f:real->real s. 18992 vector_variation s (\x. f(a + x)) = 18993 vector_variation (IMAGE (\x. a + x) s) f)``, 18994 REWRITE_TAC [HAS_BOUNDED_VARIATION_TRANSLATION_EQ_AND_VECTOR_VARIATION_TRANSLATION]); 18995 18996val HAS_BOUNDED_VARIATION_TRANSLATION_EQ_INTERVAL_AND_VECTOR_VARIATION_TRANSLATION_INTERVAL = store_thm ("HAS_BOUNDED_VARIATION_TRANSLATION_EQ_INTERVAL_AND_VECTOR_VARIATION_TRANSLATION_INTERVAL", 18997 ``(!a f:real->real u v. 18998 (\x. f(a + x)) has_bounded_variation_on interval[u,v] <=> 18999 f has_bounded_variation_on interval[a+u,a+v]) /\ 19000 (!a f:real->real u v. 19001 vector_variation (interval[u,v]) (\x. f(a + x)) = 19002 vector_variation (interval[a+u,a+v]) f)``, 19003 SIMP_TAC std_ss [INTERVAL_TRANSLATION, HAS_BOUNDED_VARIATION_TRANSLATION_EQ, 19004 VECTOR_VARIATION_TRANSLATION]); 19005 19006val HAS_BOUNDED_VARIATION_TRANSLATION_EQ_INTERVAL = store_thm ("HAS_BOUNDED_VARIATION_TRANSLATION_EQ_INTERVAL", 19007 ``(!a f:real->real u v. 19008 (\x. f(a + x)) has_bounded_variation_on interval[u,v] <=> 19009 f has_bounded_variation_on interval[a+u,a+v])``, 19010 REWRITE_TAC [HAS_BOUNDED_VARIATION_TRANSLATION_EQ_INTERVAL_AND_VECTOR_VARIATION_TRANSLATION_INTERVAL]); 19011 19012val VECTOR_VARIATION_TRANSLATION_INTERVAL = store_thm ("VECTOR_VARIATION_TRANSLATION_INTERVAL", 19013 ``(!a f:real->real u v. 19014 vector_variation (interval[u,v]) (\x. f(a + x)) = 19015 vector_variation (interval[a+u,a+v]) f)``, 19016 REWRITE_TAC [HAS_BOUNDED_VARIATION_TRANSLATION_EQ_INTERVAL_AND_VECTOR_VARIATION_TRANSLATION_INTERVAL]); 19017 19018val HAS_BOUNDED_VARIATION_TRANSLATION = store_thm ("HAS_BOUNDED_VARIATION_TRANSLATION", 19019 ``!f:real->real s a. 19020 f has_bounded_variation_on s 19021 ==> (\x. f(a + x)) has_bounded_variation_on (IMAGE (\x. -a + x) s)``, 19022 REWRITE_TAC[HAS_BOUNDED_VARIATION_TRANSLATION2_EQ]); 19023 19024val HAS_BOUNDED_VARIATION_REFLECT2_EQ_AND_VECTOR_VARIATION_REFLECT2 = store_thm ("HAS_BOUNDED_VARIATION_REFLECT2_EQ_AND_VECTOR_VARIATION_REFLECT2", 19025 ``(!f:real->real s. 19026 (\x. f(-x)) has_bounded_variation_on (IMAGE (\x. -x) s) <=> 19027 f has_bounded_variation_on s) /\ 19028 (!f:real->real s. 19029 vector_variation (IMAGE (\x. -x) s) (\x. f(-x)) = 19030 vector_variation s f)``, 19031 MATCH_MP_TAC VARIATION_EQUAL_LEMMA THEN 19032 SIMP_TAC std_ss [] THEN CONJ_TAC THENL [REAL_ARITH_TAC, ALL_TAC] THEN 19033 METIS_TAC [DIVISION_OF_REFLECT, REFLECT_INTERVAL]); 19034 19035val HAS_BOUNDED_VARIATION_REFLECT2_EQ = store_thm ("HAS_BOUNDED_VARIATION_REFLECT2_EQ", 19036 ``(!f:real->real s. 19037 (\x. f(-x)) has_bounded_variation_on (IMAGE (\x. -x) s) <=> 19038 f has_bounded_variation_on s)``, 19039 REWRITE_TAC [HAS_BOUNDED_VARIATION_REFLECT2_EQ_AND_VECTOR_VARIATION_REFLECT2]); 19040 19041val VECTOR_VARIATION_REFLECT2 = store_thm ("VECTOR_VARIATION_REFLECT2", 19042 ``(!f:real->real s. 19043 vector_variation (IMAGE (\x. -x) s) (\x. f(-x)) = 19044 vector_variation s f)``, 19045 REWRITE_TAC [HAS_BOUNDED_VARIATION_REFLECT2_EQ_AND_VECTOR_VARIATION_REFLECT2]); 19046 19047val HAS_BOUNDED_VARIATION_REFLECT_EQ_AND_VECTOR_VARIATION_REFLECT = store_thm ("HAS_BOUNDED_VARIATION_REFLECT_EQ_AND_VECTOR_VARIATION_REFLECT", 19048 ``(!f:real->real s. 19049 (\x. f(-x)) has_bounded_variation_on s <=> 19050 f has_bounded_variation_on (IMAGE (\x. -x) s)) /\ 19051 (!f:real->real s. 19052 vector_variation s (\x. f(-x)) = 19053 vector_variation (IMAGE (\x. -x) s) f)``, 19054 REPEAT STRIP_TAC THENL 19055 [MP_TAC(ISPECL[``f:real->real``, ``IMAGE (\x. -x) (s:real->bool)``] 19056 HAS_BOUNDED_VARIATION_REFLECT2_EQ), 19057 MP_TAC(ISPECL[``f:real->real``, ``IMAGE (\x. -x) (s:real->bool)``] 19058 VECTOR_VARIATION_REFLECT2)] THEN 19059 SIMP_TAC std_ss [GSYM IMAGE_COMPOSE, o_DEF] THEN 19060 REWRITE_TAC[IMAGE_ID, REAL_NEG_NEG]); 19061 19062val HAS_BOUNDED_VARIATION_REFLECT_EQ = store_thm ("HAS_BOUNDED_VARIATION_REFLECT_EQ", 19063 ``(!f:real->real s. 19064 (\x. f(-x)) has_bounded_variation_on s <=> 19065 f has_bounded_variation_on (IMAGE (\x. -x) s))``, 19066 REWRITE_TAC [HAS_BOUNDED_VARIATION_REFLECT_EQ_AND_VECTOR_VARIATION_REFLECT]); 19067 19068val VECTOR_VARIATION_REFLECT = store_thm ("VECTOR_VARIATION_REFLECT", 19069 ``(!f:real->real s. 19070 vector_variation s (\x. f(-x)) = 19071 vector_variation (IMAGE (\x. -x) s) f)``, 19072 REWRITE_TAC [HAS_BOUNDED_VARIATION_REFLECT_EQ_AND_VECTOR_VARIATION_REFLECT]); 19073 19074val HAS_BOUNDED_VARIATION_REFLECT_EQ_INTERVAL_AND_VECTOR_VARIATION_REFLECT_INTERVAL = store_thm ("HAS_BOUNDED_VARIATION_REFLECT_EQ_INTERVAL_AND_VECTOR_VARIATION_REFLECT_INTERVAL", 19075 ``(!f:real->real u v. 19076 (\x. f(-x)) has_bounded_variation_on interval[u,v] <=> 19077 f has_bounded_variation_on interval[-v,-u]) /\ 19078 (!f:real->real u v. 19079 vector_variation (interval[u,v]) (\x. f(-x)) = 19080 vector_variation (interval[-v,-u]) f)``, 19081 SIMP_TAC std_ss [GSYM REFLECT_INTERVAL, HAS_BOUNDED_VARIATION_REFLECT_EQ, 19082 VECTOR_VARIATION_REFLECT]); 19083 19084val HAS_BOUNDED_VARIATION_REFLECT_EQ_INTERVAL = store_thm ("HAS_BOUNDED_VARIATION_REFLECT_EQ_INTERVAL", 19085 ``(!f:real->real u v. 19086 (\x. f(-x)) has_bounded_variation_on interval[u,v] <=> 19087 f has_bounded_variation_on interval[-v,-u])``, 19088 REWRITE_TAC [HAS_BOUNDED_VARIATION_REFLECT_EQ_INTERVAL_AND_VECTOR_VARIATION_REFLECT_INTERVAL]); 19089 19090val VECTOR_VARIATION_REFLECT_INTERVAL = store_thm ("VECTOR_VARIATION_REFLECT_INTERVAL", 19091 ``(!f:real->real u v. 19092 vector_variation (interval[u,v]) (\x. f(-x)) = 19093 vector_variation (interval[-v,-u]) f)``, 19094 REWRITE_TAC [HAS_BOUNDED_VARIATION_REFLECT_EQ_INTERVAL_AND_VECTOR_VARIATION_REFLECT_INTERVAL]); 19095 19096val HAS_BOUNDED_VARIATION_DARBOUX = store_thm ("HAS_BOUNDED_VARIATION_DARBOUX", 19097 ``!f a b. 19098 f has_bounded_variation_on interval[a,b] <=> 19099 ?g h. (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 19100 ==> (g x) <= (g y)) /\ 19101 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 19102 ==> (h x) <= (h y)) /\ 19103 (!x. f x = g x - h x)``, 19104 REPEAT GEN_TAC THEN EQ_TAC THEN STRIP_TAC THENL 19105 [MAP_EVERY EXISTS_TAC 19106 [``\x:real. (vector_variation (interval[a,x]) (f:real->real))``, 19107 ``\x:real. (vector_variation (interval[a,x]) f) - f x``] THEN 19108 SIMP_TAC real_ss [REAL_ARITH ``a - (a - x):real = x``] THEN 19109 REPEAT STRIP_TAC THENL 19110 [MATCH_MP_TAC VECTOR_VARIATION_MONOTONE, 19111 MATCH_MP_TAC(REAL_ARITH 19112 ``!x. a - (b - x) <= c - (d - x) ==> a - b <= c - d:real``) THEN 19113 EXISTS_TAC ``(f(a:real)):real`` THEN 19114 SIMP_TAC std_ss [] THEN 19115 MATCH_MP_TAC VECTOR_VARIATION_MINUS_FUNCTION_MONOTONE] THEN 19116 (CONJ_TAC THENL 19117 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (SIMP_RULE std_ss [IMP_CONJ] 19118 HAS_BOUNDED_VARIATION_ON_SUBSET)), 19119 ALL_TAC] THEN 19120 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19121 REWRITE_TAC[SUBSET_INTERVAL, GSYM INTERVAL_EQ_EMPTY] THEN 19122 ASM_REAL_ARITH_TAC), 19123 GEN_REWR_TAC LAND_CONV [GSYM ETA_AX] THEN ASM_REWRITE_TAC[] THEN 19124 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_SUB THEN 19125 CONJ_TAC THEN MATCH_MP_TAC INCREASING_BOUNDED_VARIATION THEN 19126 ASM_REWRITE_TAC[]]); 19127 19128val HAS_BOUNDED_VARIATION_DARBOUX_STRICT = store_thm ("HAS_BOUNDED_VARIATION_DARBOUX_STRICT", 19129 ``!f a b. 19130 f has_bounded_variation_on interval[a,b] <=> 19131 ?g h. (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x < y 19132 ==> (g x) < (g y)) /\ 19133 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x < y 19134 ==> (h x) < (h y)) /\ 19135 (!x. f x = g x - h x)``, 19136 REPEAT GEN_TAC THEN REWRITE_TAC[HAS_BOUNDED_VARIATION_DARBOUX] THEN 19137 EQ_TAC THEN SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 19138 MAP_EVERY X_GEN_TAC [``g:real->real``, ``h:real->real``] THEN 19139 STRIP_TAC THENL 19140 [MAP_EVERY EXISTS_TAC [``\x:real. g x + x``, ``\x:real. h x + x``] THEN 19141 ASM_SIMP_TAC std_ss [REAL_ARITH ``(a + x) - (b + x):real = a - b``] THEN 19142 REPEAT STRIP_TAC THEN 19143 MATCH_MP_TAC REAL_LET_ADD2 THEN ASM_REWRITE_TAC[] THEN 19144 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_SIMP_TAC std_ss [REAL_LT_IMP_LE], 19145 MAP_EVERY EXISTS_TAC [``g:real->real``, ``h:real->real``] THEN 19146 ASM_REWRITE_TAC[REAL_LE_LT] THEN ASM_MESON_TAC[]]); 19147 19148val HAS_BOUNDED_VARIATION_COMPOSE_INCREASING = store_thm ("HAS_BOUNDED_VARIATION_COMPOSE_INCREASING", 19149 ``!f g:real->real a b. 19150 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 19151 ==> (f x) <= (f y)) /\ 19152 g has_bounded_variation_on interval[f a,f b] 19153 ==> (g o f) has_bounded_variation_on interval[a,b]``, 19154 REPEAT GEN_TAC THEN DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 19155 ONCE_REWRITE_TAC[HAS_BOUNDED_VARIATION_ON_COMPONENTWISE] THEN 19156 ASM_SIMP_TAC std_ss [HAS_BOUNDED_VARIATION_DARBOUX, LEFT_IMP_EXISTS_THM] THEN 19157 MAP_EVERY X_GEN_TAC [``h:real->real``, ``k:real->real``] THEN 19158 STRIP_TAC THEN 19159 MAP_EVERY EXISTS_TAC [``(h:real->real) o (f:real->real)``, 19160 ``(k:real->real) o (f:real->real)``] THEN 19161 ASM_SIMP_TAC std_ss [o_THM] THEN 19162 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 19163 REPEAT STRIP_TAC THEN TRY(FIRST_X_ASSUM MATCH_MP_TAC) THEN 19164 ASM_REWRITE_TAC[] THEN 19165 REWRITE_TAC[IN_INTERVAL] THEN CONJ_TAC THEN 19166 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[] THEN 19167 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_REWRITE_TAC[] THEN 19168 REWRITE_TAC[IN_INTERVAL] THEN POP_ASSUM MP_TAC THEN 19169 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN REAL_ARITH_TAC); 19170 19171val HAS_BOUNDED_VARIATION_ON_REFLECT = store_thm ("HAS_BOUNDED_VARIATION_ON_REFLECT", 19172 ``!f:real->real s. 19173 f has_bounded_variation_on IMAGE (\x. -x) s 19174 ==> (\x. f(-x)) has_bounded_variation_on s``, 19175 REPEAT GEN_TAC THEN 19176 REWRITE_TAC[has_bounded_variation_on] THEN 19177 REWRITE_TAC[has_bounded_setvariation_on] THEN 19178 DISCH_THEN (X_CHOOSE_TAC ``B:real``) THEN EXISTS_TAC ``B:real`` THEN 19179 MAP_EVERY X_GEN_TAC [``d:(real->bool)->bool``, ``t:real->bool``] THEN 19180 STRIP_TAC THEN FIRST_X_ASSUM(MP_TAC o SPECL 19181 [``IMAGE (IMAGE (\x. -x)) (d:(real->bool)->bool)``, 19182 ``IMAGE (\x. -x) (t:real->bool)``]) THEN 19183 ASM_SIMP_TAC std_ss [DIVISION_OF_REFLECT] THEN 19184 SIMP_TAC std_ss [SUBSET_DEF, FORALL_IN_IMAGE] THEN 19185 KNOW_TAC ``(!x:real. x IN t ==> -x IN IMAGE (\x. -x) s)`` THENL 19186 [ASM_SET_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 19187 ASM_REWRITE_TAC[GSYM SUBSET_DEF] THEN 19188 W(MP_TAC o PART_MATCH (lhs o rand) SUM_IMAGE o lhand o lhand o snd) THEN 19189 KNOW_TAC ``(!(x :real -> bool) (y :real -> bool). 19190 x IN (d :(real -> bool) -> bool) /\ y IN d /\ 19191 (IMAGE (\(x :real). -x) x = IMAGE (\(x :real). -x) y) ==> 19192 (x = y))`` THENL 19193 [METIS_TAC[REAL_ARITH ``(-x:real = -y) <=> (x = y)``, INJECTIVE_IMAGE], 19194 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 19195 DISCH_THEN SUBST1_TAC THEN 19196 MATCH_MP_TAC(REAL_ARITH ``(x = y) ==> x <= d ==> y <= d:real``) THEN 19197 MATCH_MP_TAC SUM_EQ THEN UNDISCH_TAC ``d division_of t`` THEN 19198 DISCH_TAC THEN FIRST_ASSUM(fn th => 19199 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION th]) THEN 19200 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN DISCH_TAC THEN 19201 SUBGOAL_THEN ``u <= v:real`` ASSUME_TAC THENL 19202 [METIS_TAC[GSYM INTERVAL_NE_EMPTY, division_of], ALL_TAC] THEN 19203 ASM_SIMP_TAC std_ss [o_THM, REFLECT_INTERVAL] THEN 19204 ASM_SIMP_TAC std_ss [INTERVAL_UPPERBOUND, INTERVAL_LOWERBOUND, 19205 REAL_LE_NEG2] THEN 19206 REAL_ARITH_TAC]); 19207 19208val HAS_BOUNDED_VARIATION_ON_REFLECT_INTERVAL = store_thm ("HAS_BOUNDED_VARIATION_ON_REFLECT_INTERVAL", 19209 ``!f:real->real a b. 19210 f has_bounded_variation_on interval[-b,-a] 19211 ==> (\x. f(-x)) has_bounded_variation_on interval[a,b]``, 19212 REPEAT STRIP_TAC THEN MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_REFLECT THEN 19213 ASM_REWRITE_TAC[REFLECT_INTERVAL]); 19214 19215val VECTOR_VARIATION_REFLECT_INTERVAL = store_thm ("VECTOR_VARIATION_REFLECT_INTERVAL", 19216 ``!f:real->real a b. 19217 vector_variation (interval[a,b]) (\x. f(-x)) = 19218 vector_variation (interval[-b,-a]) f``, 19219 REWRITE_TAC[VECTOR_VARIATION_REFLECT, REFLECT_INTERVAL]); 19220 19221val HAS_BOUNDED_VARIATION_COMPOSE_DECREASING = store_thm ("HAS_BOUNDED_VARIATION_COMPOSE_DECREASING", 19222 ``!f g:real->real a b. 19223 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 19224 ==> (f y) <= (f x)) /\ 19225 g has_bounded_variation_on interval[f b,f a] 19226 ==> (g o f) has_bounded_variation_on interval[a,b]``, 19227 REPEAT GEN_TAC THEN 19228 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC MP_TAC) THEN 19229 DISCH_THEN(MP_TAC o MATCH_MP (REWRITE_RULE[REAL_NEG_NEG] 19230 (ISPECL [``f:real->real``, ``-b:real``, ``-a:real``] 19231 HAS_BOUNDED_VARIATION_ON_REFLECT_INTERVAL))) THEN 19232 POP_ASSUM MP_TAC THEN 19233 GEN_REWR_TAC (LAND_CONV o BINDER_CONV o BINDER_CONV o RAND_CONV) 19234 [GSYM REAL_LE_NEG2] THEN 19235 REWRITE_TAC[AND_IMP_INTRO] THEN 19236 ONCE_REWRITE_TAC [METIS [] ``-f x <= -f y <=> (\x. -f x) x <= (\y. -f y) y:real``] THEN 19237 ONCE_REWRITE_TAC [METIS [] ``interval [(-f a,-f b:real)] = 19238 interval [((\x. -f x) a,(\x. -f x) b)]``] THEN 19239 DISCH_THEN(MP_TAC o MATCH_MP HAS_BOUNDED_VARIATION_COMPOSE_INCREASING) THEN 19240 SIMP_TAC std_ss [o_DEF, REAL_NEG_NEG]); 19241 19242val HAS_BOUNDED_VARIATION_ON_ID = store_thm ("HAS_BOUNDED_VARIATION_ON_ID", 19243 ``!a b. (\x. x) has_bounded_variation_on interval[a,b]``, 19244 REPEAT GEN_TAC THEN MATCH_MP_TAC INCREASING_BOUNDED_VARIATION THEN 19245 SIMP_TAC std_ss []); 19246 19247val HAS_BOUNDED_VARIATION_ON_COMBINE_GEN = store_thm ("HAS_BOUNDED_VARIATION_ON_COMBINE_GEN", 19248 ``!f:real->real s a. 19249 is_interval s 19250 ==> (f has_bounded_variation_on s <=> 19251 f has_bounded_variation_on {x | x IN s /\ x <= a} /\ 19252 f has_bounded_variation_on {x | x IN s /\ x >= a})``, 19253 REPEAT STRIP_TAC THEN EQ_TAC THENL 19254 [DISCH_THEN(fn th => CONJ_TAC THEN MP_TAC th) THEN 19255 MATCH_MP_TAC(SIMP_RULE std_ss [IMP_CONJ_ALT] 19256 HAS_BOUNDED_VARIATION_ON_SUBSET) THEN 19257 SIMP_TAC std_ss [SUBSET_RESTRICT], 19258 ALL_TAC] THEN 19259 DISCH_TAC THEN REWRITE_TAC[HAS_BOUNDED_VARIATION_NONTRIVIAL] THEN 19260 SUBGOAL_THEN ``bounded(IMAGE (f:real->real) s)`` MP_TAC THENL 19261 [MATCH_MP_TAC BOUNDED_SUBSET THEN 19262 EXISTS_TAC 19263 ``IMAGE (f:real->real) 19264 ({x | x IN s /\ x <= a} UNION 19265 {x | x IN s /\ x >= a})`` THEN 19266 CONJ_TAC THENL 19267 [REWRITE_TAC[IMAGE_UNION, BOUNDED_UNION] THEN CONJ_TAC THEN 19268 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED THEN 19269 ASM_REWRITE_TAC[] THEN 19270 ONCE_REWRITE_TAC [METIS [] ``(x <= a <=> (\x. x <= a) x) /\ 19271 (x >= a <=> (\x. x >= a) x)``] THEN 19272 REWRITE_TAC[SET_RULE ``{x | x IN s /\ P x} = s INTER {x | P x}``] THEN 19273 MATCH_MP_TAC IS_INTERVAL_INTER THEN ASM_REWRITE_TAC[] THEN 19274 SIMP_TAC std_ss [IS_INTERVAL_CASES, real_ge] THEN METIS_TAC[], 19275 MATCH_MP_TAC IMAGE_SUBSET THEN 19276 SIMP_TAC std_ss [SUBSET_DEF, GSPECIFICATION, IN_UNION] THEN REAL_ARITH_TAC], 19277 SIMP_TAC std_ss [BOUNDED_POS, FORALL_IN_IMAGE] THEN 19278 DISCH_THEN(X_CHOOSE_THEN ``D:real`` STRIP_ASSUME_TAC) THEN 19279 FIRST_X_ASSUM(CONJUNCTS_THEN MP_TAC) THEN 19280 REWRITE_TAC[has_bounded_variation_on, has_bounded_setvariation_on] THEN 19281 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 19282 X_GEN_TAC ``C:real`` THEN DISCH_TAC THEN 19283 X_GEN_TAC ``B:real`` THEN DISCH_TAC] THEN 19284 EXISTS_TAC ``&4 * D + B + C:real`` THEN 19285 MAP_EVERY X_GEN_TAC [``d:(real->bool)->bool``, ``t:real->bool``] THEN 19286 STRIP_TAC THEN 19287 ABBREV_TAC ``dl = {k:real->bool | 19288 k IN d /\ k SUBSET {x | x IN s /\ x <= a}}`` THEN 19289 ABBREV_TAC ``dr = {k:real->bool | 19290 k IN d /\ k SUBSET {x | x IN s /\ x >= a}}`` THEN 19291 UNDISCH_TAC ``!d t. 19292 d division_of t /\ t SUBSET {x | x IN s /\ x >= a} ==> 19293 sum d (\k. abs 19294 (f (interval_upperbound k) - 19295 f (interval_lowerbound k))) <= C`` THEN DISCH_TAC THEN 19296 FIRST_X_ASSUM (MP_TAC o SPECL 19297 [``dr:(real->bool)->bool``, ``BIGUNION dr:real->bool``]) THEN 19298 FIRST_X_ASSUM (MP_TAC o SPECL 19299 [``dl:(real->bool)->bool``, ``BIGUNION dl:real->bool``]) THEN 19300 KNOW_TAC ``dl division_of BIGUNION dl:real->bool /\ 19301 BIGUNION dl SUBSET {x | x IN s /\ x <= a}`` THENL 19302 [CONJ_TAC THENL [MATCH_MP_TAC DIVISION_OF_SUBSET, ASM_SET_TAC[]] THEN 19303 EXISTS_TAC ``d:(real->bool)->bool`` THEN 19304 CONJ_TAC THENL [METIS_TAC[DIVISION_OF_UNION_SELF], ASM_SET_TAC[]], 19305 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 19306 ONCE_REWRITE_TAC[TAUT `p ==> q ==> r <=> q ==> p ==> r`]] THEN 19307 KNOW_TAC ``dr division_of BIGUNION dr:real->bool /\ 19308 BIGUNION dr SUBSET {x | x IN s /\ x >= a}`` THENL 19309 [CONJ_TAC THENL [MATCH_MP_TAC DIVISION_OF_SUBSET, ASM_SET_TAC[]] THEN 19310 EXISTS_TAC ``d:(real->bool)->bool`` THEN 19311 CONJ_TAC THENL [METIS_TAC[DIVISION_OF_UNION_SELF], ASM_SET_TAC[]], 19312 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 19313 ONCE_REWRITE_TAC[TAUT `p ==> q ==> r <=> q ==> p ==> r`]] THEN 19314 UNDISCH_TAC ``d division_of t`` THEN DISCH_TAC THEN 19315 FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 19316 MATCH_MP_TAC(REAL_ARITH 19317 ``u <= (s + t) + d ==> s <= b ==> t <= c ==> u <= d + b + c:real``) THEN 19318 W(MP_TAC o PART_MATCH (rand o rand) 19319 SUM_UNION_NONZERO o lhand o rand o snd) THEN 19320 KNOW_TAC ``FINITE (dl :(real -> bool) -> bool) /\ 19321 FINITE (dr :(real -> bool) -> bool) /\ 19322 (!(x :real -> bool). x IN dl INTER dr ==> 19323 ((\(k :real -> bool). 19324 abs ((f :real -> real) (interval_upperbound k) - 19325 f (interval_lowerbound k))) x = (0 : real)))`` THENL 19326 [MAP_EVERY EXPAND_TAC ["dl", "dr"] THEN 19327 SIMP_TAC std_ss [IN_INTER, GSPECIFICATION] THEN 19328 ASM_SIMP_TAC std_ss [FINITE_RESTRICT, IMP_CONJ] THEN 19329 UNDISCH_TAC ``d division_of t`` THEN DISCH_TAC THEN 19330 FIRST_ASSUM(fn th => 19331 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 19332 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, INTERVAL_UPPERBOUND_NONEMPTY] THEN 19333 REWRITE_TAC[AND_IMP_INTRO, GSYM SUBSET_INTER, GSYM CONJ_ASSOC] THEN 19334 ONCE_REWRITE_TAC [METIS [] ``(x <= a <=> (\x. x <= a) x) /\ 19335 (x >= a <=> (\x. x >= a) x)``] THEN 19336 REWRITE_TAC [SET_RULE 19337 ``{x | x IN P /\ Q x} INTER {x | x IN P /\ R x} = {x | x IN P /\ Q x /\ R x}``] THEN 19338 SIMP_TAC std_ss [REAL_ARITH ``x <= a /\ x >= a <=> (x = a:real)``] THEN 19339 REPEAT STRIP_TAC THEN REWRITE_TAC[ABS_ZERO, REAL_SUB_0] THEN AP_TERM_TAC THEN 19340 FIRST_X_ASSUM(MP_TAC o MATCH_MP (SET_RULE 19341 ``s SUBSET {x | x IN t /\ (x = a)} ==> s SUBSET {a}``)) THEN 19342 REWRITE_TAC[GSYM INTERVAL_SING, SUBSET_INTERVAL] THEN 19343 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [INTERVAL_NE_EMPTY]) THEN 19344 REAL_ARITH_TAC, 19345 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 19346 DISCH_THEN(SUBST1_TAC o SYM)] THEN 19347 MATCH_MP_TAC(REAL_ARITH ``s - t <= b ==> s <= t + b:real``) THEN 19348 W(MP_TAC o PART_MATCH (rand o rand) SUM_DIFF o lhand o snd) THEN 19349 ASM_SIMP_TAC std_ss [] THEN 19350 KNOW_TAC ``dl UNION (dr:(real->bool)->bool) SUBSET d`` THENL 19351 [ASM_SET_TAC[], DISCH_TAC THEN ASM_REWRITE_TAC [] THEN 19352 POP_ASSUM K_TAC THEN DISCH_THEN(SUBST1_TAC o SYM)] THEN 19353 SUBGOAL_THEN 19354 ``FINITE(d DIFF (dl UNION dr):(real->bool)->bool) /\ 19355 CARD(d DIFF (dl UNION dr)) <= 2`` 19356 STRIP_ASSUME_TAC THENL 19357 [MATCH_MP_TAC(METIS[CARD_SUBSET, LESS_EQ_TRANS, FINITE_SUBSET] 19358 ``!t. s SUBSET t /\ FINITE t /\ CARD t <= 2 19359 ==> FINITE s /\ CARD s <= 2``) THEN 19360 EXISTS_TAC ``{k | k IN d /\ ~(content k = &0) /\ a IN k}`` THEN 19361 ASM_SIMP_TAC std_ss [FINITE_RESTRICT] THEN 19362 SUBST1_TAC(MESON[EXP_1] ``2 = 2 EXP 1``) THEN 19363 CONJ_TAC THENL 19364 [ALL_TAC, 19365 MATCH_MP_TAC DIVISION_COMMON_POINT_BOUND THEN ASM_MESON_TAC[]] THEN 19366 GEN_REWR_TAC I [SUBSET_DEF] THEN MAP_EVERY EXPAND_TAC ["dl", "dr"] THEN 19367 SIMP_TAC std_ss [IN_DIFF, IMP_CONJ, GSPECIFICATION, IN_UNION] THEN 19368 UNDISCH_TAC ``d division_of t`` THEN DISCH_TAC THEN 19369 FIRST_ASSUM(fn th => 19370 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 19371 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, INTERVAL_UPPERBOUND_NONEMPTY] THEN 19372 ONCE_REWRITE_TAC [METIS [] ``(x <= a <=> (\x. x <= a) x) /\ 19373 (x >= a <=> (\x. x >= a) x)``] THEN 19374 REWRITE_TAC[SET_RULE ``{x | x IN s /\ P x} = s INTER {x | P x}``] THEN 19375 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN STRIP_TAC THEN 19376 SUBGOAL_THEN ``interval[u:real,v] SUBSET s`` ASSUME_TAC THENL 19377 [METIS_TAC[division_of, SUBSET_DEF], ASM_REWRITE_TAC[SUBSET_INTER]] THEN 19378 SIMP_TAC std_ss [CONTENT_EQ_0, IN_INTERVAL, SUBSET_DEF, GSPECIFICATION] THEN 19379 REAL_ARITH_TAC, 19380 ALL_TAC] THEN 19381 MATCH_MP_TAC REAL_LE_TRANS THEN EXISTS_TAC 19382 ``&(CARD(d DIFF (dl UNION dr):(real->bool)->bool)) * &2 * D:real`` THEN 19383 CONJ_TAC THENL 19384 [REWRITE_TAC [GSYM REAL_MUL_ASSOC] THEN 19385 MATCH_MP_TAC SUM_BOUND THEN ASM_SIMP_TAC std_ss [] THEN 19386 REWRITE_TAC[IN_DIFF, IMP_CONJ] THEN UNDISCH_TAC ``d division_of t`` THEN 19387 DISCH_TAC THEN FIRST_ASSUM(fn th => 19388 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 19389 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, INTERVAL_UPPERBOUND_NONEMPTY] THEN 19390 REPEAT STRIP_TAC THEN MATCH_MP_TAC(REAL_ARITH 19391 ``abs(x:real) <= d /\ abs y <= d ==> abs(x - y) <= &2 * d:real``) THEN 19392 ASM_MESON_TAC[division_of, SUBSET_DEF, ENDS_IN_INTERVAL], 19393 ASM_SIMP_TAC std_ss [REAL_MUL_ASSOC, REAL_LE_RMUL] THEN 19394 REWRITE_TAC[REAL_ARITH ``x * &2 <= &4 <=> x <= &2:real``] THEN 19395 ASM_REWRITE_TAC[REAL_OF_NUM_LE]]); 19396 19397val HAS_BOUNDED_VARIATION_ON_CLOSURE = store_thm ("HAS_BOUNDED_VARIATION_ON_CLOSURE", 19398 ``!f:real->real s. 19399 is_interval s /\ f has_bounded_variation_on s 19400 ==> f has_bounded_variation_on (closure s)``, 19401 REPEAT STRIP_TAC THEN 19402 FIRST_ASSUM(STRIP_ASSUME_TAC o MATCH_MP CARD_FRONTIER_INTERVAL) THEN 19403 SUBGOAL_THEN ``bounded (IMAGE (f:real->real) (closure (s:real->bool)))`` MP_TAC THENL 19404 [MATCH_MP_TAC BOUNDED_SUBSET THEN 19405 EXISTS_TAC ``IMAGE (f:real->real) (s UNION frontier s)`` THEN 19406 CONJ_TAC THENL 19407 [ASM_REWRITE_TAC[IMAGE_UNION, BOUNDED_UNION] THEN 19408 ASM_SIMP_TAC std_ss [HAS_BOUNDED_VARIATION_ON_IMP_BOUNDED] THEN 19409 ASM_SIMP_TAC std_ss [FINITE_IMP_BOUNDED, IMAGE_FINITE], 19410 REWRITE_TAC[frontier] THEN 19411 MP_TAC(ISPEC ``s:real->bool`` INTERIOR_SUBSET) THEN SET_TAC[]], 19412 SIMP_TAC std_ss [BOUNDED_POS, FORALL_IN_IMAGE] THEN 19413 DISCH_THEN(X_CHOOSE_THEN ``B:real`` STRIP_ASSUME_TAC) THEN 19414 UNDISCH_TAC ``(f:real->real) has_bounded_variation_on s`` THEN 19415 REWRITE_TAC[has_bounded_setvariation_on, has_bounded_variation_on] THEN 19416 DISCH_THEN(X_CHOOSE_THEN ``kk:real`` STRIP_ASSUME_TAC) THEN 19417 EXISTS_TAC ``kk + &8 * B:real`` THEN 19418 MAP_EVERY X_GEN_TAC [``d:(real->bool)->bool``, ``u:real->bool``] THEN 19419 STRIP_TAC THEN FIRST_ASSUM(ASSUME_TAC o MATCH_MP DIVISION_OF_FINITE) THEN 19420 SUBGOAL_THEN 19421 ``d = { k:real->bool | 19422 k IN d /\ k SUBSET s} UNION {k | k IN d /\ ~(k SUBSET s)}`` 19423 SUBST1_TAC THENL [SET_TAC[], ALL_TAC] THEN 19424 KNOW_TAC ``sum {k | k IN d /\ k SUBSET s} 19425 (\k. abs (f (interval_upperbound k) - f (interval_lowerbound k))) + 19426 sum {k | k IN d /\ ~(k SUBSET s)} 19427 (\k. abs (f (interval_upperbound k) - f (interval_lowerbound k))) <= 19428 kk + &8 * B:real /\ 19429 FINITE {k | k IN d /\ k SUBSET s} /\ 19430 FINITE {k | k IN d /\ ~(k SUBSET s)} /\ 19431 DISJOINT {k | k IN d /\ k SUBSET s} {k | k IN d /\ ~(k SUBSET s)}`` THENL 19432 [ALL_TAC, METIS_TAC [SUM_UNION]] THEN ASM_SIMP_TAC std_ss [FINITE_RESTRICT] THEN 19433 CONJ_TAC THENL [MATCH_MP_TAC REAL_LE_ADD2, SET_TAC[]] THEN CONJ_TAC THENL 19434 [FULL_SIMP_TAC std_ss [] THEN 19435 FIRST_X_ASSUM MATCH_MP_TAC THEN 19436 EXISTS_TAC ``BIGUNION {k:real->bool | k IN d /\ k SUBSET s}`` THEN 19437 CONJ_TAC THENL [MATCH_MP_TAC DIVISION_OF_SUBSET, SET_TAC[]] THEN 19438 EXISTS_TAC ``d:(real->bool)->bool`` THEN 19439 CONJ_TAC THENL [ASM_MESON_TAC[DIVISION_OF_UNION_SELF], SET_TAC[]], 19440 ONCE_REWRITE_TAC[GSYM SUM_SUPPORT] THEN 19441 SIMP_TAC std_ss [support, GSPECIFICATION, NEUTRAL_REAL_ADD] THEN 19442 REWRITE_TAC[ABS_ZERO, REAL_SUB_0] THEN 19443 MP_TAC(ISPECL 19444 [``{k | (k IN d /\ ~(k SUBSET s)) /\ 19445 ~((f:real->real)(interval_upperbound k) = 19446 f (interval_lowerbound k))}``, 19447 ``\k. abs ((f:real->real) (interval_upperbound k) - 19448 f (interval_lowerbound k))``, 19449 ``&2 * B:real``] SUM_BOUND) THEN 19450 ASM_SIMP_TAC std_ss [GSYM CONJ_ASSOC, FINITE_RESTRICT, FORALL_IN_GSPEC] THEN 19451 KNOW_TAC ``(!(k :real -> bool). 19452 k IN (d :(real -> bool) -> bool) /\ ~(k SUBSET (s :real -> bool)) /\ 19453 (f :real -> real) (interval_upperbound k) <> 19454 f (interval_lowerbound k) ==> 19455 abs (f (interval_upperbound k) - f (interval_lowerbound k)) <= 19456 (2 :real) * (B :real))`` THENL 19457 [ONCE_REWRITE_TAC[IMP_CONJ] THEN UNDISCH_TAC ``d division_of u`` THEN 19458 DISCH_TAC THEN FIRST_ASSUM(fn th => 19459 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 19460 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, 19461 INTERVAL_UPPERBOUND_NONEMPTY] THEN 19462 MAP_EVERY X_GEN_TAC [``a:real``, ``b:real``] THEN STRIP_TAC THEN 19463 STRIP_TAC THEN MATCH_MP_TAC(REAL_ARITH 19464 ``abs(x) <= B /\ abs(y) <= B ==> abs(y - x:real) <= &2 * B``) THEN 19465 CONJ_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 19466 UNDISCH_TAC ``d division_of u`` THEN DISCH_TAC THEN 19467 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [division_of]) THEN 19468 DISCH_THEN (CONJUNCTS_THEN2 K_TAC MP_TAC) THEN 19469 DISCH_THEN (CONJUNCTS_THEN2 MP_TAC K_TAC) THEN 19470 DISCH_THEN(MP_TAC o SPEC ``interval[a:real,b]``) THEN 19471 ASM_REWRITE_TAC[] THENL 19472 [ONCE_REWRITE_TAC [METIS [] 19473 ``(?a' b'. interval [(a,b)] = interval [(a',b')]) = 19474 (\a. (?a' b'. interval [(a,b)] = interval [(a',b')])) a``], 19475 ONCE_REWRITE_TAC [METIS [] 19476 ``(?a' b'. interval [(a,b)] = interval [(a',b')]) = 19477 (\b. (?a' b'. interval [(a,b)] = interval [(a',b')])) b``]] THEN 19478 MATCH_MP_TAC(SET_RULE 19479 ``u SUBSET s /\ x IN i ==> i SUBSET u /\ P x ==> x IN s``) THEN 19480 ASM_REWRITE_TAC[ENDS_IN_INTERVAL], 19481 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 19482 MATCH_MP_TAC(SIMP_RULE std_ss [IMP_CONJ_ALT] REAL_LE_TRANS) THEN 19483 ASM_SIMP_TAC std_ss [REAL_MUL_ASSOC, REAL_LE_RMUL] THEN 19484 REWRITE_TAC[REAL_ARITH ``x * &2 <= &8 <=> x <= &4:real``] THEN 19485 REWRITE_TAC[REAL_OF_NUM_LE] THEN 19486 MATCH_MP_TAC LESS_EQ_TRANS THEN EXISTS_TAC 19487 ``CARD(BIGUNION {{k | k IN d /\ ~(content k = &0) /\ x IN k} 19488 | (x:real) IN frontier s})`` THEN 19489 CONJ_TAC THENL 19490 [MATCH_MP_TAC (SIMP_RULE std_ss [AND_IMP_INTRO, 19491 GSYM RIGHT_FORALL_IMP_THM] CARD_SUBSET) THEN 19492 CONJ_TAC THENL 19493 [MATCH_MP_TAC FINITE_BIGUNION THEN 19494 ASM_SIMP_TAC std_ss [FORALL_IN_GSPEC, FINITE_RESTRICT] THEN 19495 ASM_SIMP_TAC real_ss [IMAGE_FINITE, GSYM IMAGE_DEF, BIGUNION_IMAGE], 19496 ALL_TAC] THEN 19497 ASM_SIMP_TAC std_ss [FORALL_IN_GSPEC, FINITE_RESTRICT] THEN 19498 ASM_SIMP_TAC real_ss [IMAGE_FINITE, GSYM IMAGE_DEF, BIGUNION_IMAGE] THEN 19499 GEN_REWR_TAC I [SUBSET_DEF] THEN SIMP_TAC std_ss [GSPECIFICATION] THEN 19500 ONCE_REWRITE_TAC[IMP_CONJ] THEN UNDISCH_TAC ``d division_of u`` THEN 19501 DISCH_TAC THEN FIRST_ASSUM(fn th => 19502 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 19503 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, 19504 INTERVAL_UPPERBOUND_NONEMPTY] THEN 19505 SIMP_TAC std_ss [INTERVAL_NE_EMPTY, CONTENT_CLOSED_INTERVAL, REAL_SUB_0] THEN 19506 REPEAT STRIP_TAC THEN 19507 FIRST_X_ASSUM(MP_TAC o MATCH_MP (SET_RULE 19508 ``~(s SUBSET t) ==> s SUBSET closure t 19509 ==> ?x. x IN (closure t DIFF t) /\ x IN s``)) THEN 19510 KNOW_TAC ``interval [(a,b:real)] SUBSET closure s`` THENL 19511 [ASM_MESON_TAC[division_of, SUBSET_DEF], 19512 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 19513 REWRITE_TAC[frontier] THEN 19514 MP_TAC(ISPEC ``s:real->bool`` INTERIOR_SUBSET) THEN ASM_SET_TAC[], 19515 MATCH_MP_TAC LESS_EQ_TRANS THEN EXISTS_TAC ``CARD(frontier s:real->bool) * 2`` THEN 19516 CONJ_TAC THENL [ALL_TAC, ASM_SIMP_TAC arith_ss []] THEN 19517 ONCE_REWRITE_TAC [METIS [] 19518 ``{k | k IN d /\ content k <> 0 /\ x IN k} = 19519 (\x. {k | k IN d /\ content k <> 0 /\ x IN k}) x``] THEN 19520 MATCH_MP_TAC CARD_BIGUNION_LE THEN 19521 ASM_SIMP_TAC std_ss [GSYM FINITE_HAS_SIZE, FINITE_RESTRICT] THEN 19522 SUBST1_TAC(METIS [EXP_1] ``(2:num) = 2 EXP 1``) THEN 19523 REPEAT STRIP_TAC THEN SIMP_TAC std_ss [] THEN 19524 SUBST1_TAC(METIS [EXP_1] ``(2:num) = 2 EXP 1``) THEN 19525 MATCH_MP_TAC DIVISION_COMMON_POINT_BOUND THEN METIS_TAC[]]]]]); 19526 19527val HAS_BOUNDED_VARIATION_ON_SING = store_thm ("HAS_BOUNDED_VARIATION_ON_SING", 19528 ``!f a. f has_bounded_variation_on {a}``, 19529 REWRITE_TAC[has_bounded_variation_on, has_bounded_setvariation_on, 19530 REWRITE_RULE[INTERVAL_SING] DIVISION_OF_SING] THEN 19531 REPEAT GEN_TAC THEN EXISTS_TAC ``&0:real`` THEN 19532 MAP_EVERY X_GEN_TAC [``d:(real->bool)->bool``, ``t:real->bool``] THEN 19533 STRIP_TAC THEN MATCH_MP_TAC REAL_EQ_IMP_LE THEN MATCH_MP_TAC SUM_EQ_0 THEN 19534 FIRST_ASSUM(fn th => 19535 SIMP_TAC std_ss [MATCH_MP FORALL_IN_DIVISION_NONEMPTY th]) THEN 19536 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, INTERVAL_UPPERBOUND_NONEMPTY] THEN 19537 MAP_EVERY X_GEN_TAC [``u:real``, ``v:real``] THEN STRIP_TAC THEN 19538 REWRITE_TAC[ABS_ZERO, REAL_SUB_0] THEN AP_TERM_TAC THEN 19539 SUBGOAL_THEN ``interval[u:real,v] SUBSET interval[a,a]`` MP_TAC THENL 19540 [REWRITE_TAC[INTERVAL_SING] THEN ASM_MESON_TAC[division_of, SUBSET_DEF], 19541 REWRITE_TAC[SUBSET_INTERVAL] THEN 19542 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [INTERVAL_NE_EMPTY]) THEN 19543 REAL_ARITH_TAC]); 19544 19545val INCREASING_LEFT_LIMIT = store_thm ("INCREASING_LEFT_LIMIT", 19546 ``!f a b c. 19547 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 19548 ==> (f x) <= (f y)) /\ 19549 c IN interval[a,b] 19550 ==> ?l. (f --> l) (at c within interval[a,c])``, 19551 REPEAT STRIP_TAC THEN EXISTS_TAC 19552 ``(sup {(f x) | x IN interval[a,b] /\ x < c})`` THEN 19553 ONCE_REWRITE_TAC [METIS [] ``{f x | x IN interval [(a,b)] /\ x < c} = 19554 {f x | (\x. x IN interval [(a,b)] /\ x < c) x}``] THEN 19555 ONCE_REWRITE_TAC[SIMPLE_IMAGE_GEN] THEN SIMP_TAC std_ss [LIM_WITHIN] THEN 19556 REWRITE_TAC[dist] THEN 19557 ASM_CASES_TAC ``{x | x IN interval[a,b] /\ x < c} = {}`` THENL 19558 [GEN_TAC THEN DISCH_TAC THEN EXISTS_TAC ``&1:real`` THEN 19559 REWRITE_TAC[REAL_LT_01] THEN 19560 UNDISCH_TAC ``{x:real | x IN interval [(a,b)] /\ x < c} = {}`` THEN 19561 DISCH_TAC THEN 19562 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [EXTENSION]) THEN 19563 DISCH_TAC THEN GEN_TAC THEN POP_ASSUM (MP_TAC o SPEC ``x:real``) THEN 19564 MATCH_MP_TAC(TAUT `(a ==> ~b) ==> a ==> b ==> c`) THEN 19565 SIMP_TAC std_ss [NOT_IN_EMPTY, GSPECIFICATION, IN_INTERVAL] THEN 19566 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN POP_ASSUM MP_TAC THEN 19567 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 19568 ALL_TAC] THEN 19569 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 19570 MP_TAC(ISPEC ``{((f:real->real) x) | x IN interval[a,b] /\ x < c}`` SUP) THEN 19571 ASM_SIMP_TAC std_ss [FORALL_IN_GSPEC] THEN 19572 KNOW_TAC ``{(f:real->real) x | x IN interval [(a,b)] /\ x < c} <> {} /\ 19573 (?b'. !x. x IN interval [(a,b)] /\ x < c ==> f x <= b')`` THENL 19574 [CONJ_TAC THENL 19575 [ONCE_REWRITE_TAC [METIS [] ``{f x | x IN interval [(a,b)] /\ x < c} = 19576 {f x | (\x. x IN interval [(a,b)] /\ x < c) x}``] THEN 19577 ONCE_REWRITE_TAC[SIMPLE_IMAGE_GEN] THEN ASM_SIMP_TAC std_ss [IMAGE_EQ_EMPTY], 19578 EXISTS_TAC ``(f(b:real)):real`` THEN REPEAT STRIP_TAC THEN 19579 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 19580 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_REAL_ARITH_TAC], 19581 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 19582 ONCE_REWRITE_TAC [METIS [] ``{f x | x IN interval [(a,b)] /\ x < c} = 19583 {f x | (\x. x IN interval [(a,b)] /\ x < c) x}``] THEN 19584 ONCE_REWRITE_TAC[SIMPLE_IMAGE_GEN] THEN SIMP_TAC std_ss [IMAGE_ID] THEN 19585 ABBREV_TAC ``s = sup (IMAGE (\x. (f x)) 19586 {x | x IN interval[a,b] /\ x < c})`` THEN 19587 ASM_SIMP_TAC std_ss [] THEN 19588 DISCH_THEN(CONJUNCTS_THEN2 ASSUME_TAC (MP_TAC o SPEC ``s - e:real``)) THEN 19589 FULL_SIMP_TAC std_ss [METIS [ETA_AX] ``(\x. f x) = f:real->real``] THEN 19590 ASM_SIMP_TAC std_ss [REAL_ARITH ``&0 < e ==> ~(s <= s - e:real)``, NOT_FORALL_THM] THEN 19591 SIMP_TAC std_ss [NOT_IMP, REAL_NOT_LE, IN_INTERVAL] THEN 19592 DISCH_THEN(X_CHOOSE_THEN ``d:real`` STRIP_ASSUME_TAC) THEN 19593 EXISTS_TAC ``c - d:real`` THEN 19594 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19595 CONJ_TAC THENL [POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19596 REAL_ARITH_TAC, ALL_TAC] THEN 19597 X_GEN_TAC ``x:real`` THEN STRIP_TAC THEN 19598 FIRST_X_ASSUM(MP_TAC o SPECL [``d:real``, ``x:real``]) THEN 19599 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN ASM_REAL_ARITH_TAC]); 19600 19601val DECREASING_LEFT_LIMIT = store_thm ("DECREASING_LEFT_LIMIT", 19602 ``!f a b c. 19603 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 19604 ==> (f y) <= (f x)) /\ 19605 c IN interval[a,b] 19606 ==> ?l. (f --> l) (at c within interval[a,c])``, 19607 REPEAT STRIP_TAC THEN 19608 MP_TAC(ISPECL 19609 [``\x. -((f:real->real) x)``, ``a:real``, ``b:real``, ``c:real``] 19610 INCREASING_LEFT_LIMIT) THEN 19611 ASM_SIMP_TAC std_ss [REAL_LE_NEG2] THEN 19612 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) [GSYM LIM_NEG_EQ] THEN 19613 SIMP_TAC std_ss [REAL_NEG_NEG, ETA_AX] THEN MESON_TAC[]); 19614 19615val INCREASING_RIGHT_LIMIT = store_thm ("INCREASING_RIGHT_LIMIT", 19616 ``!f a b c. 19617 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 19618 ==> (f x) <= (f y)) /\ 19619 c IN interval[a,b] 19620 ==> ?l. (f --> l) (at c within interval[c,b])``, 19621 REPEAT STRIP_TAC THEN 19622 MP_TAC(ISPECL [``\x. (f:real->real) (-x)``, 19623 ``-b:real``, ``-a:real``, ``-c:real``] 19624 DECREASING_LEFT_LIMIT) THEN 19625 ASM_SIMP_TAC std_ss [IN_INTERVAL_REFLECT] THEN 19626 ONCE_REWRITE_TAC [METIS [] 19627 ``((!x y. 19628 x IN interval [(-b,-a)] /\ y IN interval [(-b,-a)] /\ x <= y ==> 19629 f (-y) <= (f:real->real) (-x))) = 19630 (!x y. (\x y. 19631 x IN interval [(-b,-a)] /\ y IN interval [(-b,-a)] /\ x <= y ==> 19632 f (-y) <= f (-x)) x y)``] THEN 19633 ONCE_REWRITE_TAC[METIS [REAL_NEG_NEG] 19634 ``(!x:real y:real. P x y) <=> (!x y. P (-x) (-y))``] THEN 19635 SIMP_TAC std_ss [IN_INTERVAL_REFLECT, REAL_NEG_NEG] THEN 19636 ASM_SIMP_TAC std_ss [REAL_LE_NEG2] THEN 19637 DISCH_THEN (X_CHOOSE_TAC ``l:real``) THEN EXISTS_TAC ``l:real`` THEN 19638 POP_ASSUM MP_TAC THEN SIMP_TAC std_ss [LIM_WITHIN] THEN 19639 ONCE_REWRITE_TAC [METIS [] 19640 ``(!x. 19641 x IN interval [(-b,-c)] /\ 0 < dist (x,-c) /\ dist (x,-c) < d ==> 19642 dist (f (-x),l) < e) = 19643 (!x. 19644 (\x. x IN interval [(-b,-c)] /\ 0 < dist (x,-c) /\ dist (x,-c) < d ==> 19645 dist (f (-x),l) < e) x)``] THEN 19646 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) 19647 [MESON[REAL_NEG_NEG] ``(!x:real. P x) <=> (!x. P (-x))``] THEN 19648 SIMP_TAC std_ss [IN_INTERVAL_REFLECT, REAL_NEG_NEG, dist, 19649 REAL_ARITH ``abs(-x:real - -y) = abs(x - y)``]); 19650 19651val DECREASING_RIGHT_LIMIT = store_thm ("DECREASING_RIGHT_LIMIT", 19652 ``!f a b c. 19653 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ x <= y 19654 ==> (f y) <= (f x)) /\ 19655 c IN interval[a,b] 19656 ==> ?l. (f --> l) (at c within interval[c,b])``, 19657 REPEAT STRIP_TAC THEN 19658 MP_TAC(ISPECL 19659 [``\x. -((f:real->real) x)``, ``a:real``, ``b:real``, ``c:real``] 19660 INCREASING_RIGHT_LIMIT) THEN 19661 ASM_SIMP_TAC std_ss [REAL_LE_NEG2] THEN 19662 GEN_REWR_TAC (LAND_CONV o ONCE_DEPTH_CONV) [GSYM LIM_NEG_EQ] THEN 19663 SIMP_TAC std_ss [REAL_NEG_NEG, ETA_AX] THEN MESON_TAC[]); 19664 19665val HAS_BOUNDED_VECTOR_VARIATION_LEFT_LIMIT = store_thm ("HAS_BOUNDED_VECTOR_VARIATION_LEFT_LIMIT", 19666 ``!f:real->real a b c. 19667 f has_bounded_variation_on interval[a,b] /\ c IN interval[a,b] 19668 ==> ?l. (f --> l) (at c within interval[a,c])``, 19669 REPEAT GEN_TAC THEN DISCH_THEN (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 19670 DISCH_THEN 19671 (MP_TAC o REWRITE_RULE [HAS_BOUNDED_VARIATION_DARBOUX]) THEN 19672 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM, CONJ_ASSOC] THEN REPEAT GEN_TAC THEN 19673 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 19674 REWRITE_TAC[GSYM CONJ_ASSOC] THEN DISCH_THEN(CONJUNCTS_THEN 19675 (MP_TAC o SPEC ``c:real`` o MATCH_MP 19676 (ONCE_REWRITE_RULE[IMP_CONJ] INCREASING_LEFT_LIMIT))) THEN 19677 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 19678 X_GEN_TAC ``l2:real`` THEN DISCH_TAC THEN 19679 X_GEN_TAC ``l1:real`` THEN DISCH_TAC THEN 19680 EXISTS_TAC ``l1 - l2:real`` THEN 19681 GEN_REWR_TAC (RATOR_CONV o LAND_CONV) [GSYM ETA_AX] THEN 19682 ASM_SIMP_TAC std_ss [LIM_SUB]); 19683 19684val HAS_BOUNDED_VECTOR_VARIATION_RIGHT_LIMIT = store_thm ("HAS_BOUNDED_VECTOR_VARIATION_RIGHT_LIMIT", 19685 ``!f:real->real a b c. 19686 f has_bounded_variation_on interval[a,b] /\ c IN interval[a,b] 19687 ==> ?l. (f --> l) (at c within interval[c,b])``, 19688 REPEAT GEN_TAC THEN DISCH_THEN (CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 19689 DISCH_THEN 19690 (MP_TAC o REWRITE_RULE [HAS_BOUNDED_VARIATION_DARBOUX]) THEN 19691 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM, CONJ_ASSOC] THEN REPEAT GEN_TAC THEN 19692 DISCH_THEN(CONJUNCTS_THEN2 MP_TAC ASSUME_TAC) THEN 19693 REWRITE_TAC[GSYM CONJ_ASSOC] THEN DISCH_THEN(CONJUNCTS_THEN 19694 (MP_TAC o SPEC ``c:real`` o MATCH_MP 19695 (ONCE_REWRITE_RULE[IMP_CONJ] INCREASING_RIGHT_LIMIT))) THEN 19696 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 19697 X_GEN_TAC ``l2:real`` THEN DISCH_TAC THEN 19698 X_GEN_TAC ``l1:real`` THEN DISCH_TAC THEN 19699 EXISTS_TAC ``l1 - l2:real`` THEN 19700 GEN_REWR_TAC (RATOR_CONV o LAND_CONV) [GSYM ETA_AX] THEN 19701 ASM_SIMP_TAC std_ss [LIM_SUB]); 19702 19703val lemma = prove ( 19704 ``!f:real->real a b c. 19705 f has_bounded_variation_on interval[a,b] /\ c IN interval[a,b] 19706 ==> ((\x. (vector_variation(interval[a,x]) f)) 19707 continuous (at c within interval[a,c]) <=> 19708 f continuous (at c within interval[a,c]))``, 19709 REPEAT STRIP_TAC THEN EQ_TAC THENL 19710 [REWRITE_TAC[continuous_within] THEN 19711 SIMP_TAC std_ss [GSPECIFICATION, dist] THEN 19712 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 19713 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 19714 DISCH_THEN (X_CHOOSE_TAC ``d:real``) THEN EXISTS_TAC ``d:real`` THEN 19715 POP_ASSUM MP_TAC THEN STRIP_TAC THEN 19716 ASM_REWRITE_TAC[] THEN X_GEN_TAC ``x:real`` THEN STRIP_TAC THEN 19717 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN ASM_REWRITE_TAC[] THEN 19718 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LET_TRANS) THEN 19719 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``c:real``, ``x:real``] 19720 VECTOR_VARIATION_COMBINE) THEN 19721 KNOW_TAC ``a <= x /\ x <= c /\ 19722 (f:real->real) has_bounded_variation_on interval [(a,c)]`` THENL 19723 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19724 REPEAT(CONJ_TAC THENL [ASM_REAL_ARITH_TAC, ALL_TAC]) THEN 19725 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 19726 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 19727 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_REAL_ARITH_TAC, 19728 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 19729 DISCH_THEN(SUBST1_TAC o SYM) THEN 19730 REWRITE_TAC[REAL_ARITH ``abs(a - (a + b)) = abs b:real``] THEN 19731 MATCH_MP_TAC(REAL_ARITH ``x <= a ==> x <= abs a:real``) THEN 19732 ONCE_REWRITE_TAC[ABS_SUB] THEN 19733 MATCH_MP_TAC VECTOR_VARIATION_GE_ABS_FUNCTION THEN CONJ_TAC THENL 19734 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 19735 HAS_BOUNDED_VARIATION_ON_SUBSET)), 19736 REWRITE_TAC[SEGMENT] THEN COND_CASES_TAC] THEN 19737 REWRITE_TAC[SUBSET_INTERVAL] THEN 19738 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_REAL_ARITH_TAC, 19739 ALL_TAC] THEN 19740 DISCH_TAC THEN ASM_CASES_TAC ``c limit_point_of interval[a:real,c]`` THENL 19741 [ALL_TAC, 19742 ASM_REWRITE_TAC[CONTINUOUS_WITHIN, LIM, TRIVIAL_LIMIT_WITHIN]] THEN 19743 UNDISCH_TAC ``f has_bounded_variation_on interval [(a,b)]`` THEN 19744 DISCH_TAC THEN FIRST_ASSUM(MP_TAC o 19745 REWRITE_RULE [HAS_BOUNDED_VARIATION_DARBOUX]) THEN 19746 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 19747 MAP_EVERY X_GEN_TAC [``g:real->real``, ``h:real->real``] THEN 19748 STRIP_TAC THEN 19749 MP_TAC(ISPECL [``h:real->real``, ``a:real``, ``b:real``, ``c:real``] 19750 INCREASING_LEFT_LIMIT) THEN 19751 MP_TAC(ISPECL [``g:real->real``, ``a:real``, ``b:real``, ``c:real``] 19752 INCREASING_LEFT_LIMIT) THEN 19753 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 19754 X_GEN_TAC ``gc:real`` THEN DISCH_TAC THEN 19755 X_GEN_TAC ``hc:real`` THEN DISCH_TAC THEN 19756 ABBREV_TAC ``k = gc - (g:real->real) c`` THEN 19757 SUBGOAL_THEN ``hc - (h:real->real) c = k`` ASSUME_TAC THENL 19758 [EXPAND_TAC "k" THEN 19759 ONCE_REWRITE_TAC[REAL_ARITH 19760 ``(hc' - hc:real = gc' - gc) <=> (gc' - hc' = gc - hc)``] THEN 19761 UNDISCH_TAC ``f continuous (at c within interval [(a,c)])`` THEN DISCH_TAC THEN 19762 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [CONTINUOUS_WITHIN]) THEN 19763 ASM_REWRITE_TAC[] THEN 19764 MATCH_MP_TAC(REWRITE_RULE[TAUT `a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] 19765 LIM_UNIQUE) THEN 19766 ASM_REWRITE_TAC[TRIVIAL_LIMIT_WITHIN] THEN 19767 GEN_REWR_TAC (RATOR_CONV o LAND_CONV) [GSYM ETA_AX] THEN 19768 ASM_SIMP_TAC std_ss [LIM_SUB], 19769 ALL_TAC] THEN 19770 MAP_EVERY ABBREV_TAC 19771 [``g':real->real = \x. if c <= x then g(x) + k else g(x)``, 19772 ``h':real->real = 19773 \x. if c <= x then h(x) + k else h(x)``] THEN 19774 SUBGOAL_THEN 19775 ``(!x y. x IN interval[a,c] /\ y IN interval[a,c] /\ x <= y 19776 ==> (g' x) <= ((g':real->real) y)) /\ 19777 (!x y. x IN interval[a,c] /\ y IN interval[a,c] /\ x <= y 19778 ==> (h' x) <= ((h':real->real) y))`` 19779 STRIP_ASSUME_TAC THENL 19780 [MAP_EVERY EXPAND_TAC ["g'", "h'"] THEN SIMP_TAC std_ss [] THEN CONJ_TAC THEN 19781 MAP_EVERY X_GEN_TAC [``x:real``, ``y:real``] THEN 19782 REWRITE_TAC[IN_INTERVAL] THEN STRIP_TAC THEN 19783 (ASM_CASES_TAC ``c <= x:real`` THENL 19784 [SUBGOAL_THEN ``c <= y:real`` ASSUME_TAC THENL 19785 [POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19786 UNDISCH_TAC ``x <= c:real`` THEN REAL_ARITH_TAC, 19787 ASM_SIMP_TAC std_ss []] THEN 19788 REWRITE_TAC[REAL_LE_RADD] THEN 19789 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 19790 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19791 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 19792 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19793 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19794 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19795 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 19796 ALL_TAC] THEN 19797 ASM_SIMP_TAC std_ss [] THEN COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [] THENL 19798 [ALL_TAC, 19799 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 19800 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19801 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 19802 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19803 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19804 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19805 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC] THEN 19806 SUBGOAL_THEN ``y:real = c`` SUBST_ALL_TAC THENL 19807 [UNDISCH_TAC ``y <= c:real`` THEN POP_ASSUM MP_TAC THEN 19808 REAL_ARITH_TAC, ALL_TAC] THEN 19809 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (METIS [] 19810 ``(gc - (g:real->real) c = k) 19811 ==> b <= (g c + (gc - g c)) ==> b <= (g c + k)``)) THEN 19812 REWRITE_TAC[REAL_ARITH ``a + (b - a:real) = b``] THEN 19813 MATCH_MP_TAC(ISPEC ``at c within interval[a:real,c]`` 19814 LIM_DROP_LBOUND)) 19815 THENL [EXISTS_TAC ``g:real->real``, EXISTS_TAC ``h:real->real``] THEN 19816 ASM_REWRITE_TAC[TRIVIAL_LIMIT_WITHIN, EVENTUALLY_WITHIN] THEN 19817 EXISTS_TAC ``c - x:real`` THEN 19818 (CONJ_TAC THENL [UNDISCH_TAC ``~(c <= x:real)`` THEN 19819 REAL_ARITH_TAC, ALL_TAC]) THEN 19820 REWRITE_TAC[dist, IN_INTERVAL] THEN 19821 SIMP_TAC std_ss [IN_INTERVAL] THEN REPEAT STRIP_TAC THEN 19822 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 19823 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19824 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 19825 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19826 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19827 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19828 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19829 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19830 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 19831 ALL_TAC] THEN 19832 SUBGOAL_THEN 19833 ``(g':real->real) continuous (at c within interval[a,c]) /\ 19834 (h':real->real) continuous (at c within interval[a,c])`` 19835 MP_TAC THENL 19836 [MAP_EVERY EXPAND_TAC ["g'", "h'"] THEN 19837 SIMP_TAC std_ss [CONTINUOUS_WITHIN, REAL_LE_REFL] THEN 19838 RULE_ASSUM_TAC(REWRITE_RULE[REAL_ARITH 19839 ``(g - g':real = k) <=> (g' + k = g:real)``]) THEN 19840 ASM_REWRITE_TAC[] THEN CONJ_TAC THEN 19841 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP 19842 (REWRITE_RULE[IMP_CONJ_ALT] LIM_TRANSFORM)) THEN 19843 MAP_EVERY EXPAND_TAC ["g'", "h'"] THEN 19844 REWRITE_TAC[LIM_WITHIN, dist, IN_INTERVAL] THEN 19845 SIMP_TAC std_ss [REAL_ARITH ``x <= c /\ &0 < abs(x - c) ==> ~(c <= x:real)``] THEN 19846 REWRITE_TAC[REAL_SUB_REFL, ABS_N] THEN 19847 MESON_TAC[REAL_LT_01], 19848 ALL_TAC] THEN 19849 REWRITE_TAC[continuous_within] THEN 19850 SIMP_TAC std_ss [GSPECIFICATION, dist] THEN 19851 DISCH_THEN(fn th => 19852 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 19853 CONJUNCTS_THEN (MP_TAC o SPEC ``e / &2:real``) th) THEN 19854 ASM_REWRITE_TAC[REAL_HALF] THEN 19855 DISCH_THEN(X_CHOOSE_THEN ``d2:real`` STRIP_ASSUME_TAC) THEN 19856 DISCH_THEN(X_CHOOSE_THEN ``d1:real`` STRIP_ASSUME_TAC) THEN 19857 EXISTS_TAC ``min d1 d2:real`` THEN ASM_REWRITE_TAC[REAL_LT_MIN] THEN 19858 X_GEN_TAC ``d:real`` THEN STRIP_TAC THEN 19859 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``c:real``, ``d:real``] 19860 VECTOR_VARIATION_COMBINE) THEN 19861 KNOW_TAC ``a <= d /\ d <= c /\ 19862 (f:real->real) has_bounded_variation_on interval [(a,c)]`` THENL 19863 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19864 ASM_SIMP_TAC real_ss [] THEN 19865 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 19866 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 19867 REWRITE_TAC[SUBSET_INTERVAL] THEN 19868 UNDISCH_TAC ``a <= c /\ c <= b:real`` THEN REAL_ARITH_TAC, 19869 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 19870 DISCH_THEN(SUBST1_TAC o SYM)] THEN 19871 REWRITE_TAC[REAL_ARITH ``abs(a - (a + b)) = abs b:real``] THEN 19872 MATCH_MP_TAC(REAL_ARITH ``&0 <= x /\ x < a ==> abs x < a:real``) THEN 19873 CONJ_TAC THENL 19874 [MATCH_MP_TAC VECTOR_VARIATION_POS_LE THEN 19875 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 19876 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 19877 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19878 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_SIMP_TAC real_ss [], 19879 ALL_TAC] THEN 19880 SUBGOAL_THEN ``f:real->real = \x. g' x - h' x`` SUBST1_TAC THENL 19881 [MAP_EVERY EXPAND_TAC ["g'", "h'"] THEN SIMP_TAC std_ss [FUN_EQ_THM] THEN 19882 GEN_TAC THEN COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [] THEN REAL_ARITH_TAC, 19883 ALL_TAC] THEN 19884 MP_TAC(ISPECL 19885 [``g':real->real``, ``\x. -((h':real->real) x)``, 19886 ``interval[d:real,c]``] VECTOR_VARIATION_TRIANGLE) THEN 19887 KNOW_TAC ``(g':real->real) has_bounded_variation_on interval [(d,c)] /\ 19888 (\x. -h' x) has_bounded_variation_on interval [(d,c)]`` THENL 19889 [CONJ_TAC THENL [ALL_TAC, MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_NEG] THEN 19890 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_SUBSET THEN 19891 EXISTS_TAC ``interval[a:real,c]`` THEN 19892 ASM_SIMP_TAC std_ss [INCREASING_BOUNDED_VARIATION, SUBSET_INTERVAL] THEN 19893 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_SIMP_TAC real_ss [], 19894 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 19895 SIMP_TAC std_ss [real_sub] THEN MATCH_MP_TAC(REAL_ARITH 19896 ``y * 2 < a /\ z * 2 < a ==> x <= y + z ==> x < a:real``) THEN 19897 REWRITE_TAC[VECTOR_VARIATION_NEG] THEN CONJ_TAC THEN 19898 SIMP_TAC real_ss [GSYM REAL_LT_RDIV_EQ] THEN 19899 W(MP_TAC o PART_MATCH (lhs o rand) 19900 INCREASING_VECTOR_VARIATION o lhand o snd) THENL 19901 [KNOW_TAC ``interval [(d,c)] <> {} /\ 19902 (!x y. x IN interval [(d,c)] /\ y IN interval [(d,c)] /\ x <= y ==> 19903 g' x <= (g':real->real) y)`` THENL 19904 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19905 ASM_REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY, IN_INTERVAL, REAL_NOT_LT] THEN 19906 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 19907 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 19908 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19909 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19910 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19911 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19912 REAL_ARITH_TAC, 19913 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 19914 DISCH_THEN SUBST1_TAC], 19915 KNOW_TAC ``interval [(d,c)] <> {} /\ 19916 (!x y. x IN interval [(d,c)] /\ y IN interval [(d,c)] /\ x <= y ==> 19917 h' x <= (h':real->real) y)`` THENL 19918 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19919 ASM_REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY, IN_INTERVAL, REAL_NOT_LT] THEN 19920 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 19921 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 19922 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19923 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19924 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19925 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 19926 REAL_ARITH_TAC, 19927 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 19928 DISCH_THEN SUBST1_TAC]] THEN 19929 MATCH_MP_TAC(REAL_ARITH ``abs(x - y) < e ==> y - x < e:real``) THEN 19930 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[]); 19931 19932val VECTOR_VARIATION_CONTINUOUS_LEFT = store_thm ("VECTOR_VARIATION_CONTINUOUS_LEFT", 19933 ``!f:real->real a b c. 19934 f has_bounded_variation_on interval[a,b] /\ c IN interval[a,b] 19935 ==> ((\x. (vector_variation(interval[a,x]) f)) 19936 continuous (at c within interval[a,c]) <=> 19937 f continuous (at c within interval[a,c]))``, 19938 REPEAT STRIP_TAC THEN EQ_TAC THENL 19939 [REWRITE_TAC[continuous_within] THEN 19940 SIMP_TAC std_ss [GSPECIFICATION, dist] THEN 19941 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 19942 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 19943 STRIP_TAC THEN EXISTS_TAC ``d:real`` THEN 19944 ASM_REWRITE_TAC[] THEN X_GEN_TAC ``x:real`` THEN STRIP_TAC THEN 19945 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN ASM_REWRITE_TAC[] THEN 19946 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LET_TRANS) THEN 19947 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``c:real``, ``x:real``] 19948 VECTOR_VARIATION_COMBINE) THEN 19949 KNOW_TAC ``a <= x /\ x <= c /\ 19950 (f:real->real) has_bounded_variation_on interval [(a,c)]`` THENL 19951 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 19952 REPEAT(CONJ_TAC THENL [ASM_REAL_ARITH_TAC, ALL_TAC]) THEN 19953 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 19954 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 19955 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_REAL_ARITH_TAC, 19956 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 19957 DISCH_THEN(SUBST1_TAC o SYM) THEN 19958 REWRITE_TAC[REAL_ARITH ``abs(a - (a + b)) = abs b:real``] THEN 19959 REWRITE_TAC[dist] THEN 19960 MATCH_MP_TAC(REAL_ARITH ``x <= a ==> x <= abs a:real``) THEN 19961 ONCE_REWRITE_TAC[ABS_SUB] THEN 19962 MATCH_MP_TAC VECTOR_VARIATION_GE_ABS_FUNCTION THEN CONJ_TAC THENL 19963 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 19964 HAS_BOUNDED_VARIATION_ON_SUBSET)), 19965 REWRITE_TAC[SEGMENT] THEN COND_CASES_TAC] THEN 19966 REWRITE_TAC[SUBSET_INTERVAL] THEN 19967 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_REAL_ARITH_TAC, 19968 ALL_TAC] THEN 19969 DISCH_TAC THEN ASM_CASES_TAC ``c limit_point_of interval[a:real,c]`` THENL 19970 [ALL_TAC, 19971 ASM_REWRITE_TAC[CONTINUOUS_WITHIN, LIM, TRIVIAL_LIMIT_WITHIN]] THEN 19972 MATCH_MP_TAC(CONTINUOUS_WITHIN_COMPARISON) THEN 19973 EXISTS_TAC ``\x. sum ((1:num)..(1:num)) 19974 (\i. (vector_variation (interval[a,x]) 19975 (\u. (((f:real->real) u)))))`` THEN 19976 SIMP_TAC std_ss [] THEN CONJ_TAC THENL 19977 [ONCE_REWRITE_TAC [METIS [] 19978 ``((\x. sum ((1:num) .. (1:num)) 19979 (\i. vector_variation (interval [(a,x)]) (\u. f u)))) = 19980 ((\x. sum ((1:num) .. (1:num)) 19981 (\i. (\i x. vector_variation (interval [(a,x)]) (\u. f u)) i x)))``] THEN 19982 MATCH_MP_TAC CONTINUOUS_SUM THEN SIMP_TAC std_ss [FINITE_NUMSEG] THEN 19983 REWRITE_TAC[IN_NUMSEG] THEN REPEAT STRIP_TAC THEN 19984 W(MP_TAC o PART_MATCH (lhs o rand) lemma o snd) THEN 19985 METIS_TAC [], 19986 ALL_TAC] THEN 19987 X_GEN_TAC ``x:real`` THEN REWRITE_TAC[IN_INTERVAL] THEN DISCH_TAC THEN 19988 REWRITE_TAC[dist, GSYM SUM_SUB_NUMSEG] THEN 19989 SUBGOAL_THEN 19990 ``(vector_variation(interval [a,c]) (f:real->real) = 19991 vector_variation(interval [a,x]) (f:real->real) + 19992 vector_variation(interval [x,c]) (f:real->real)) /\ 19993 (vector_variation(interval [a,c]) (\x. ((f:real->real) x)) = 19994 vector_variation(interval [a,x]) (\x. (f x)) + 19995 vector_variation(interval [x,c]) (\x. (f x)))`` 19996 (fn th => ASM_SIMP_TAC std_ss [th]) 19997 THENL 19998 [REPEAT STRIP_TAC THEN CONV_TAC SYM_CONV THEN 19999 MATCH_MP_TAC VECTOR_VARIATION_COMBINE THEN 20000 ASM_REWRITE_TAC[] THEN 20001 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_SUBSET THEN 20002 EXISTS_TAC ``interval[a:real,b]`` THEN 20003 ASM_REWRITE_TAC[SUBSET_INTERVAL] THEN 20004 RULE_ASSUM_TAC(ONCE_REWRITE_RULE 20005 [HAS_BOUNDED_VARIATION_ON_COMPONENTWISE]) THEN 20006 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20007 ASM_SIMP_TAC std_ss [REAL_LE_REFL], 20008 REWRITE_TAC[REAL_ADD_SUB]] THEN 20009 SIMP_TAC std_ss [NUMSEG_SING, SUM_SING, ETA_AX, REAL_LE_REFL]); 20010 20011val lemma = prove ( 20012 ``!f:real->real a b c. 20013 f has_bounded_variation_on interval[a,b] /\ c IN interval[a,b] 20014 ==> ((\x. (vector_variation(interval[a,x]) f)) 20015 continuous (at c within interval[c,b]) <=> 20016 f continuous (at c within interval[c,b]))``, 20017 REPEAT STRIP_TAC THEN EQ_TAC THENL 20018 [REWRITE_TAC[continuous_within] THEN 20019 SIMP_TAC std_ss [GSPECIFICATION, dist] THEN 20020 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 20021 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 20022 STRIP_TAC THEN EXISTS_TAC ``d:real`` THEN 20023 ASM_REWRITE_TAC[] THEN X_GEN_TAC ``x:real`` THEN STRIP_TAC THEN 20024 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN ASM_REWRITE_TAC[] THEN 20025 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LET_TRANS) THEN 20026 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``x:real``, ``c:real``] 20027 VECTOR_VARIATION_COMBINE) THEN 20028 KNOW_TAC ``a <= c /\ c <= x /\ 20029 (f:real->real) has_bounded_variation_on interval [(a,x)]`` THENL 20030 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20031 REPEAT(CONJ_TAC THENL [ASM_REAL_ARITH_TAC, ALL_TAC]) THEN 20032 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 20033 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 20034 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_REAL_ARITH_TAC, 20035 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 20036 DISCH_THEN(SUBST1_TAC o SYM) THEN 20037 REWRITE_TAC[REAL_ARITH ``abs((a + b) - a) = abs b:real``] THEN 20038 MATCH_MP_TAC(REAL_ARITH ``x <= a ==> x <= abs a:real``) THEN 20039 MATCH_MP_TAC VECTOR_VARIATION_GE_ABS_FUNCTION THEN CONJ_TAC THENL 20040 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 20041 HAS_BOUNDED_VARIATION_ON_SUBSET)), 20042 REWRITE_TAC[SEGMENT] THEN COND_CASES_TAC] THEN 20043 REWRITE_TAC[SUBSET_INTERVAL] THEN 20044 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_REAL_ARITH_TAC, 20045 ALL_TAC] THEN 20046 DISCH_TAC THEN ASM_CASES_TAC ``c limit_point_of interval[c:real,b]`` THENL 20047 [ALL_TAC, 20048 ASM_REWRITE_TAC[CONTINUOUS_WITHIN, LIM, TRIVIAL_LIMIT_WITHIN]] THEN 20049 UNDISCH_TAC ``(f:real->real) has_bounded_variation_on interval [(a,b)]`` THEN 20050 DISCH_TAC THEN FIRST_ASSUM(MP_TAC o 20051 REWRITE_RULE [HAS_BOUNDED_VARIATION_DARBOUX]) THEN 20052 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 20053 MAP_EVERY X_GEN_TAC [``g:real->real``, ``h:real->real``] THEN 20054 STRIP_TAC THEN 20055 MP_TAC(ISPECL [``h:real->real``, ``a:real``, ``b:real``, ``c:real``] 20056 INCREASING_RIGHT_LIMIT) THEN 20057 MP_TAC(ISPECL [``g:real->real``, ``a:real``, ``b:real``, ``c:real``] 20058 INCREASING_RIGHT_LIMIT) THEN 20059 ASM_SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 20060 X_GEN_TAC ``gc:real`` THEN DISCH_TAC THEN 20061 X_GEN_TAC ``hc:real`` THEN DISCH_TAC THEN 20062 ABBREV_TAC ``k = gc - (g:real->real) c`` THEN 20063 SUBGOAL_THEN ``hc - (h:real->real) c = k`` ASSUME_TAC THENL 20064 [EXPAND_TAC "k" THEN 20065 ONCE_REWRITE_TAC[REAL_ARITH 20066 ``(hc' - hc:real = gc' - gc) <=> (gc' - hc' = gc - hc)``] THEN 20067 UNDISCH_TAC ``f continuous (at c within interval [(c,b)])`` THEN DISCH_TAC THEN 20068 FIRST_X_ASSUM(MP_TAC o REWRITE_RULE [CONTINUOUS_WITHIN]) THEN 20069 ASM_REWRITE_TAC[] THEN 20070 MATCH_MP_TAC(REWRITE_RULE[TAUT`a /\ b /\ c ==> d <=> a /\ b ==> c ==> d`] 20071 LIM_UNIQUE) THEN 20072 ASM_REWRITE_TAC[TRIVIAL_LIMIT_WITHIN] THEN 20073 GEN_REWR_TAC (RATOR_CONV o LAND_CONV) [GSYM ETA_AX] THEN 20074 ASM_SIMP_TAC std_ss [LIM_SUB], 20075 ALL_TAC] THEN 20076 MAP_EVERY ABBREV_TAC 20077 [``g':real->real = \x. if x <= c then g(x) + k else g(x)``, 20078 ``h':real->real = 20079 \x. if x <= c then h(x) + k else h(x)``] THEN 20080 SUBGOAL_THEN 20081 ``(!x y. x IN interval[c,b] /\ y IN interval[c,b] /\ x <= y 20082 ==> (g' x) <= ((g':real->real) y)) /\ 20083 (!x y. x IN interval[c,b] /\ y IN interval[c,b] /\ x <= y 20084 ==> (h' x) <= ((h':real->real) y))`` 20085 STRIP_ASSUME_TAC THENL 20086 [MAP_EVERY EXPAND_TAC ["g'", "h'"] THEN SIMP_TAC std_ss [] THEN CONJ_TAC THEN 20087 MAP_EVERY X_GEN_TAC [``x:real``, ``y:real``] THEN 20088 REWRITE_TAC[IN_INTERVAL] THEN STRIP_TAC THEN 20089 (ASM_CASES_TAC ``y <= c:real`` THENL 20090 [SUBGOAL_THEN ``x <= c:real`` ASSUME_TAC THENL 20091 [POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20092 REAL_ARITH_TAC, ASM_REWRITE_TAC[]] THEN 20093 SIMP_TAC std_ss [REAL_LE_RADD] THEN 20094 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 20095 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20096 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 20097 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20098 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20099 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20100 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 20101 ALL_TAC] THEN 20102 ASM_SIMP_TAC std_ss [] THEN COND_CASES_TAC THEN ASM_SIMP_TAC std_ss [] THENL 20103 [ALL_TAC, 20104 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 20105 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20106 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 20107 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20108 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20109 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20110 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC] THEN 20111 SUBGOAL_THEN ``x:real = c`` SUBST_ALL_TAC THENL 20112 [UNDISCH_TAC ``c <= x:real`` THEN POP_ASSUM MP_TAC THEN 20113 REAL_ARITH_TAC, ALL_TAC] THEN 20114 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (MESON[] 20115 ``(gc - (g:real->real) c = k) 20116 ==> (g c + (gc - g c)) <= b ==> (g c + k) <= b``)) THEN 20117 REWRITE_TAC[REAL_ARITH ``a + (b - a:real) = b``] THEN 20118 MATCH_MP_TAC(ISPEC ``at c within interval[c:real,b]`` 20119 LIM_DROP_UBOUND)) 20120 THENL [EXISTS_TAC ``g:real->real``, EXISTS_TAC ``h:real->real``] THEN 20121 ASM_SIMP_TAC std_ss [TRIVIAL_LIMIT_WITHIN, EVENTUALLY_WITHIN] THEN 20122 EXISTS_TAC ``y - c:real`` THEN 20123 (CONJ_TAC THENL [POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20124 REAL_ARITH_TAC, ALL_TAC]) THEN 20125 REWRITE_TAC[dist, IN_INTERVAL] THEN 20126 SIMP_TAC std_ss [IN_INTERVAL] THEN REPEAT STRIP_TAC THEN 20127 FIRST_X_ASSUM MATCH_MP_TAC THEN REWRITE_TAC[IN_INTERVAL] THEN 20128 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20129 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 20130 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20131 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20132 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20133 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20134 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20135 POP_ASSUM MP_TAC THEN REAL_ARITH_TAC, 20136 ALL_TAC] THEN 20137 SUBGOAL_THEN 20138 ``(g':real->real) continuous (at c within interval[c,b]) /\ 20139 (h':real->real) continuous (at c within interval[c,b])`` 20140 MP_TAC THENL 20141 [MAP_EVERY EXPAND_TAC ["g'", "h'"] THEN 20142 SIMP_TAC std_ss [CONTINUOUS_WITHIN, REAL_LE_REFL] THEN 20143 RULE_ASSUM_TAC(REWRITE_RULE[REAL_ARITH 20144 ``(g - g':real = k) <=> (g' + k = g:real)``]) THEN 20145 ASM_SIMP_TAC std_ss [] THEN CONJ_TAC THEN 20146 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP 20147 (REWRITE_RULE[IMP_CONJ_ALT] LIM_TRANSFORM)) THEN 20148 MAP_EVERY EXPAND_TAC ["g'", "h'"] THEN 20149 SIMP_TAC std_ss [LIM_WITHIN, dist, IN_INTERVAL] THEN 20150 SIMP_TAC std_ss [REAL_ARITH ``c <= x /\ &0 < abs(x - c) ==> ~(x <= c:real)``] THEN 20151 REWRITE_TAC[REAL_SUB_REFL, ABS_N] THEN 20152 MESON_TAC[REAL_LT_01], 20153 ALL_TAC] THEN 20154 REWRITE_TAC[continuous_within] THEN 20155 SIMP_TAC std_ss [dist, GSPECIFICATION] THEN 20156 DISCH_THEN(fn th => 20157 X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 20158 CONJUNCTS_THEN (MP_TAC o SPEC ``e / &2:real``) th) THEN 20159 ASM_REWRITE_TAC[REAL_HALF] THEN 20160 DISCH_THEN(X_CHOOSE_THEN ``d2:real`` STRIP_ASSUME_TAC) THEN 20161 DISCH_THEN(X_CHOOSE_THEN ``d1:real`` STRIP_ASSUME_TAC) THEN 20162 EXISTS_TAC ``min d1 d2:real`` THEN ASM_REWRITE_TAC[REAL_LT_MIN] THEN 20163 X_GEN_TAC ``d:real`` THEN STRIP_TAC THEN 20164 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``d:real``, ``c:real``] 20165 VECTOR_VARIATION_COMBINE) THEN 20166 KNOW_TAC ``a <= c /\ c <= d /\ 20167 (f:real->real) has_bounded_variation_on interval [(a,d)]`` THENL 20168 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20169 ASM_SIMP_TAC real_ss [] THEN 20170 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 20171 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 20172 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_SIMP_TAC real_ss [], 20173 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 20174 DISCH_THEN(SUBST1_TAC o SYM)] THEN 20175 REWRITE_TAC[REAL_ARITH ``(a + b) - a:real = b:real``] THEN 20176 MATCH_MP_TAC(REAL_ARITH ``&0 <= x /\ x < a ==> abs x < a:real``) THEN 20177 CONJ_TAC THENL 20178 [MATCH_MP_TAC VECTOR_VARIATION_POS_LE THEN 20179 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 20180 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 20181 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20182 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_SIMP_TAC real_ss [], 20183 ALL_TAC] THEN 20184 SUBGOAL_THEN ``f:real->real = \x. g' x - h' x`` SUBST1_TAC THENL 20185 [MAP_EVERY EXPAND_TAC ["g'", "h'"] THEN SIMP_TAC std_ss [FUN_EQ_THM] THEN 20186 GEN_TAC THEN COND_CASES_TAC THEN ASM_REWRITE_TAC[] THEN REAL_ARITH_TAC, 20187 ALL_TAC] THEN 20188 MP_TAC(ISPECL 20189 [``g':real->real``, ``\x. -((h':real->real) x)``, 20190 ``interval[c:real,d]``] VECTOR_VARIATION_TRIANGLE) THEN 20191 KNOW_TAC ``(g':real->real) has_bounded_variation_on interval [(c,d)] /\ 20192 (\x. -h' x) has_bounded_variation_on interval [(c,d)]`` THENL 20193 [CONJ_TAC THENL [ALL_TAC, MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_NEG] THEN 20194 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_SUBSET THEN 20195 EXISTS_TAC ``interval[c:real,b]`` THEN 20196 ASM_SIMP_TAC std_ss [INCREASING_BOUNDED_VARIATION, SUBSET_INTERVAL] THEN 20197 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_SIMP_TAC real_ss [], 20198 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 20199 SIMP_TAC std_ss [real_sub] THEN MATCH_MP_TAC(REAL_ARITH 20200 ``y * 2 < a /\ z * 2 < a ==> x <= y + z ==> x < a:real``) THEN 20201 SIMP_TAC std_ss [VECTOR_VARIATION_NEG] THEN CONJ_TAC THEN 20202 SIMP_TAC real_ss [GSYM REAL_LT_RDIV_EQ] THEN 20203 W(MP_TAC o PART_MATCH (lhs o rand) 20204 INCREASING_VECTOR_VARIATION o lhand o snd) THENL 20205 [KNOW_TAC ``interval [(c,d)] <> {} /\ 20206 (!x y. x IN interval [(c,d)] /\ y IN interval [(c,d)] /\ x <= y ==> 20207 g' x <= (g':real->real) y)`` THENL 20208 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20209 ASM_REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY, IN_INTERVAL, REAL_NOT_LT] THEN 20210 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 20211 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 20212 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20213 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20214 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20215 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20216 REAL_ARITH_TAC, 20217 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 20218 DISCH_THEN SUBST1_TAC], 20219 KNOW_TAC ``interval [(c,d)] <> {} /\ 20220 (!x y. x IN interval [(c,d)] /\ y IN interval [(c,d)] /\ x <= y ==> 20221 h' x <= (h':real->real) y)`` THENL 20222 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20223 ASM_REWRITE_TAC[GSYM INTERVAL_EQ_EMPTY, IN_INTERVAL, REAL_NOT_LT] THEN 20224 REPEAT STRIP_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC THEN 20225 UNDISCH_TAC `` a <= c /\ c <= b:real`` THEN 20226 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20227 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20228 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20229 POP_ASSUM MP_TAC THEN POP_ASSUM MP_TAC THEN 20230 REAL_ARITH_TAC, 20231 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC THEN 20232 DISCH_THEN SUBST1_TAC]] THEN 20233 MATCH_MP_TAC(REAL_ARITH ``abs(x - y) < e ==> y - x < e:real``) THEN 20234 ONCE_REWRITE_TAC [ABS_SUB] THEN 20235 FIRST_X_ASSUM MATCH_MP_TAC THEN ASM_REWRITE_TAC[]); 20236 20237val VECTOR_VARIATION_CONTINUOUS_RIGHT = store_thm ("VECTOR_VARIATION_CONTINUOUS_RIGHT", 20238 ``!f:real->real a b c. 20239 f has_bounded_variation_on interval[a,b] /\ c IN interval[a,b] 20240 ==> ((\x. (vector_variation(interval[a,x]) f)) 20241 continuous (at c within interval[c,b]) <=> 20242 f continuous (at c within interval[c,b]))``, 20243 REPEAT STRIP_TAC THEN EQ_TAC THENL 20244 [REWRITE_TAC[continuous_within] THEN 20245 SIMP_TAC std_ss [GSPECIFICATION, dist] THEN 20246 DISCH_TAC THEN X_GEN_TAC ``e:real`` THEN DISCH_TAC THEN 20247 FIRST_X_ASSUM(MP_TAC o SPEC ``e:real``) THEN ASM_REWRITE_TAC[] THEN 20248 STRIP_TAC THEN EXISTS_TAC ``d:real`` THEN 20249 ASM_REWRITE_TAC[] THEN X_GEN_TAC ``x:real`` THEN STRIP_TAC THEN 20250 FIRST_X_ASSUM(MP_TAC o SPEC ``x:real``) THEN ASM_REWRITE_TAC[] THEN 20251 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] REAL_LET_TRANS) THEN 20252 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``x:real``, ``c:real``] 20253 VECTOR_VARIATION_COMBINE) THEN 20254 KNOW_TAC ``a <= c /\ c <= x /\ 20255 (f:real->real) has_bounded_variation_on interval [(a,x)]`` THENL 20256 [RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20257 REPEAT(CONJ_TAC THENL [ASM_REAL_ARITH_TAC, ALL_TAC]) THEN 20258 FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 20259 HAS_BOUNDED_VARIATION_ON_SUBSET)) THEN 20260 REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_REAL_ARITH_TAC, 20261 DISCH_TAC THEN ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 20262 DISCH_THEN(SUBST1_TAC o SYM) THEN 20263 REWRITE_TAC[REAL_ARITH ``abs((a + b) - a) = abs b:real``] THEN 20264 REWRITE_TAC[dist] THEN 20265 MATCH_MP_TAC(REAL_ARITH ``x <= a ==> x <= abs a:real``) THEN 20266 ONCE_REWRITE_TAC[ABS_SUB] THEN 20267 MATCH_MP_TAC VECTOR_VARIATION_GE_ABS_FUNCTION THEN CONJ_TAC THENL 20268 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 20269 HAS_BOUNDED_VARIATION_ON_SUBSET)), 20270 REWRITE_TAC[SEGMENT] THEN COND_CASES_TAC] THEN 20271 REWRITE_TAC[SUBSET_INTERVAL] THEN 20272 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_SIMP_TAC real_ss [], 20273 ALL_TAC] THEN 20274 DISCH_TAC THEN ASM_CASES_TAC ``c limit_point_of interval[c:real,b]`` THENL 20275 [ALL_TAC, 20276 ASM_REWRITE_TAC[CONTINUOUS_WITHIN, LIM, TRIVIAL_LIMIT_WITHIN]] THEN 20277 MATCH_MP_TAC(CONTINUOUS_WITHIN_COMPARISON) THEN 20278 EXISTS_TAC ``\x. sum ((1:num)..(1:num)) 20279 (\i. (vector_variation (interval[a,x]) 20280 (\u. (((f:real->real) u)))))`` THEN 20281 SIMP_TAC std_ss [] THEN CONJ_TAC THENL 20282 [ONCE_REWRITE_TAC [METIS [] 20283 ``(\i. vector_variation (interval [(a,x)]) (\u. f u)) = 20284 (\i. (\i x. vector_variation (interval [(a,x)]) (\u. f u)) i x)``] THEN 20285 MATCH_MP_TAC CONTINUOUS_SUM THEN REWRITE_TAC[FINITE_NUMSEG] THEN 20286 REWRITE_TAC[IN_NUMSEG] THEN REPEAT STRIP_TAC THEN 20287 W(MP_TAC o PART_MATCH (lhs o rand) lemma o snd) THEN 20288 METIS_TAC [], 20289 ALL_TAC] THEN 20290 X_GEN_TAC ``x:real`` THEN REWRITE_TAC[IN_INTERVAL] THEN DISCH_TAC THEN 20291 SIMP_TAC std_ss [dist, GSYM SUM_SUB_NUMSEG] THEN 20292 SUBGOAL_THEN 20293 ``(vector_variation(interval [a,x]) (f:real->real) = 20294 vector_variation(interval [a,c]) (f:real->real) + 20295 vector_variation(interval [c,x]) (f:real->real)) /\ 20296 (vector_variation(interval [a,x]) 20297 (\x. ((f:real->real) x)) = 20298 vector_variation(interval [a,c]) (\x. (f x)) + 20299 vector_variation(interval [c,x]) (\x. (f x)))`` 20300 (fn th => ASM_SIMP_TAC std_ss [th]) 20301 THENL 20302 [REPEAT STRIP_TAC THEN CONV_TAC SYM_CONV THEN 20303 MATCH_MP_TAC VECTOR_VARIATION_COMBINE THEN 20304 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20305 ASM_SIMP_TAC std_ss [] THEN 20306 MATCH_MP_TAC HAS_BOUNDED_VARIATION_ON_SUBSET THEN 20307 EXISTS_TAC ``interval[a:real,b]`` THEN 20308 ASM_REWRITE_TAC[SUBSET_INTERVAL] THEN 20309 RULE_ASSUM_TAC(ONCE_REWRITE_RULE 20310 [HAS_BOUNDED_VARIATION_ON_COMPONENTWISE]) THEN 20311 ASM_SIMP_TAC std_ss [REAL_LE_REFL], 20312 REWRITE_TAC[REAL_ARITH ``a - (a + b):real = -b``]] THEN 20313 SIMP_TAC std_ss [NUMSEG_SING, SUM_SING, ETA_AX, REAL_LE_REFL]); 20314 20315val lemma = prove ( 20316 ``!f:real->real a b c. 20317 c IN interval[a,b] 20318 ==> (f continuous (at c within interval[a,b]) <=> 20319 f continuous (at c within interval[a,c]) /\ 20320 f continuous (at c within interval[c,b]))``, 20321 REPEAT STRIP_TAC THEN REWRITE_TAC[CONTINUOUS_WITHIN] THEN EQ_TAC THENL 20322 [DISCH_THEN(ASSUME_TAC o GEN_ALL o 20323 MATCH_MP (REWRITE_RULE[IMP_CONJ] LIM_WITHIN_SUBSET)) THEN 20324 CONJ_TAC THEN FIRST_X_ASSUM MATCH_MP_TAC, 20325 DISCH_THEN(MP_TAC o MATCH_MP LIM_UNION) THEN 20326 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] LIM_WITHIN_SUBSET)] THEN 20327 REWRITE_TAC[SUBSET_DEF, IN_UNION, IN_INTERVAL] THEN 20328 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN ASM_REAL_ARITH_TAC); 20329 20330val VECTOR_VARIATION_CONTINUOUS = store_thm ("VECTOR_VARIATION_CONTINUOUS", 20331 ``!f:real->real a b c. 20332 f has_bounded_variation_on interval[a,b] /\ c IN interval[a,b] 20333 ==> ((\x. (vector_variation(interval[a,x]) f)) 20334 continuous (at c within interval[a,b]) <=> 20335 f continuous (at c within interval[a,b]))``, 20336 REPEAT STRIP_TAC THEN 20337 FIRST_ASSUM(fn th => ONCE_REWRITE_TAC[MATCH_MP lemma th]) THEN 20338 METIS_TAC[VECTOR_VARIATION_CONTINUOUS_LEFT, 20339 VECTOR_VARIATION_CONTINUOUS_RIGHT]); 20340 20341val CONTINUOUS_ON_VECTOR_VARIATION = store_thm ("CONTINUOUS_ON_VECTOR_VARIATION", 20342 ``!f:real->real a b. 20343 f has_bounded_variation_on interval[a,b] /\ 20344 f continuous_on interval[a,b] 20345 ==> (\x. (vector_variation (interval [a,x]) f)) continuous_on 20346 interval[a,b]``, 20347 SIMP_TAC std_ss [CONTINUOUS_ON_EQ_CONTINUOUS_WITHIN, VECTOR_VARIATION_CONTINUOUS]); 20348 20349val HAS_BOUNDED_VARIATION_DARBOUX_STRONG = store_thm ("HAS_BOUNDED_VARIATION_DARBOUX_STRONG", 20350 ``!f a b. 20351 f has_bounded_variation_on interval[a,b] 20352 ==> ?g h. (!x. f x = g x - h x) /\ 20353 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ 20354 x <= y 20355 ==> (g x) <= (g y)) /\ 20356 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ 20357 x <= y 20358 ==> (h x) <= (h y)) /\ 20359 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ 20360 x < y 20361 ==> (g x) < (g y)) /\ 20362 (!x y. x IN interval[a,b] /\ y IN interval[a,b] /\ 20363 x < y 20364 ==> (h x) < (h y)) /\ 20365 (!x. x IN interval[a,b] /\ 20366 f continuous (at x within interval[a,x]) 20367 ==> g continuous (at x within interval[a,x]) /\ 20368 h continuous (at x within interval[a,x])) /\ 20369 (!x. x IN interval[a,b] /\ 20370 f continuous (at x within interval[x,b]) 20371 ==> g continuous (at x within interval[x,b]) /\ 20372 h continuous (at x within interval[x,b])) /\ 20373 (!x. x IN interval[a,b] /\ 20374 f continuous (at x within interval[a,b]) 20375 ==> g continuous (at x within interval[a,b]) /\ 20376 h continuous (at x within interval[a,b]))``, 20377 REPEAT STRIP_TAC THEN 20378 MAP_EVERY EXISTS_TAC 20379 [``\x:real. x + (vector_variation (interval[a,x]) (f:real->real))``, 20380 ``\x:real. x + (vector_variation (interval[a,x]) f) - f x``] THEN 20381 SIMP_TAC real_ss [REAL_ARITH ``(x + l) - (x + l - f):real = f``] THEN 20382 SIMP_TAC std_ss [] THEN REPEAT STRIP_TAC THENL 20383 [MATCH_MP_TAC REAL_LE_ADD2 THEN ASM_REWRITE_TAC[] THEN 20384 MATCH_MP_TAC VECTOR_VARIATION_MONOTONE, 20385 REWRITE_TAC [real_sub, GSYM REAL_ADD_ASSOC] THEN 20386 MATCH_MP_TAC REAL_LE_ADD2 THEN ASM_REWRITE_TAC[GSYM real_sub] THEN 20387 MATCH_MP_TAC(REAL_ARITH 20388 ``!x. a - (b - x) <= c - (d - x) ==> a - b <= c - d:real``) THEN 20389 EXISTS_TAC ``(f(a:real)):real`` THEN 20390 SIMP_TAC std_ss [] THEN 20391 MATCH_MP_TAC VECTOR_VARIATION_MINUS_FUNCTION_MONOTONE, 20392 MATCH_MP_TAC REAL_LTE_ADD2 THEN ASM_REWRITE_TAC[] THEN 20393 MATCH_MP_TAC VECTOR_VARIATION_MONOTONE, 20394 REWRITE_TAC [real_sub, GSYM REAL_ADD_ASSOC] THEN 20395 MATCH_MP_TAC REAL_LTE_ADD2 THEN ASM_REWRITE_TAC[GSYM real_sub] THEN 20396 MATCH_MP_TAC(REAL_ARITH 20397 ``!x. a - (b - x) <= c - (d - x) ==> a - b <= c - d:real``) THEN 20398 EXISTS_TAC ``(f(a:real)):real`` THEN 20399 SIMP_TAC std_ss [] THEN 20400 MATCH_MP_TAC VECTOR_VARIATION_MINUS_FUNCTION_MONOTONE, 20401 ONCE_REWRITE_TAC [METIS [] 20402 ``(\x. x + vector_variation (interval [(a,x)]) f) = 20403 (\x. (\x. x) x + (\x. vector_variation (interval [(a,x)]) f) x)``] THEN 20404 MATCH_MP_TAC CONTINUOUS_ADD THEN 20405 REWRITE_TAC[CONTINUOUS_WITHIN_ID] THEN 20406 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, ``x:real``] 20407 VECTOR_VARIATION_CONTINUOUS_LEFT) THEN 20408 ASM_REWRITE_TAC[], 20409 ONCE_REWRITE_TAC [METIS [real_sub, REAL_ADD_ASSOC] 20410 ``(\x. x + vector_variation (interval [(a,x)]) f - f x) = 20411 (\x. (\x. x) x + (\x. vector_variation (interval [(a,x)]) f - f x) x)``] THEN 20412 MATCH_MP_TAC CONTINUOUS_ADD THEN 20413 REWRITE_TAC[CONTINUOUS_WITHIN_ID] THEN 20414 ONCE_REWRITE_TAC [METIS [] 20415 ``(\x. vector_variation (interval [(a,x)]) f - f x) = 20416 (\x. (\x. vector_variation (interval [(a,x)]) f) x - f x)``] THEN 20417 MATCH_MP_TAC CONTINUOUS_SUB THEN ASM_REWRITE_TAC[] THEN 20418 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, ``x:real``] 20419 VECTOR_VARIATION_CONTINUOUS_LEFT) THEN 20420 ASM_REWRITE_TAC[], 20421 ONCE_REWRITE_TAC [METIS [] 20422 ``(\x. x + vector_variation (interval [(a,x)]) f) = 20423 (\x. (\x. x) x + (\x. vector_variation (interval [(a,x)]) f) x)``] THEN 20424 MATCH_MP_TAC CONTINUOUS_ADD THEN 20425 REWRITE_TAC[CONTINUOUS_WITHIN_ID] THEN 20426 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, ``x:real``] 20427 VECTOR_VARIATION_CONTINUOUS_RIGHT) THEN 20428 ASM_REWRITE_TAC[], 20429 ONCE_REWRITE_TAC [METIS [real_sub, REAL_ADD_ASSOC] 20430 ``(\x. x + vector_variation (interval [(a,x)]) f - f x) = 20431 (\x. (\x. x) x + (\x. vector_variation (interval [(a,x)]) f - f x) x)``] THEN 20432 MATCH_MP_TAC CONTINUOUS_ADD THEN 20433 REWRITE_TAC[CONTINUOUS_WITHIN_ID] THEN 20434 ONCE_REWRITE_TAC [METIS [] 20435 ``(\x. vector_variation (interval [(a,x)]) f - f x) = 20436 (\x. (\x. vector_variation (interval [(a,x)]) f) x - f x)``] THEN 20437 MATCH_MP_TAC CONTINUOUS_SUB THEN ASM_REWRITE_TAC[] THEN 20438 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, ``x:real``] 20439 VECTOR_VARIATION_CONTINUOUS_RIGHT) THEN 20440 ASM_REWRITE_TAC[], 20441 ONCE_REWRITE_TAC [METIS [] 20442 ``(\x. x + vector_variation (interval [(a,x)]) f) = 20443 (\x. (\x. x) x + (\x. vector_variation (interval [(a,x)]) f) x)``] THEN 20444 MATCH_MP_TAC CONTINUOUS_ADD THEN 20445 REWRITE_TAC[CONTINUOUS_WITHIN_ID] THEN 20446 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, ``x:real``] 20447 VECTOR_VARIATION_CONTINUOUS) THEN 20448 ASM_REWRITE_TAC[], 20449 ONCE_REWRITE_TAC [METIS [real_sub, REAL_ADD_ASSOC] 20450 ``(\x. x + vector_variation (interval [(a,x)]) f - f x) = 20451 (\x. (\x. x) x + (\x. vector_variation (interval [(a,x)]) f - f x) x)``] THEN 20452 MATCH_MP_TAC CONTINUOUS_ADD THEN 20453 REWRITE_TAC[CONTINUOUS_WITHIN_ID] THEN 20454 ONCE_REWRITE_TAC [METIS [] 20455 ``(\x. vector_variation (interval [(a,x)]) f - f x) = 20456 (\x. (\x. vector_variation (interval [(a,x)]) f) x - f x)``] THEN 20457 MATCH_MP_TAC CONTINUOUS_SUB THEN ASM_REWRITE_TAC[] THEN 20458 MP_TAC(ISPECL [``f:real->real``, ``a:real``, ``b:real``, ``x:real``] 20459 VECTOR_VARIATION_CONTINUOUS) THEN 20460 ASM_REWRITE_TAC[]] THEN 20461 (CONJ_TAC THENL 20462 [FIRST_X_ASSUM(MATCH_MP_TAC o MATCH_MP (REWRITE_RULE[IMP_CONJ] 20463 HAS_BOUNDED_VARIATION_ON_SUBSET)), 20464 ALL_TAC] THEN 20465 RULE_ASSUM_TAC(REWRITE_RULE[IN_INTERVAL]) THEN 20466 REWRITE_TAC[SUBSET_INTERVAL, GSYM INTERVAL_EQ_EMPTY] THEN 20467 ASM_REAL_ARITH_TAC)); 20468 20469val INTEGRABLE_BOUNDED_VARIATION_PRODUCT = store_thm ("INTEGRABLE_BOUNDED_VARIATION_PRODUCT", 20470 ``!f:real->real g a b. 20471 f integrable_on interval[a,b] /\ 20472 g has_bounded_variation_on interval[a,b] 20473 ==> (\x. (g x) * f x) integrable_on interval[a,b]``, 20474 REPEAT STRIP_TAC THEN FIRST_X_ASSUM 20475 (MP_TAC o REWRITE_RULE [HAS_BOUNDED_VARIATION_DARBOUX]) THEN 20476 SIMP_TAC std_ss [LEFT_IMP_EXISTS_THM] THEN 20477 MAP_EVERY X_GEN_TAC [``h:real->real``, ``k:real->real``] THEN 20478 STRIP_TAC THEN ASM_REWRITE_TAC[REAL_SUB_RDISTRIB] THEN 20479 ONCE_REWRITE_TAC [METIS [] ``(\x. h x * f x - k x * (f:real->real) x) = 20480 (\x. (\x. h x * f x) x - (\x. k x * f x) x)``] THEN 20481 MATCH_MP_TAC INTEGRABLE_SUB THEN 20482 CONJ_TAC THEN MATCH_MP_TAC INTEGRABLE_INCREASING_PRODUCT THEN 20483 ASM_REWRITE_TAC[]); 20484 20485val INTEGRABLE_BOUNDED_VARIATION_PRODUCT_ALT = store_thm ("INTEGRABLE_BOUNDED_VARIATION_PRODUCT_ALT", 20486 ``!f:real->real g a b. 20487 f integrable_on interval[a,b] /\ 20488 g has_bounded_variation_on interval[a,b] 20489 ==> (\x. g x * f x) integrable_on interval[a,b]``, 20490 REPEAT GEN_TAC THEN 20491 DISCH_THEN(MP_TAC o MATCH_MP INTEGRABLE_BOUNDED_VARIATION_PRODUCT) THEN 20492 SIMP_TAC std_ss [o_DEF]); 20493 20494val INTEGRABLE_BOUNDED_VARIATION_BILINEAR_LMUL = store_thm ("INTEGRABLE_BOUNDED_VARIATION_BILINEAR_LMUL", 20495 ``!op:real->real->real f g a b. 20496 bilinear op /\ 20497 f integrable_on interval[a,b] /\ 20498 g has_bounded_variation_on interval[a,b] 20499 ==> (\x. op (g x) (f x)) integrable_on interval[a,b]``, 20500 REPEAT STRIP_TAC THEN 20501 KNOW_TAC ``!x. (g:real->real) x = sum ((1:num)..(1:num)) (\i. g x * &i)`` THENL 20502 [SIMP_TAC std_ss [SUM_SING, NUMSEG_SING, REAL_MUL_RID], 20503 DISCH_TAC THEN ONCE_ASM_REWRITE_TAC [] THEN POP_ASSUM K_TAC] THEN 20504 FIRST_ASSUM(ASSUME_TAC o CONJUNCT2 o REWRITE_RULE [bilinear]) THEN 20505 KNOW_TAC ``!n y g. FINITE ((1:num).. n) ==> 20506 ((\(x:real). (op:real->real->real) x y) (sum ((1:num)..n) g) = 20507 sum ((1:num)..n) ((\x. op x y) o g))`` THENL 20508 [REPEAT STRIP_TAC THEN MATCH_MP_TAC LINEAR_SUM THEN ASM_SIMP_TAC std_ss [], 20509 ALL_TAC] THEN 20510 SIMP_TAC std_ss [FINITE_NUMSEG, o_DEF] THEN DISCH_THEN(K ALL_TAC) THEN 20511 ONCE_REWRITE_TAC [METIS [] 20512 ``(\x. sum (1 .. 1) (\i. op ((g:real->real) x * &i) (f x))) = 20513 (\x. sum (1 .. 1) (\i. (\i x. op (g x * &i) (f x)) i x))``] THEN 20514 MATCH_MP_TAC INTEGRABLE_SUM THEN SIMP_TAC std_ss [FINITE_NUMSEG, IN_NUMSEG] THEN 20515 X_GEN_TAC ``k:num`` THEN DISCH_TAC THEN 20516 FIRST_ASSUM(MP_TAC o GEN_ALL o MATCH_MP LINEAR_CMUL o SPEC_ALL) THEN 20517 SIMP_TAC std_ss [] THEN DISCH_THEN(K ALL_TAC) THEN 20518 ONCE_REWRITE_TAC [METIS [] ``(\x. (g:real->real) x * op (&k) (f x)) = 20519 (\x. g x * (\x. (op:real->real->real) (&k) (f x)) x)``] THEN 20520 MATCH_MP_TAC INTEGRABLE_BOUNDED_VARIATION_PRODUCT_ALT THEN 20521 ASM_SIMP_TAC std_ss [o_DEF, IN_NUMSEG] THEN ONCE_REWRITE_TAC[GSYM o_DEF] THEN 20522 MATCH_MP_TAC INTEGRABLE_LINEAR THEN ASM_REWRITE_TAC[] THEN 20523 UNDISCH_TAC ``bilinear op`` THEN DISCH_TAC THEN 20524 FIRST_ASSUM(MP_TAC o CONJUNCT1 o SIMP_RULE std_ss [bilinear]) THEN 20525 METIS_TAC [ETA_AX]); 20526 20527val INTEGRABLE_BOUNDED_VARIATION_BILINEAR_RMUL = store_thm ("INTEGRABLE_BOUNDED_VARIATION_BILINEAR_RMUL", 20528 ``!op:real->real->real f g a b. 20529 bilinear op /\ 20530 f integrable_on interval[a,b] /\ 20531 g has_bounded_variation_on interval[a,b] 20532 ==> (\x. op (f x) (g x)) integrable_on interval[a,b]``, 20533 REPEAT STRIP_TAC THEN MP_TAC(ISPECL 20534 [``\x y. (op:real->real->real) y x``, 20535 ``f:real->real``, ``g:real->real``, 20536 ``a:real``, ``b:real``] INTEGRABLE_BOUNDED_VARIATION_BILINEAR_LMUL) THEN 20537 ASM_SIMP_TAC std_ss [BILINEAR_SWAP]); 20538 20539val INTEGRABLE_BOUNDED_VARIATION = store_thm ("INTEGRABLE_BOUNDED_VARIATION", 20540 ``!f:real->real a b. 20541 f has_bounded_variation_on interval[a,b] 20542 ==> f integrable_on interval[a,b]``, 20543 REPEAT STRIP_TAC THEN 20544 MP_TAC(ISPECL 20545 [``\x:real y:real. x * y``, 20546 ``(\x. 1):real->real``, 20547 ``f:real->real``, ``a:real``, ``b:real``] 20548 INTEGRABLE_BOUNDED_VARIATION_BILINEAR_RMUL) THEN 20549 ASM_SIMP_TAC std_ss [INTEGRABLE_CONST, BILINEAR_DOT] THEN 20550 SIMP_TAC std_ss [REAL_MUL_LID, ETA_AX]); 20551 20552val HAS_BOUNDED_VARIATION_ON_INDEFINITE_INTEGRAL_RIGHT = store_thm ("HAS_BOUNDED_VARIATION_ON_INDEFINITE_INTEGRAL_RIGHT", 20553 ``!f:real->real a b. 20554 f absolutely_integrable_on interval[a,b] 20555 ==> (\c. integral (interval[a,c]) f) has_bounded_variation_on 20556 interval[a,b]``, 20557 REPEAT STRIP_TAC THEN REWRITE_TAC[has_bounded_variation_on] THEN 20558 FIRST_ASSUM(MP_TAC o 20559 MATCH_MP ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION) THEN 20560 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] HAS_BOUNDED_SETVARIATION_ON_EQ) THEN 20561 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, INTERVAL_UPPERBOUND_NONEMPTY] THEN 20562 SIMP_TAC std_ss [INTERVAL_NE_EMPTY, SUBSET_INTERVAL, GSYM REAL_NOT_LE] THEN 20563 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_ARITH 20564 ``(a:real = b - c) <=> (c + a = b)``] THEN 20565 MATCH_MP_TAC INTEGRAL_COMBINE THEN ASM_REWRITE_TAC[] THEN 20566 FIRST_ASSUM(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE) THEN 20567 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] INTEGRABLE_ON_SUBINTERVAL) THEN 20568 ASM_REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_REAL_ARITH_TAC); 20569 20570val HAS_BOUNDED_VARIATION_ON_INDEFINITE_INTEGRAL_LEFT = store_thm ("HAS_BOUNDED_VARIATION_ON_INDEFINITE_INTEGRAL_LEFT", 20571 ``!f:real->real a b. 20572 f absolutely_integrable_on interval[a,b] 20573 ==> (\c. integral (interval[c,b]) f) has_bounded_variation_on 20574 interval[a,b]``, 20575 REPEAT STRIP_TAC THEN 20576 REWRITE_TAC[has_bounded_variation_on] THEN 20577 ONCE_REWRITE_TAC[GSYM HAS_BOUNDED_SETVARIATION_ON_NEG] THEN 20578 FIRST_ASSUM(MP_TAC o 20579 MATCH_MP ABSOLUTELY_INTEGRABLE_BOUNDED_SETVARIATION) THEN 20580 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ] HAS_BOUNDED_SETVARIATION_ON_EQ) THEN 20581 SIMP_TAC std_ss [INTERVAL_LOWERBOUND_NONEMPTY, INTERVAL_UPPERBOUND_NONEMPTY] THEN 20582 SIMP_TAC std_ss [INTERVAL_NE_EMPTY, SUBSET_INTERVAL, GSYM REAL_NOT_LE] THEN 20583 REPEAT STRIP_TAC THEN REWRITE_TAC[REAL_ARITH 20584 ``(a:real = -(b - c)) <=> (a + b = c)``] THEN 20585 MATCH_MP_TAC INTEGRAL_COMBINE THEN ASM_REWRITE_TAC[] THEN 20586 FIRST_ASSUM(MP_TAC o MATCH_MP ABSOLUTELY_INTEGRABLE_IMP_INTEGRABLE) THEN 20587 MATCH_MP_TAC(REWRITE_RULE[IMP_CONJ_ALT] INTEGRABLE_ON_SUBINTERVAL) THEN 20588 ASM_REWRITE_TAC[SUBSET_INTERVAL] THEN ASM_REAL_ARITH_TAC); 20589 20590(* TODO: hol-light's "Multivariate/integration.ml", starting from line 21056: 20591 20592 CONTINUOUS_BV_IMP_UNIFORMLY_CONTINUOUS 20593 HAS_BOUNDED_VARIATION_ON_DARBOUX_IMP_CONTINUOUS 20594 VECTOR_VARIATION_ON_INTERIOR 20595 VECTOR_VARIATION_ON_CLOSURE 20596 HAS_BOUNDED_VARIATION_IMP_BAIRE1 20597 INCREASING_IMP_BAIRE1 20598 DECREASING_IMP_BAIRE1 20599 FACTOR_THROUGH_VARIATION 20600 FACTOR_CONTINUOUS_THROUGH_VARIATION 20601 ... 20602 *) 20603 20604val _ = export_theory(); 20605