1 (* Title: HOL/Library/Topology_Euclidian_Space.thy |
|
2 Author: Amine Chaieb, University of Cambridge |
|
3 Author: Robert Himmelmann, TU Muenchen |
|
4 *) |
|
5 |
|
6 header {* Elementary topology in Euclidean space. *} |
|
7 |
|
8 theory Topology_Euclidean_Space |
|
9 imports SEQ Euclidean_Space Product_Vector |
|
10 begin |
|
11 |
|
12 declare fstcart_pastecart[simp] sndcart_pastecart[simp] |
|
13 |
|
14 subsection{* General notion of a topology *} |
|
15 |
|
16 definition "istopology L \<longleftrightarrow> {} \<in> L \<and> (\<forall>S \<in>L. \<forall>T \<in>L. S \<inter> T \<in> L) \<and> (\<forall>K. K \<subseteq>L \<longrightarrow> \<Union> K \<in> L)" |
|
17 typedef (open) 'a topology = "{L::('a set) set. istopology L}" |
|
18 morphisms "openin" "topology" |
|
19 unfolding istopology_def by blast |
|
20 |
|
21 lemma istopology_open_in[intro]: "istopology(openin U)" |
|
22 using openin[of U] by blast |
|
23 |
|
24 lemma topology_inverse': "istopology U \<Longrightarrow> openin (topology U) = U" |
|
25 using topology_inverse[unfolded mem_def Collect_def] . |
|
26 |
|
27 lemma topology_inverse_iff: "istopology U \<longleftrightarrow> openin (topology U) = U" |
|
28 using topology_inverse[of U] istopology_open_in[of "topology U"] by auto |
|
29 |
|
30 lemma topology_eq: "T1 = T2 \<longleftrightarrow> (\<forall>S. openin T1 S \<longleftrightarrow> openin T2 S)" |
|
31 proof- |
|
32 {assume "T1=T2" hence "\<forall>S. openin T1 S \<longleftrightarrow> openin T2 S" by simp} |
|
33 moreover |
|
34 {assume H: "\<forall>S. openin T1 S \<longleftrightarrow> openin T2 S" |
|
35 hence "openin T1 = openin T2" by (metis mem_def set_ext) |
|
36 hence "topology (openin T1) = topology (openin T2)" by simp |
|
37 hence "T1 = T2" unfolding openin_inverse .} |
|
38 ultimately show ?thesis by blast |
|
39 qed |
|
40 |
|
41 text{* Infer the "universe" from union of all sets in the topology. *} |
|
42 |
|
43 definition "topspace T = \<Union>{S. openin T S}" |
|
44 |
|
45 subsection{* Main properties of open sets *} |
|
46 |
|
47 lemma openin_clauses: |
|
48 fixes U :: "'a topology" |
|
49 shows "openin U {}" |
|
50 "\<And>S T. openin U S \<Longrightarrow> openin U T \<Longrightarrow> openin U (S\<inter>T)" |
|
51 "\<And>K. (\<forall>S \<in> K. openin U S) \<Longrightarrow> openin U (\<Union>K)" |
|
52 using openin[of U] unfolding istopology_def Collect_def mem_def |
|
53 by (metis mem_def subset_eq)+ |
|
54 |
|
55 lemma openin_subset[intro]: "openin U S \<Longrightarrow> S \<subseteq> topspace U" |
|
56 unfolding topspace_def by blast |
|
57 lemma openin_empty[simp]: "openin U {}" by (simp add: openin_clauses) |
|
58 |
|
59 lemma openin_Int[intro]: "openin U S \<Longrightarrow> openin U T \<Longrightarrow> openin U (S \<inter> T)" |
|
60 by (simp add: openin_clauses) |
|
61 |
|
62 lemma openin_Union[intro]: "(\<forall>S \<in>K. openin U S) \<Longrightarrow> openin U (\<Union> K)" by (simp add: openin_clauses) |
|
63 |
|
64 lemma openin_Un[intro]: "openin U S \<Longrightarrow> openin U T \<Longrightarrow> openin U (S \<union> T)" |
|
65 using openin_Union[of "{S,T}" U] by auto |
|
66 |
|
67 lemma openin_topspace[intro, simp]: "openin U (topspace U)" by (simp add: openin_Union topspace_def) |
|
68 |
|
69 lemma openin_subopen: "openin U S \<longleftrightarrow> (\<forall>x \<in> S. \<exists>T. openin U T \<and> x \<in> T \<and> T \<subseteq> S)" (is "?lhs \<longleftrightarrow> ?rhs") |
|
70 proof- |
|
71 {assume ?lhs then have ?rhs by auto } |
|
72 moreover |
|
73 {assume H: ?rhs |
|
74 then obtain t where t: "\<forall>x\<in>S. openin U (t x) \<and> x \<in> t x \<and> t x \<subseteq> S" |
|
75 unfolding Ball_def ex_simps(6)[symmetric] choice_iff by blast |
|
76 from t have th0: "\<forall>x\<in> t`S. openin U x" by auto |
|
77 have "\<Union> t`S = S" using t by auto |
|
78 with openin_Union[OF th0] have "openin U S" by simp } |
|
79 ultimately show ?thesis by blast |
|
80 qed |
|
81 |
|
82 subsection{* Closed sets *} |
|
83 |
|
84 definition "closedin U S \<longleftrightarrow> S \<subseteq> topspace U \<and> openin U (topspace U - S)" |
|
85 |
|
86 lemma closedin_subset: "closedin U S \<Longrightarrow> S \<subseteq> topspace U" by (metis closedin_def) |
|
87 lemma closedin_empty[simp]: "closedin U {}" by (simp add: closedin_def) |
|
88 lemma closedin_topspace[intro,simp]: |
|
89 "closedin U (topspace U)" by (simp add: closedin_def) |
|
90 lemma closedin_Un[intro]: "closedin U S \<Longrightarrow> closedin U T \<Longrightarrow> closedin U (S \<union> T)" |
|
91 by (auto simp add: Diff_Un closedin_def) |
|
92 |
|
93 lemma Diff_Inter[intro]: "A - \<Inter>S = \<Union> {A - s|s. s\<in>S}" by auto |
|
94 lemma closedin_Inter[intro]: assumes Ke: "K \<noteq> {}" and Kc: "\<forall>S \<in>K. closedin U S" |
|
95 shows "closedin U (\<Inter> K)" using Ke Kc unfolding closedin_def Diff_Inter by auto |
|
96 |
|
97 lemma closedin_Int[intro]: "closedin U S \<Longrightarrow> closedin U T \<Longrightarrow> closedin U (S \<inter> T)" |
|
98 using closedin_Inter[of "{S,T}" U] by auto |
|
99 |
|
100 lemma Diff_Diff_Int: "A - (A - B) = A \<inter> B" by blast |
|
101 lemma openin_closedin_eq: "openin U S \<longleftrightarrow> S \<subseteq> topspace U \<and> closedin U (topspace U - S)" |
|
102 apply (auto simp add: closedin_def Diff_Diff_Int inf_absorb2) |
|
103 apply (metis openin_subset subset_eq) |
|
104 done |
|
105 |
|
106 lemma openin_closedin: "S \<subseteq> topspace U \<Longrightarrow> (openin U S \<longleftrightarrow> closedin U (topspace U - S))" |
|
107 by (simp add: openin_closedin_eq) |
|
108 |
|
109 lemma openin_diff[intro]: assumes oS: "openin U S" and cT: "closedin U T" shows "openin U (S - T)" |
|
110 proof- |
|
111 have "S - T = S \<inter> (topspace U - T)" using openin_subset[of U S] oS cT |
|
112 by (auto simp add: topspace_def openin_subset) |
|
113 then show ?thesis using oS cT by (auto simp add: closedin_def) |
|
114 qed |
|
115 |
|
116 lemma closedin_diff[intro]: assumes oS: "closedin U S" and cT: "openin U T" shows "closedin U (S - T)" |
|
117 proof- |
|
118 have "S - T = S \<inter> (topspace U - T)" using closedin_subset[of U S] oS cT |
|
119 by (auto simp add: topspace_def ) |
|
120 then show ?thesis using oS cT by (auto simp add: openin_closedin_eq) |
|
121 qed |
|
122 |
|
123 subsection{* Subspace topology. *} |
|
124 |
|
125 definition "subtopology U V = topology {S \<inter> V |S. openin U S}" |
|
126 |
|
127 lemma istopology_subtopology: "istopology {S \<inter> V |S. openin U S}" (is "istopology ?L") |
|
128 proof- |
|
129 have "{} \<in> ?L" by blast |
|
130 {fix A B assume A: "A \<in> ?L" and B: "B \<in> ?L" |
|
131 from A B obtain Sa and Sb where Sa: "openin U Sa" "A = Sa \<inter> V" and Sb: "openin U Sb" "B = Sb \<inter> V" by blast |
|
132 have "A\<inter>B = (Sa \<inter> Sb) \<inter> V" "openin U (Sa \<inter> Sb)" using Sa Sb by blast+ |
|
133 then have "A \<inter> B \<in> ?L" by blast} |
|
134 moreover |
|
135 {fix K assume K: "K \<subseteq> ?L" |
|
136 have th0: "?L = (\<lambda>S. S \<inter> V) ` openin U " |
|
137 apply (rule set_ext) |
|
138 apply (simp add: Ball_def image_iff) |
|
139 by (metis mem_def) |
|
140 from K[unfolded th0 subset_image_iff] |
|
141 obtain Sk where Sk: "Sk \<subseteq> openin U" "K = (\<lambda>S. S \<inter> V) ` Sk" by blast |
|
142 have "\<Union>K = (\<Union>Sk) \<inter> V" using Sk by auto |
|
143 moreover have "openin U (\<Union> Sk)" using Sk by (auto simp add: subset_eq mem_def) |
|
144 ultimately have "\<Union>K \<in> ?L" by blast} |
|
145 ultimately show ?thesis unfolding istopology_def by blast |
|
146 qed |
|
147 |
|
148 lemma openin_subtopology: |
|
149 "openin (subtopology U V) S \<longleftrightarrow> (\<exists> T. (openin U T) \<and> (S = T \<inter> V))" |
|
150 unfolding subtopology_def topology_inverse'[OF istopology_subtopology] |
|
151 by (auto simp add: Collect_def) |
|
152 |
|
153 lemma topspace_subtopology: "topspace(subtopology U V) = topspace U \<inter> V" |
|
154 by (auto simp add: topspace_def openin_subtopology) |
|
155 |
|
156 lemma closedin_subtopology: |
|
157 "closedin (subtopology U V) S \<longleftrightarrow> (\<exists>T. closedin U T \<and> S = T \<inter> V)" |
|
158 unfolding closedin_def topspace_subtopology |
|
159 apply (simp add: openin_subtopology) |
|
160 apply (rule iffI) |
|
161 apply clarify |
|
162 apply (rule_tac x="topspace U - T" in exI) |
|
163 by auto |
|
164 |
|
165 lemma openin_subtopology_refl: "openin (subtopology U V) V \<longleftrightarrow> V \<subseteq> topspace U" |
|
166 unfolding openin_subtopology |
|
167 apply (rule iffI, clarify) |
|
168 apply (frule openin_subset[of U]) apply blast |
|
169 apply (rule exI[where x="topspace U"]) |
|
170 by auto |
|
171 |
|
172 lemma subtopology_superset: assumes UV: "topspace U \<subseteq> V" |
|
173 shows "subtopology U V = U" |
|
174 proof- |
|
175 {fix S |
|
176 {fix T assume T: "openin U T" "S = T \<inter> V" |
|
177 from T openin_subset[OF T(1)] UV have eq: "S = T" by blast |
|
178 have "openin U S" unfolding eq using T by blast} |
|
179 moreover |
|
180 {assume S: "openin U S" |
|
181 hence "\<exists>T. openin U T \<and> S = T \<inter> V" |
|
182 using openin_subset[OF S] UV by auto} |
|
183 ultimately have "(\<exists>T. openin U T \<and> S = T \<inter> V) \<longleftrightarrow> openin U S" by blast} |
|
184 then show ?thesis unfolding topology_eq openin_subtopology by blast |
|
185 qed |
|
186 |
|
187 |
|
188 lemma subtopology_topspace[simp]: "subtopology U (topspace U) = U" |
|
189 by (simp add: subtopology_superset) |
|
190 |
|
191 lemma subtopology_UNIV[simp]: "subtopology U UNIV = U" |
|
192 by (simp add: subtopology_superset) |
|
193 |
|
194 subsection{* The universal Euclidean versions are what we use most of the time *} |
|
195 |
|
196 definition |
|
197 euclidean :: "'a::topological_space topology" where |
|
198 "euclidean = topology open" |
|
199 |
|
200 lemma open_openin: "open S \<longleftrightarrow> openin euclidean S" |
|
201 unfolding euclidean_def |
|
202 apply (rule cong[where x=S and y=S]) |
|
203 apply (rule topology_inverse[symmetric]) |
|
204 apply (auto simp add: istopology_def) |
|
205 by (auto simp add: mem_def subset_eq) |
|
206 |
|
207 lemma topspace_euclidean: "topspace euclidean = UNIV" |
|
208 apply (simp add: topspace_def) |
|
209 apply (rule set_ext) |
|
210 by (auto simp add: open_openin[symmetric]) |
|
211 |
|
212 lemma topspace_euclidean_subtopology[simp]: "topspace (subtopology euclidean S) = S" |
|
213 by (simp add: topspace_euclidean topspace_subtopology) |
|
214 |
|
215 lemma closed_closedin: "closed S \<longleftrightarrow> closedin euclidean S" |
|
216 by (simp add: closed_def closedin_def topspace_euclidean open_openin Compl_eq_Diff_UNIV) |
|
217 |
|
218 lemma open_subopen: "open S \<longleftrightarrow> (\<forall>x\<in>S. \<exists>T. open T \<and> x \<in> T \<and> T \<subseteq> S)" |
|
219 by (simp add: open_openin openin_subopen[symmetric]) |
|
220 |
|
221 subsection{* Open and closed balls. *} |
|
222 |
|
223 definition |
|
224 ball :: "'a::metric_space \<Rightarrow> real \<Rightarrow> 'a set" where |
|
225 "ball x e = {y. dist x y < e}" |
|
226 |
|
227 definition |
|
228 cball :: "'a::metric_space \<Rightarrow> real \<Rightarrow> 'a set" where |
|
229 "cball x e = {y. dist x y \<le> e}" |
|
230 |
|
231 lemma mem_ball[simp]: "y \<in> ball x e \<longleftrightarrow> dist x y < e" by (simp add: ball_def) |
|
232 lemma mem_cball[simp]: "y \<in> cball x e \<longleftrightarrow> dist x y \<le> e" by (simp add: cball_def) |
|
233 |
|
234 lemma mem_ball_0 [simp]: |
|
235 fixes x :: "'a::real_normed_vector" |
|
236 shows "x \<in> ball 0 e \<longleftrightarrow> norm x < e" |
|
237 by (simp add: dist_norm) |
|
238 |
|
239 lemma mem_cball_0 [simp]: |
|
240 fixes x :: "'a::real_normed_vector" |
|
241 shows "x \<in> cball 0 e \<longleftrightarrow> norm x \<le> e" |
|
242 by (simp add: dist_norm) |
|
243 |
|
244 lemma centre_in_cball[simp]: "x \<in> cball x e \<longleftrightarrow> 0\<le> e" by simp |
|
245 lemma ball_subset_cball[simp,intro]: "ball x e \<subseteq> cball x e" by (simp add: subset_eq) |
|
246 lemma subset_ball[intro]: "d <= e ==> ball x d \<subseteq> ball x e" by (simp add: subset_eq) |
|
247 lemma subset_cball[intro]: "d <= e ==> cball x d \<subseteq> cball x e" by (simp add: subset_eq) |
|
248 lemma ball_max_Un: "ball a (max r s) = ball a r \<union> ball a s" |
|
249 by (simp add: expand_set_eq) arith |
|
250 |
|
251 lemma ball_min_Int: "ball a (min r s) = ball a r \<inter> ball a s" |
|
252 by (simp add: expand_set_eq) |
|
253 |
|
254 subsection{* Topological properties of open balls *} |
|
255 |
|
256 lemma diff_less_iff: "(a::real) - b > 0 \<longleftrightarrow> a > b" |
|
257 "(a::real) - b < 0 \<longleftrightarrow> a < b" |
|
258 "a - b < c \<longleftrightarrow> a < c +b" "a - b > c \<longleftrightarrow> a > c +b" by arith+ |
|
259 lemma diff_le_iff: "(a::real) - b \<ge> 0 \<longleftrightarrow> a \<ge> b" "(a::real) - b \<le> 0 \<longleftrightarrow> a \<le> b" |
|
260 "a - b \<le> c \<longleftrightarrow> a \<le> c +b" "a - b \<ge> c \<longleftrightarrow> a \<ge> c +b" by arith+ |
|
261 |
|
262 lemma open_ball[intro, simp]: "open (ball x e)" |
|
263 unfolding open_dist ball_def Collect_def Ball_def mem_def |
|
264 unfolding dist_commute |
|
265 apply clarify |
|
266 apply (rule_tac x="e - dist xa x" in exI) |
|
267 using dist_triangle_alt[where z=x] |
|
268 apply (clarsimp simp add: diff_less_iff) |
|
269 apply atomize |
|
270 apply (erule_tac x="y" in allE) |
|
271 apply (erule_tac x="xa" in allE) |
|
272 by arith |
|
273 |
|
274 lemma centre_in_ball[simp]: "x \<in> ball x e \<longleftrightarrow> e > 0" by (metis mem_ball dist_self) |
|
275 lemma open_contains_ball: "open S \<longleftrightarrow> (\<forall>x\<in>S. \<exists>e>0. ball x e \<subseteq> S)" |
|
276 unfolding open_dist subset_eq mem_ball Ball_def dist_commute .. |
|
277 |
|
278 lemma open_contains_ball_eq: "open S \<Longrightarrow> \<forall>x. x\<in>S \<longleftrightarrow> (\<exists>e>0. ball x e \<subseteq> S)" |
|
279 by (metis open_contains_ball subset_eq centre_in_ball) |
|
280 |
|
281 lemma ball_eq_empty[simp]: "ball x e = {} \<longleftrightarrow> e \<le> 0" |
|
282 unfolding mem_ball expand_set_eq |
|
283 apply (simp add: not_less) |
|
284 by (metis zero_le_dist order_trans dist_self) |
|
285 |
|
286 lemma ball_empty[intro]: "e \<le> 0 ==> ball x e = {}" by simp |
|
287 |
|
288 subsection{* Basic "localization" results are handy for connectedness. *} |
|
289 |
|
290 lemma openin_open: "openin (subtopology euclidean U) S \<longleftrightarrow> (\<exists>T. open T \<and> (S = U \<inter> T))" |
|
291 by (auto simp add: openin_subtopology open_openin[symmetric]) |
|
292 |
|
293 lemma openin_open_Int[intro]: "open S \<Longrightarrow> openin (subtopology euclidean U) (U \<inter> S)" |
|
294 by (auto simp add: openin_open) |
|
295 |
|
296 lemma open_openin_trans[trans]: |
|
297 "open S \<Longrightarrow> open T \<Longrightarrow> T \<subseteq> S \<Longrightarrow> openin (subtopology euclidean S) T" |
|
298 by (metis Int_absorb1 openin_open_Int) |
|
299 |
|
300 lemma open_subset: "S \<subseteq> T \<Longrightarrow> open S \<Longrightarrow> openin (subtopology euclidean T) S" |
|
301 by (auto simp add: openin_open) |
|
302 |
|
303 lemma closedin_closed: "closedin (subtopology euclidean U) S \<longleftrightarrow> (\<exists>T. closed T \<and> S = U \<inter> T)" |
|
304 by (simp add: closedin_subtopology closed_closedin Int_ac) |
|
305 |
|
306 lemma closedin_closed_Int: "closed S ==> closedin (subtopology euclidean U) (U \<inter> S)" |
|
307 by (metis closedin_closed) |
|
308 |
|
309 lemma closed_closedin_trans: "closed S \<Longrightarrow> closed T \<Longrightarrow> T \<subseteq> S \<Longrightarrow> closedin (subtopology euclidean S) T" |
|
310 apply (subgoal_tac "S \<inter> T = T" ) |
|
311 apply auto |
|
312 apply (frule closedin_closed_Int[of T S]) |
|
313 by simp |
|
314 |
|
315 lemma closed_subset: "S \<subseteq> T \<Longrightarrow> closed S \<Longrightarrow> closedin (subtopology euclidean T) S" |
|
316 by (auto simp add: closedin_closed) |
|
317 |
|
318 lemma openin_euclidean_subtopology_iff: |
|
319 fixes S U :: "'a::metric_space set" |
|
320 shows "openin (subtopology euclidean U) S |
|
321 \<longleftrightarrow> S \<subseteq> U \<and> (\<forall>x\<in>S. \<exists>e>0. \<forall>x'\<in>U. dist x' x < e \<longrightarrow> x'\<in> S)" (is "?lhs \<longleftrightarrow> ?rhs") |
|
322 proof- |
|
323 {assume ?lhs hence ?rhs unfolding openin_subtopology open_openin[symmetric] |
|
324 by (simp add: open_dist) blast} |
|
325 moreover |
|
326 {assume SU: "S \<subseteq> U" and H: "\<And>x. x \<in> S \<Longrightarrow> \<exists>e>0. \<forall>x'\<in>U. dist x' x < e \<longrightarrow> x' \<in> S" |
|
327 from H obtain d where d: "\<And>x . x\<in> S \<Longrightarrow> d x > 0 \<and> (\<forall>x' \<in> U. dist x' x < d x \<longrightarrow> x' \<in> S)" |
|
328 by metis |
|
329 let ?T = "\<Union>{B. \<exists>x\<in>S. B = ball x (d x)}" |
|
330 have oT: "open ?T" by auto |
|
331 { fix x assume "x\<in>S" |
|
332 hence "x \<in> \<Union>{B. \<exists>x\<in>S. B = ball x (d x)}" |
|
333 apply simp apply(rule_tac x="ball x(d x)" in exI) apply auto |
|
334 by (rule d [THEN conjunct1]) |
|
335 hence "x\<in> ?T \<inter> U" using SU and `x\<in>S` by auto } |
|
336 moreover |
|
337 { fix y assume "y\<in>?T" |
|
338 then obtain B where "y\<in>B" "B\<in>{B. \<exists>x\<in>S. B = ball x (d x)}" by auto |
|
339 then obtain x where "x\<in>S" and x:"y \<in> ball x (d x)" by auto |
|
340 assume "y\<in>U" |
|
341 hence "y\<in>S" using d[OF `x\<in>S`] and x by(auto simp add: dist_commute) } |
|
342 ultimately have "S = ?T \<inter> U" by blast |
|
343 with oT have ?lhs unfolding openin_subtopology open_openin[symmetric] by blast} |
|
344 ultimately show ?thesis by blast |
|
345 qed |
|
346 |
|
347 text{* These "transitivity" results are handy too. *} |
|
348 |
|
349 lemma openin_trans[trans]: "openin (subtopology euclidean T) S \<Longrightarrow> openin (subtopology euclidean U) T |
|
350 \<Longrightarrow> openin (subtopology euclidean U) S" |
|
351 unfolding open_openin openin_open by blast |
|
352 |
|
353 lemma openin_open_trans: "openin (subtopology euclidean T) S \<Longrightarrow> open T \<Longrightarrow> open S" |
|
354 by (auto simp add: openin_open intro: openin_trans) |
|
355 |
|
356 lemma closedin_trans[trans]: |
|
357 "closedin (subtopology euclidean T) S \<Longrightarrow> |
|
358 closedin (subtopology euclidean U) T |
|
359 ==> closedin (subtopology euclidean U) S" |
|
360 by (auto simp add: closedin_closed closed_closedin closed_Inter Int_assoc) |
|
361 |
|
362 lemma closedin_closed_trans: "closedin (subtopology euclidean T) S \<Longrightarrow> closed T \<Longrightarrow> closed S" |
|
363 by (auto simp add: closedin_closed intro: closedin_trans) |
|
364 |
|
365 subsection{* Connectedness *} |
|
366 |
|
367 definition "connected S \<longleftrightarrow> |
|
368 ~(\<exists>e1 e2. open e1 \<and> open e2 \<and> S \<subseteq> (e1 \<union> e2) \<and> (e1 \<inter> e2 \<inter> S = {}) |
|
369 \<and> ~(e1 \<inter> S = {}) \<and> ~(e2 \<inter> S = {}))" |
|
370 |
|
371 lemma connected_local: |
|
372 "connected S \<longleftrightarrow> ~(\<exists>e1 e2. |
|
373 openin (subtopology euclidean S) e1 \<and> |
|
374 openin (subtopology euclidean S) e2 \<and> |
|
375 S \<subseteq> e1 \<union> e2 \<and> |
|
376 e1 \<inter> e2 = {} \<and> |
|
377 ~(e1 = {}) \<and> |
|
378 ~(e2 = {}))" |
|
379 unfolding connected_def openin_open by (safe, blast+) |
|
380 |
|
381 lemma exists_diff: "(\<exists>S. P(UNIV - S)) \<longleftrightarrow> (\<exists>S. P S)" (is "?lhs \<longleftrightarrow> ?rhs") |
|
382 proof- |
|
383 |
|
384 {assume "?lhs" hence ?rhs by blast } |
|
385 moreover |
|
386 {fix S assume H: "P S" |
|
387 have "S = UNIV - (UNIV - S)" by auto |
|
388 with H have "P (UNIV - (UNIV - S))" by metis } |
|
389 ultimately show ?thesis by metis |
|
390 qed |
|
391 |
|
392 lemma connected_clopen: "connected S \<longleftrightarrow> |
|
393 (\<forall>T. openin (subtopology euclidean S) T \<and> |
|
394 closedin (subtopology euclidean S) T \<longrightarrow> T = {} \<or> T = S)" (is "?lhs \<longleftrightarrow> ?rhs") |
|
395 proof- |
|
396 have " \<not> connected S \<longleftrightarrow> (\<exists>e1 e2. open e1 \<and> open (UNIV - e2) \<and> S \<subseteq> e1 \<union> (UNIV - e2) \<and> e1 \<inter> (UNIV - e2) \<inter> S = {} \<and> e1 \<inter> S \<noteq> {} \<and> (UNIV - e2) \<inter> S \<noteq> {})" |
|
397 unfolding connected_def openin_open closedin_closed |
|
398 apply (subst exists_diff) by blast |
|
399 hence th0: "connected S \<longleftrightarrow> \<not> (\<exists>e2 e1. closed e2 \<and> open e1 \<and> S \<subseteq> e1 \<union> (UNIV - e2) \<and> e1 \<inter> (UNIV - e2) \<inter> S = {} \<and> e1 \<inter> S \<noteq> {} \<and> (UNIV - e2) \<inter> S \<noteq> {})" |
|
400 (is " _ \<longleftrightarrow> \<not> (\<exists>e2 e1. ?P e2 e1)") apply (simp add: closed_def Compl_eq_Diff_UNIV) by metis |
|
401 |
|
402 have th1: "?rhs \<longleftrightarrow> \<not> (\<exists>t' t. closed t'\<and>t = S\<inter>t' \<and> t\<noteq>{} \<and> t\<noteq>S \<and> (\<exists>t'. open t' \<and> t = S \<inter> t'))" |
|
403 (is "_ \<longleftrightarrow> \<not> (\<exists>t' t. ?Q t' t)") |
|
404 unfolding connected_def openin_open closedin_closed by auto |
|
405 {fix e2 |
|
406 {fix e1 have "?P e2 e1 \<longleftrightarrow> (\<exists>t. closed e2 \<and> t = S\<inter>e2 \<and> open e1 \<and> t = S\<inter>e1 \<and> t\<noteq>{} \<and> t\<noteq>S)" |
|
407 by auto} |
|
408 then have "(\<exists>e1. ?P e2 e1) \<longleftrightarrow> (\<exists>t. ?Q e2 t)" by metis} |
|
409 then have "\<forall>e2. (\<exists>e1. ?P e2 e1) \<longleftrightarrow> (\<exists>t. ?Q e2 t)" by blast |
|
410 then show ?thesis unfolding th0 th1 by simp |
|
411 qed |
|
412 |
|
413 lemma connected_empty[simp, intro]: "connected {}" |
|
414 by (simp add: connected_def) |
|
415 |
|
416 subsection{* Hausdorff and other separation properties *} |
|
417 |
|
418 class t0_space = |
|
419 assumes t0_space: "x \<noteq> y \<Longrightarrow> \<exists>U. open U \<and> \<not> (x \<in> U \<longleftrightarrow> y \<in> U)" |
|
420 |
|
421 class t1_space = |
|
422 assumes t1_space: "x \<noteq> y \<Longrightarrow> \<exists>U V. open U \<and> open V \<and> x \<in> U \<and> y \<notin> U \<and> x \<notin> V \<and> y \<in> V" |
|
423 begin |
|
424 |
|
425 subclass t0_space |
|
426 proof |
|
427 qed (fast dest: t1_space) |
|
428 |
|
429 end |
|
430 |
|
431 text {* T2 spaces are also known as Hausdorff spaces. *} |
|
432 |
|
433 class t2_space = |
|
434 assumes hausdorff: "x \<noteq> y \<Longrightarrow> \<exists>U V. open U \<and> open V \<and> x \<in> U \<and> y \<in> V \<and> U \<inter> V = {}" |
|
435 begin |
|
436 |
|
437 subclass t1_space |
|
438 proof |
|
439 qed (fast dest: hausdorff) |
|
440 |
|
441 end |
|
442 |
|
443 instance metric_space \<subseteq> t2_space |
|
444 proof |
|
445 fix x y :: "'a::metric_space" |
|
446 assume xy: "x \<noteq> y" |
|
447 let ?U = "ball x (dist x y / 2)" |
|
448 let ?V = "ball y (dist x y / 2)" |
|
449 have th0: "\<And>d x y z. (d x z :: real) <= d x y + d y z \<Longrightarrow> d y z = d z y |
|
450 ==> ~(d x y * 2 < d x z \<and> d z y * 2 < d x z)" by arith |
|
451 have "open ?U \<and> open ?V \<and> x \<in> ?U \<and> y \<in> ?V \<and> ?U \<inter> ?V = {}" |
|
452 using dist_pos_lt[OF xy] th0[of dist,OF dist_triangle dist_commute] |
|
453 by (auto simp add: expand_set_eq) |
|
454 then show "\<exists>U V. open U \<and> open V \<and> x \<in> U \<and> y \<in> V \<and> U \<inter> V = {}" |
|
455 by blast |
|
456 qed |
|
457 |
|
458 lemma separation_t2: |
|
459 fixes x y :: "'a::t2_space" |
|
460 shows "x \<noteq> y \<longleftrightarrow> (\<exists>U V. open U \<and> open V \<and> x \<in> U \<and> y \<in> V \<and> U \<inter> V = {})" |
|
461 using hausdorff[of x y] by blast |
|
462 |
|
463 lemma separation_t1: |
|
464 fixes x y :: "'a::t1_space" |
|
465 shows "x \<noteq> y \<longleftrightarrow> (\<exists>U V. open U \<and> open V \<and> x \<in>U \<and> y\<notin> U \<and> x\<notin>V \<and> y\<in>V)" |
|
466 using t1_space[of x y] by blast |
|
467 |
|
468 lemma separation_t0: |
|
469 fixes x y :: "'a::t0_space" |
|
470 shows "x \<noteq> y \<longleftrightarrow> (\<exists>U. open U \<and> ~(x\<in>U \<longleftrightarrow> y\<in>U))" |
|
471 using t0_space[of x y] by blast |
|
472 |
|
473 subsection{* Limit points *} |
|
474 |
|
475 definition |
|
476 islimpt:: "'a::topological_space \<Rightarrow> 'a set \<Rightarrow> bool" |
|
477 (infixr "islimpt" 60) where |
|
478 "x islimpt S \<longleftrightarrow> (\<forall>T. x\<in>T \<longrightarrow> open T \<longrightarrow> (\<exists>y\<in>S. y\<in>T \<and> y\<noteq>x))" |
|
479 |
|
480 lemma islimptI: |
|
481 assumes "\<And>T. x \<in> T \<Longrightarrow> open T \<Longrightarrow> \<exists>y\<in>S. y \<in> T \<and> y \<noteq> x" |
|
482 shows "x islimpt S" |
|
483 using assms unfolding islimpt_def by auto |
|
484 |
|
485 lemma islimptE: |
|
486 assumes "x islimpt S" and "x \<in> T" and "open T" |
|
487 obtains y where "y \<in> S" and "y \<in> T" and "y \<noteq> x" |
|
488 using assms unfolding islimpt_def by auto |
|
489 |
|
490 lemma islimpt_subset: "x islimpt S \<Longrightarrow> S \<subseteq> T ==> x islimpt T" by (auto simp add: islimpt_def) |
|
491 |
|
492 lemma islimpt_approachable: |
|
493 fixes x :: "'a::metric_space" |
|
494 shows "x islimpt S \<longleftrightarrow> (\<forall>e>0. \<exists>x'\<in>S. x' \<noteq> x \<and> dist x' x < e)" |
|
495 unfolding islimpt_def |
|
496 apply auto |
|
497 apply(erule_tac x="ball x e" in allE) |
|
498 apply auto |
|
499 apply(rule_tac x=y in bexI) |
|
500 apply (auto simp add: dist_commute) |
|
501 apply (simp add: open_dist, drule (1) bspec) |
|
502 apply (clarify, drule spec, drule (1) mp, auto) |
|
503 done |
|
504 |
|
505 lemma islimpt_approachable_le: |
|
506 fixes x :: "'a::metric_space" |
|
507 shows "x islimpt S \<longleftrightarrow> (\<forall>e>0. \<exists>x'\<in> S. x' \<noteq> x \<and> dist x' x <= e)" |
|
508 unfolding islimpt_approachable |
|
509 using approachable_lt_le[where f="\<lambda>x'. dist x' x" and P="\<lambda>x'. \<not> (x'\<in>S \<and> x'\<noteq>x)"] |
|
510 by metis (* FIXME: VERY slow! *) |
|
511 |
|
512 class perfect_space = |
|
513 (* FIXME: perfect_space should inherit from topological_space *) |
|
514 assumes islimpt_UNIV [simp, intro]: "(x::'a::metric_space) islimpt UNIV" |
|
515 |
|
516 lemma perfect_choose_dist: |
|
517 fixes x :: "'a::perfect_space" |
|
518 shows "0 < r \<Longrightarrow> \<exists>a. a \<noteq> x \<and> dist a x < r" |
|
519 using islimpt_UNIV [of x] |
|
520 by (simp add: islimpt_approachable) |
|
521 |
|
522 instance real :: perfect_space |
|
523 apply default |
|
524 apply (rule islimpt_approachable [THEN iffD2]) |
|
525 apply (clarify, rule_tac x="x + e/2" in bexI) |
|
526 apply (auto simp add: dist_norm) |
|
527 done |
|
528 |
|
529 instance "^" :: (perfect_space, finite) perfect_space |
|
530 proof |
|
531 fix x :: "'a ^ 'b" |
|
532 { |
|
533 fix e :: real assume "0 < e" |
|
534 def a \<equiv> "x $ undefined" |
|
535 have "a islimpt UNIV" by (rule islimpt_UNIV) |
|
536 with `0 < e` obtain b where "b \<noteq> a" and "dist b a < e" |
|
537 unfolding islimpt_approachable by auto |
|
538 def y \<equiv> "Cart_lambda ((Cart_nth x)(undefined := b))" |
|
539 from `b \<noteq> a` have "y \<noteq> x" |
|
540 unfolding a_def y_def by (simp add: Cart_eq) |
|
541 from `dist b a < e` have "dist y x < e" |
|
542 unfolding dist_vector_def a_def y_def |
|
543 apply simp |
|
544 apply (rule le_less_trans [OF setL2_le_setsum [OF zero_le_dist]]) |
|
545 apply (subst setsum_diff1' [where a=undefined], simp, simp, simp) |
|
546 done |
|
547 from `y \<noteq> x` and `dist y x < e` |
|
548 have "\<exists>y\<in>UNIV. y \<noteq> x \<and> dist y x < e" by auto |
|
549 } |
|
550 then show "x islimpt UNIV" unfolding islimpt_approachable by blast |
|
551 qed |
|
552 |
|
553 lemma closed_limpt: "closed S \<longleftrightarrow> (\<forall>x. x islimpt S \<longrightarrow> x \<in> S)" |
|
554 unfolding closed_def |
|
555 apply (subst open_subopen) |
|
556 apply (simp add: islimpt_def subset_eq Compl_eq_Diff_UNIV) |
|
557 by (metis DiffE DiffI UNIV_I insertCI insert_absorb mem_def) |
|
558 |
|
559 lemma islimpt_EMPTY[simp]: "\<not> x islimpt {}" |
|
560 unfolding islimpt_def by auto |
|
561 |
|
562 lemma closed_positive_orthant: "closed {x::real^'n::finite. \<forall>i. 0 \<le>x$i}" |
|
563 proof- |
|
564 let ?U = "UNIV :: 'n set" |
|
565 let ?O = "{x::real^'n. \<forall>i. x$i\<ge>0}" |
|
566 {fix x:: "real^'n" and i::'n assume H: "\<forall>e>0. \<exists>x'\<in>?O. x' \<noteq> x \<and> dist x' x < e" |
|
567 and xi: "x$i < 0" |
|
568 from xi have th0: "-x$i > 0" by arith |
|
569 from H[rule_format, OF th0] obtain x' where x': "x' \<in>?O" "x' \<noteq> x" "dist x' x < -x $ i" by blast |
|
570 have th:" \<And>b a (x::real). abs x <= b \<Longrightarrow> b <= a ==> ~(a + x < 0)" by arith |
|
571 have th': "\<And>x (y::real). x < 0 \<Longrightarrow> 0 <= y ==> abs x <= abs (y - x)" by arith |
|
572 have th1: "\<bar>x$i\<bar> \<le> \<bar>(x' - x)$i\<bar>" using x'(1) xi |
|
573 apply (simp only: vector_component) |
|
574 by (rule th') auto |
|
575 have th2: "\<bar>dist x x'\<bar> \<ge> \<bar>(x' - x)$i\<bar>" using component_le_norm[of "x'-x" i] |
|
576 apply (simp add: dist_norm) by norm |
|
577 from th[OF th1 th2] x'(3) have False by (simp add: dist_commute) } |
|
578 then show ?thesis unfolding closed_limpt islimpt_approachable |
|
579 unfolding not_le[symmetric] by blast |
|
580 qed |
|
581 |
|
582 lemma finite_set_avoid: |
|
583 fixes a :: "'a::metric_space" |
|
584 assumes fS: "finite S" shows "\<exists>d>0. \<forall>x\<in>S. x \<noteq> a \<longrightarrow> d <= dist a x" |
|
585 proof(induct rule: finite_induct[OF fS]) |
|
586 case 1 thus ?case apply auto by ferrack |
|
587 next |
|
588 case (2 x F) |
|
589 from 2 obtain d where d: "d >0" "\<forall>x\<in>F. x\<noteq>a \<longrightarrow> d \<le> dist a x" by blast |
|
590 {assume "x = a" hence ?case using d by auto } |
|
591 moreover |
|
592 {assume xa: "x\<noteq>a" |
|
593 let ?d = "min d (dist a x)" |
|
594 have dp: "?d > 0" using xa d(1) using dist_nz by auto |
|
595 from d have d': "\<forall>x\<in>F. x\<noteq>a \<longrightarrow> ?d \<le> dist a x" by auto |
|
596 with dp xa have ?case by(auto intro!: exI[where x="?d"]) } |
|
597 ultimately show ?case by blast |
|
598 qed |
|
599 |
|
600 lemma islimpt_finite: |
|
601 fixes S :: "'a::metric_space set" |
|
602 assumes fS: "finite S" shows "\<not> a islimpt S" |
|
603 unfolding islimpt_approachable |
|
604 using finite_set_avoid[OF fS, of a] by (metis dist_commute not_le) |
|
605 |
|
606 lemma islimpt_Un: "x islimpt (S \<union> T) \<longleftrightarrow> x islimpt S \<or> x islimpt T" |
|
607 apply (rule iffI) |
|
608 defer |
|
609 apply (metis Un_upper1 Un_upper2 islimpt_subset) |
|
610 unfolding islimpt_def |
|
611 apply (rule ccontr, clarsimp, rename_tac A B) |
|
612 apply (drule_tac x="A \<inter> B" in spec) |
|
613 apply (auto simp add: open_Int) |
|
614 done |
|
615 |
|
616 lemma discrete_imp_closed: |
|
617 fixes S :: "'a::metric_space set" |
|
618 assumes e: "0 < e" and d: "\<forall>x \<in> S. \<forall>y \<in> S. dist y x < e \<longrightarrow> y = x" |
|
619 shows "closed S" |
|
620 proof- |
|
621 {fix x assume C: "\<forall>e>0. \<exists>x'\<in>S. x' \<noteq> x \<and> dist x' x < e" |
|
622 from e have e2: "e/2 > 0" by arith |
|
623 from C[rule_format, OF e2] obtain y where y: "y \<in> S" "y\<noteq>x" "dist y x < e/2" by blast |
|
624 let ?m = "min (e/2) (dist x y) " |
|
625 from e2 y(2) have mp: "?m > 0" by (simp add: dist_nz[THEN sym]) |
|
626 from C[rule_format, OF mp] obtain z where z: "z \<in> S" "z\<noteq>x" "dist z x < ?m" by blast |
|
627 have th: "dist z y < e" using z y |
|
628 by (intro dist_triangle_lt [where z=x], simp) |
|
629 from d[rule_format, OF y(1) z(1) th] y z |
|
630 have False by (auto simp add: dist_commute)} |
|
631 then show ?thesis by (metis islimpt_approachable closed_limpt [where 'a='a]) |
|
632 qed |
|
633 |
|
634 subsection{* Interior of a Set *} |
|
635 definition "interior S = {x. \<exists>T. open T \<and> x \<in> T \<and> T \<subseteq> S}" |
|
636 |
|
637 lemma interior_eq: "interior S = S \<longleftrightarrow> open S" |
|
638 apply (simp add: expand_set_eq interior_def) |
|
639 apply (subst (2) open_subopen) by (safe, blast+) |
|
640 |
|
641 lemma interior_open: "open S ==> (interior S = S)" by (metis interior_eq) |
|
642 |
|
643 lemma interior_empty[simp]: "interior {} = {}" by (simp add: interior_def) |
|
644 |
|
645 lemma open_interior[simp, intro]: "open(interior S)" |
|
646 apply (simp add: interior_def) |
|
647 apply (subst open_subopen) by blast |
|
648 |
|
649 lemma interior_interior[simp]: "interior(interior S) = interior S" by (metis interior_eq open_interior) |
|
650 lemma interior_subset: "interior S \<subseteq> S" by (auto simp add: interior_def) |
|
651 lemma subset_interior: "S \<subseteq> T ==> (interior S) \<subseteq> (interior T)" by (auto simp add: interior_def) |
|
652 lemma interior_maximal: "T \<subseteq> S \<Longrightarrow> open T ==> T \<subseteq> (interior S)" by (auto simp add: interior_def) |
|
653 lemma interior_unique: "T \<subseteq> S \<Longrightarrow> open T \<Longrightarrow> (\<forall>T'. T' \<subseteq> S \<and> open T' \<longrightarrow> T' \<subseteq> T) \<Longrightarrow> interior S = T" |
|
654 by (metis equalityI interior_maximal interior_subset open_interior) |
|
655 lemma mem_interior: "x \<in> interior S \<longleftrightarrow> (\<exists>e. 0 < e \<and> ball x e \<subseteq> S)" |
|
656 apply (simp add: interior_def) |
|
657 by (metis open_contains_ball centre_in_ball open_ball subset_trans) |
|
658 |
|
659 lemma open_subset_interior: "open S ==> S \<subseteq> interior T \<longleftrightarrow> S \<subseteq> T" |
|
660 by (metis interior_maximal interior_subset subset_trans) |
|
661 |
|
662 lemma interior_inter[simp]: "interior(S \<inter> T) = interior S \<inter> interior T" |
|
663 apply (rule equalityI, simp) |
|
664 apply (metis Int_lower1 Int_lower2 subset_interior) |
|
665 by (metis Int_mono interior_subset open_Int open_interior open_subset_interior) |
|
666 |
|
667 lemma interior_limit_point [intro]: |
|
668 fixes x :: "'a::perfect_space" |
|
669 assumes x: "x \<in> interior S" shows "x islimpt S" |
|
670 proof- |
|
671 from x obtain e where e: "e>0" "\<forall>x'. dist x x' < e \<longrightarrow> x' \<in> S" |
|
672 unfolding mem_interior subset_eq Ball_def mem_ball by blast |
|
673 { |
|
674 fix d::real assume d: "d>0" |
|
675 let ?m = "min d e" |
|
676 have mde2: "0 < ?m" using e(1) d(1) by simp |
|
677 from perfect_choose_dist [OF mde2, of x] |
|
678 obtain y where "y \<noteq> x" and "dist y x < ?m" by blast |
|
679 then have "dist y x < e" "dist y x < d" by simp_all |
|
680 from `dist y x < e` e(2) have "y \<in> S" by (simp add: dist_commute) |
|
681 have "\<exists>x'\<in>S. x'\<noteq> x \<and> dist x' x < d" |
|
682 using `y \<in> S` `y \<noteq> x` `dist y x < d` by fast |
|
683 } |
|
684 then show ?thesis unfolding islimpt_approachable by blast |
|
685 qed |
|
686 |
|
687 lemma interior_closed_Un_empty_interior: |
|
688 assumes cS: "closed S" and iT: "interior T = {}" |
|
689 shows "interior(S \<union> T) = interior S" |
|
690 proof |
|
691 show "interior S \<subseteq> interior (S\<union>T)" |
|
692 by (rule subset_interior, blast) |
|
693 next |
|
694 show "interior (S \<union> T) \<subseteq> interior S" |
|
695 proof |
|
696 fix x assume "x \<in> interior (S \<union> T)" |
|
697 then obtain R where "open R" "x \<in> R" "R \<subseteq> S \<union> T" |
|
698 unfolding interior_def by fast |
|
699 show "x \<in> interior S" |
|
700 proof (rule ccontr) |
|
701 assume "x \<notin> interior S" |
|
702 with `x \<in> R` `open R` obtain y where "y \<in> R - S" |
|
703 unfolding interior_def expand_set_eq by fast |
|
704 from `open R` `closed S` have "open (R - S)" by (rule open_Diff) |
|
705 from `R \<subseteq> S \<union> T` have "R - S \<subseteq> T" by fast |
|
706 from `y \<in> R - S` `open (R - S)` `R - S \<subseteq> T` `interior T = {}` |
|
707 show "False" unfolding interior_def by fast |
|
708 qed |
|
709 qed |
|
710 qed |
|
711 |
|
712 |
|
713 subsection{* Closure of a Set *} |
|
714 |
|
715 definition "closure S = S \<union> {x | x. x islimpt S}" |
|
716 |
|
717 lemma closure_interior: "closure S = UNIV - interior (UNIV - S)" |
|
718 proof- |
|
719 { fix x |
|
720 have "x\<in>UNIV - interior (UNIV - S) \<longleftrightarrow> x \<in> closure S" (is "?lhs = ?rhs") |
|
721 proof |
|
722 let ?exT = "\<lambda> y. (\<exists>T. open T \<and> y \<in> T \<and> T \<subseteq> UNIV - S)" |
|
723 assume "?lhs" |
|
724 hence *:"\<not> ?exT x" |
|
725 unfolding interior_def |
|
726 by simp |
|
727 { assume "\<not> ?rhs" |
|
728 hence False using * |
|
729 unfolding closure_def islimpt_def |
|
730 by blast |
|
731 } |
|
732 thus "?rhs" |
|
733 by blast |
|
734 next |
|
735 assume "?rhs" thus "?lhs" |
|
736 unfolding closure_def interior_def islimpt_def |
|
737 by blast |
|
738 qed |
|
739 } |
|
740 thus ?thesis |
|
741 by blast |
|
742 qed |
|
743 |
|
744 lemma interior_closure: "interior S = UNIV - (closure (UNIV - S))" |
|
745 proof- |
|
746 { fix x |
|
747 have "x \<in> interior S \<longleftrightarrow> x \<in> UNIV - (closure (UNIV - S))" |
|
748 unfolding interior_def closure_def islimpt_def |
|
749 by blast (* FIXME: VERY slow! *) |
|
750 } |
|
751 thus ?thesis |
|
752 by blast |
|
753 qed |
|
754 |
|
755 lemma closed_closure[simp, intro]: "closed (closure S)" |
|
756 proof- |
|
757 have "closed (UNIV - interior (UNIV -S))" by blast |
|
758 thus ?thesis using closure_interior[of S] by simp |
|
759 qed |
|
760 |
|
761 lemma closure_hull: "closure S = closed hull S" |
|
762 proof- |
|
763 have "S \<subseteq> closure S" |
|
764 unfolding closure_def |
|
765 by blast |
|
766 moreover |
|
767 have "closed (closure S)" |
|
768 using closed_closure[of S] |
|
769 by assumption |
|
770 moreover |
|
771 { fix t |
|
772 assume *:"S \<subseteq> t" "closed t" |
|
773 { fix x |
|
774 assume "x islimpt S" |
|
775 hence "x islimpt t" using *(1) |
|
776 using islimpt_subset[of x, of S, of t] |
|
777 by blast |
|
778 } |
|
779 with * have "closure S \<subseteq> t" |
|
780 unfolding closure_def |
|
781 using closed_limpt[of t] |
|
782 by auto |
|
783 } |
|
784 ultimately show ?thesis |
|
785 using hull_unique[of S, of "closure S", of closed] |
|
786 unfolding mem_def |
|
787 by simp |
|
788 qed |
|
789 |
|
790 lemma closure_eq: "closure S = S \<longleftrightarrow> closed S" |
|
791 unfolding closure_hull |
|
792 using hull_eq[of closed, unfolded mem_def, OF closed_Inter, of S] |
|
793 by (metis mem_def subset_eq) |
|
794 |
|
795 lemma closure_closed[simp]: "closed S \<Longrightarrow> closure S = S" |
|
796 using closure_eq[of S] |
|
797 by simp |
|
798 |
|
799 lemma closure_closure[simp]: "closure (closure S) = closure S" |
|
800 unfolding closure_hull |
|
801 using hull_hull[of closed S] |
|
802 by assumption |
|
803 |
|
804 lemma closure_subset: "S \<subseteq> closure S" |
|
805 unfolding closure_hull |
|
806 using hull_subset[of S closed] |
|
807 by assumption |
|
808 |
|
809 lemma subset_closure: "S \<subseteq> T \<Longrightarrow> closure S \<subseteq> closure T" |
|
810 unfolding closure_hull |
|
811 using hull_mono[of S T closed] |
|
812 by assumption |
|
813 |
|
814 lemma closure_minimal: "S \<subseteq> T \<Longrightarrow> closed T \<Longrightarrow> closure S \<subseteq> T" |
|
815 using hull_minimal[of S T closed] |
|
816 unfolding closure_hull mem_def |
|
817 by simp |
|
818 |
|
819 lemma closure_unique: "S \<subseteq> T \<and> closed T \<and> (\<forall> T'. S \<subseteq> T' \<and> closed T' \<longrightarrow> T \<subseteq> T') \<Longrightarrow> closure S = T" |
|
820 using hull_unique[of S T closed] |
|
821 unfolding closure_hull mem_def |
|
822 by simp |
|
823 |
|
824 lemma closure_empty[simp]: "closure {} = {}" |
|
825 using closed_empty closure_closed[of "{}"] |
|
826 by simp |
|
827 |
|
828 lemma closure_univ[simp]: "closure UNIV = UNIV" |
|
829 using closure_closed[of UNIV] |
|
830 by simp |
|
831 |
|
832 lemma closure_eq_empty: "closure S = {} \<longleftrightarrow> S = {}" |
|
833 using closure_empty closure_subset[of S] |
|
834 by blast |
|
835 |
|
836 lemma closure_subset_eq: "closure S \<subseteq> S \<longleftrightarrow> closed S" |
|
837 using closure_eq[of S] closure_subset[of S] |
|
838 by simp |
|
839 |
|
840 lemma open_inter_closure_eq_empty: |
|
841 "open S \<Longrightarrow> (S \<inter> closure T) = {} \<longleftrightarrow> S \<inter> T = {}" |
|
842 using open_subset_interior[of S "UNIV - T"] |
|
843 using interior_subset[of "UNIV - T"] |
|
844 unfolding closure_interior |
|
845 by auto |
|
846 |
|
847 lemma open_inter_closure_subset: |
|
848 "open S \<Longrightarrow> (S \<inter> (closure T)) \<subseteq> closure(S \<inter> T)" |
|
849 proof |
|
850 fix x |
|
851 assume as: "open S" "x \<in> S \<inter> closure T" |
|
852 { assume *:"x islimpt T" |
|
853 have "x islimpt (S \<inter> T)" |
|
854 proof (rule islimptI) |
|
855 fix A |
|
856 assume "x \<in> A" "open A" |
|
857 with as have "x \<in> A \<inter> S" "open (A \<inter> S)" |
|
858 by (simp_all add: open_Int) |
|
859 with * obtain y where "y \<in> T" "y \<in> A \<inter> S" "y \<noteq> x" |
|
860 by (rule islimptE) |
|
861 hence "y \<in> S \<inter> T" "y \<in> A \<and> y \<noteq> x" |
|
862 by simp_all |
|
863 thus "\<exists>y\<in>(S \<inter> T). y \<in> A \<and> y \<noteq> x" .. |
|
864 qed |
|
865 } |
|
866 then show "x \<in> closure (S \<inter> T)" using as |
|
867 unfolding closure_def |
|
868 by blast |
|
869 qed |
|
870 |
|
871 lemma closure_complement: "closure(UNIV - S) = UNIV - interior(S)" |
|
872 proof- |
|
873 have "S = UNIV - (UNIV - S)" |
|
874 by auto |
|
875 thus ?thesis |
|
876 unfolding closure_interior |
|
877 by auto |
|
878 qed |
|
879 |
|
880 lemma interior_complement: "interior(UNIV - S) = UNIV - closure(S)" |
|
881 unfolding closure_interior |
|
882 by blast |
|
883 |
|
884 subsection{* Frontier (aka boundary) *} |
|
885 |
|
886 definition "frontier S = closure S - interior S" |
|
887 |
|
888 lemma frontier_closed: "closed(frontier S)" |
|
889 by (simp add: frontier_def closed_Diff) |
|
890 |
|
891 lemma frontier_closures: "frontier S = (closure S) \<inter> (closure(UNIV - S))" |
|
892 by (auto simp add: frontier_def interior_closure) |
|
893 |
|
894 lemma frontier_straddle: |
|
895 fixes a :: "'a::metric_space" |
|
896 shows "a \<in> frontier S \<longleftrightarrow> (\<forall>e>0. (\<exists>x\<in>S. dist a x < e) \<and> (\<exists>x. x \<notin> S \<and> dist a x < e))" (is "?lhs \<longleftrightarrow> ?rhs") |
|
897 proof |
|
898 assume "?lhs" |
|
899 { fix e::real |
|
900 assume "e > 0" |
|
901 let ?rhse = "(\<exists>x\<in>S. dist a x < e) \<and> (\<exists>x. x \<notin> S \<and> dist a x < e)" |
|
902 { assume "a\<in>S" |
|
903 have "\<exists>x\<in>S. dist a x < e" using `e>0` `a\<in>S` by(rule_tac x=a in bexI) auto |
|
904 moreover have "\<exists>x. x \<notin> S \<and> dist a x < e" using `?lhs` `a\<in>S` |
|
905 unfolding frontier_closures closure_def islimpt_def using `e>0` |
|
906 by (auto, erule_tac x="ball a e" in allE, auto) |
|
907 ultimately have ?rhse by auto |
|
908 } |
|
909 moreover |
|
910 { assume "a\<notin>S" |
|
911 hence ?rhse using `?lhs` |
|
912 unfolding frontier_closures closure_def islimpt_def |
|
913 using open_ball[of a e] `e > 0` |
|
914 by (auto, erule_tac x = "ball a e" in allE, auto) (* FIXME: VERY slow! *) |
|
915 } |
|
916 ultimately have ?rhse by auto |
|
917 } |
|
918 thus ?rhs by auto |
|
919 next |
|
920 assume ?rhs |
|
921 moreover |
|
922 { fix T assume "a\<notin>S" and |
|
923 as:"\<forall>e>0. (\<exists>x\<in>S. dist a x < e) \<and> (\<exists>x. x \<notin> S \<and> dist a x < e)" "a \<notin> S" "a \<in> T" "open T" |
|
924 from `open T` `a \<in> T` have "\<exists>e>0. ball a e \<subseteq> T" unfolding open_contains_ball[of T] by auto |
|
925 then obtain e where "e>0" "ball a e \<subseteq> T" by auto |
|
926 then obtain y where y:"y\<in>S" "dist a y < e" using as(1) by auto |
|
927 have "\<exists>y\<in>S. y \<in> T \<and> y \<noteq> a" |
|
928 using `dist a y < e` `ball a e \<subseteq> T` unfolding ball_def using `y\<in>S` `a\<notin>S` by auto |
|
929 } |
|
930 hence "a \<in> closure S" unfolding closure_def islimpt_def using `?rhs` by auto |
|
931 moreover |
|
932 { fix T assume "a \<in> T" "open T" "a\<in>S" |
|
933 then obtain e where "e>0" and balle: "ball a e \<subseteq> T" unfolding open_contains_ball using `?rhs` by auto |
|
934 obtain x where "x \<notin> S" "dist a x < e" using `?rhs` using `e>0` by auto |
|
935 hence "\<exists>y\<in>UNIV - S. y \<in> T \<and> y \<noteq> a" using balle `a\<in>S` unfolding ball_def by (rule_tac x=x in bexI)auto |
|
936 } |
|
937 hence "a islimpt (UNIV - S) \<or> a\<notin>S" unfolding islimpt_def by auto |
|
938 ultimately show ?lhs unfolding frontier_closures using closure_def[of "UNIV - S"] by auto |
|
939 qed |
|
940 |
|
941 lemma frontier_subset_closed: "closed S \<Longrightarrow> frontier S \<subseteq> S" |
|
942 by (metis frontier_def closure_closed Diff_subset) |
|
943 |
|
944 lemma frontier_empty: "frontier {} = {}" |
|
945 by (simp add: frontier_def closure_empty) |
|
946 |
|
947 lemma frontier_subset_eq: "frontier S \<subseteq> S \<longleftrightarrow> closed S" |
|
948 proof- |
|
949 { assume "frontier S \<subseteq> S" |
|
950 hence "closure S \<subseteq> S" using interior_subset unfolding frontier_def by auto |
|
951 hence "closed S" using closure_subset_eq by auto |
|
952 } |
|
953 thus ?thesis using frontier_subset_closed[of S] by auto |
|
954 qed |
|
955 |
|
956 lemma frontier_complement: "frontier(UNIV - S) = frontier S" |
|
957 by (auto simp add: frontier_def closure_complement interior_complement) |
|
958 |
|
959 lemma frontier_disjoint_eq: "frontier S \<inter> S = {} \<longleftrightarrow> open S" |
|
960 using frontier_complement frontier_subset_eq[of "UNIV - S"] |
|
961 unfolding open_closed Compl_eq_Diff_UNIV by auto |
|
962 |
|
963 subsection{* Common nets and The "within" modifier for nets. *} |
|
964 |
|
965 definition |
|
966 at_infinity :: "'a::real_normed_vector net" where |
|
967 "at_infinity = Abs_net (range (\<lambda>r. {x. r \<le> norm x}))" |
|
968 |
|
969 definition |
|
970 indirection :: "'a::real_normed_vector \<Rightarrow> 'a \<Rightarrow> 'a net" (infixr "indirection" 70) where |
|
971 "a indirection v = (at a) within {b. \<exists>c\<ge>0. b - a = scaleR c v}" |
|
972 |
|
973 text{* Prove That They are all nets. *} |
|
974 |
|
975 lemma Rep_net_at_infinity: |
|
976 "Rep_net at_infinity = range (\<lambda>r. {x. r \<le> norm x})" |
|
977 unfolding at_infinity_def |
|
978 apply (rule Abs_net_inverse') |
|
979 apply (rule image_nonempty, simp) |
|
980 apply (clarsimp, rename_tac r s) |
|
981 apply (rule_tac x="max r s" in exI, auto) |
|
982 done |
|
983 |
|
984 lemma within_UNIV: "net within UNIV = net" |
|
985 by (simp add: Rep_net_inject [symmetric] Rep_net_within) |
|
986 |
|
987 subsection{* Identify Trivial limits, where we can't approach arbitrarily closely. *} |
|
988 |
|
989 definition |
|
990 trivial_limit :: "'a net \<Rightarrow> bool" where |
|
991 "trivial_limit net \<longleftrightarrow> {} \<in> Rep_net net" |
|
992 |
|
993 lemma trivial_limit_within: |
|
994 shows "trivial_limit (at a within S) \<longleftrightarrow> \<not> a islimpt S" |
|
995 proof |
|
996 assume "trivial_limit (at a within S)" |
|
997 thus "\<not> a islimpt S" |
|
998 unfolding trivial_limit_def |
|
999 unfolding Rep_net_within Rep_net_at |
|
1000 unfolding islimpt_def |
|
1001 apply (clarsimp simp add: expand_set_eq) |
|
1002 apply (rename_tac T, rule_tac x=T in exI) |
|
1003 apply (clarsimp, drule_tac x=y in spec, simp) |
|
1004 done |
|
1005 next |
|
1006 assume "\<not> a islimpt S" |
|
1007 thus "trivial_limit (at a within S)" |
|
1008 unfolding trivial_limit_def |
|
1009 unfolding Rep_net_within Rep_net_at |
|
1010 unfolding islimpt_def |
|
1011 apply (clarsimp simp add: image_image) |
|
1012 apply (rule_tac x=T in image_eqI) |
|
1013 apply (auto simp add: expand_set_eq) |
|
1014 done |
|
1015 qed |
|
1016 |
|
1017 lemma trivial_limit_at_iff: "trivial_limit (at a) \<longleftrightarrow> \<not> a islimpt UNIV" |
|
1018 using trivial_limit_within [of a UNIV] |
|
1019 by (simp add: within_UNIV) |
|
1020 |
|
1021 lemma trivial_limit_at: |
|
1022 fixes a :: "'a::perfect_space" |
|
1023 shows "\<not> trivial_limit (at a)" |
|
1024 by (simp add: trivial_limit_at_iff) |
|
1025 |
|
1026 lemma trivial_limit_at_infinity: |
|
1027 "\<not> trivial_limit (at_infinity :: ('a::{real_normed_vector,zero_neq_one}) net)" |
|
1028 (* FIXME: find a more appropriate type class *) |
|
1029 unfolding trivial_limit_def Rep_net_at_infinity |
|
1030 apply (clarsimp simp add: expand_set_eq) |
|
1031 apply (drule_tac x="scaleR r (sgn 1)" in spec) |
|
1032 apply (simp add: norm_sgn) |
|
1033 done |
|
1034 |
|
1035 lemma trivial_limit_sequentially: "\<not> trivial_limit sequentially" |
|
1036 by (auto simp add: trivial_limit_def Rep_net_sequentially) |
|
1037 |
|
1038 subsection{* Some property holds "sufficiently close" to the limit point. *} |
|
1039 |
|
1040 lemma eventually_at: (* FIXME: this replaces Limits.eventually_at *) |
|
1041 "eventually P (at a) \<longleftrightarrow> (\<exists>d>0. \<forall>x. 0 < dist x a \<and> dist x a < d \<longrightarrow> P x)" |
|
1042 unfolding eventually_at dist_nz by auto |
|
1043 |
|
1044 lemma eventually_at_infinity: |
|
1045 "eventually P at_infinity \<longleftrightarrow> (\<exists>b. \<forall>x. norm x >= b \<longrightarrow> P x)" |
|
1046 unfolding eventually_def Rep_net_at_infinity by auto |
|
1047 |
|
1048 lemma eventually_within: "eventually P (at a within S) \<longleftrightarrow> |
|
1049 (\<exists>d>0. \<forall>x\<in>S. 0 < dist x a \<and> dist x a < d \<longrightarrow> P x)" |
|
1050 unfolding eventually_within eventually_at dist_nz by auto |
|
1051 |
|
1052 lemma eventually_within_le: "eventually P (at a within S) \<longleftrightarrow> |
|
1053 (\<exists>d>0. \<forall>x\<in>S. 0 < dist x a \<and> dist x a <= d \<longrightarrow> P x)" (is "?lhs = ?rhs") |
|
1054 unfolding eventually_within |
|
1055 apply safe |
|
1056 apply (rule_tac x="d/2" in exI, simp) |
|
1057 apply (rule_tac x="d" in exI, simp) |
|
1058 done |
|
1059 |
|
1060 lemma eventually_happens: "eventually P net ==> trivial_limit net \<or> (\<exists>x. P x)" |
|
1061 unfolding eventually_def trivial_limit_def |
|
1062 using Rep_net_nonempty [of net] by auto |
|
1063 |
|
1064 lemma always_eventually: "(\<forall>x. P x) ==> eventually P net" |
|
1065 unfolding eventually_def trivial_limit_def |
|
1066 using Rep_net_nonempty [of net] by auto |
|
1067 |
|
1068 lemma trivial_limit_eventually: "trivial_limit net \<Longrightarrow> eventually P net" |
|
1069 unfolding trivial_limit_def eventually_def by auto |
|
1070 |
|
1071 lemma eventually_False: "eventually (\<lambda>x. False) net \<longleftrightarrow> trivial_limit net" |
|
1072 unfolding trivial_limit_def eventually_def by auto |
|
1073 |
|
1074 lemma trivial_limit_eq: "trivial_limit net \<longleftrightarrow> (\<forall>P. eventually P net)" |
|
1075 apply (safe elim!: trivial_limit_eventually) |
|
1076 apply (simp add: eventually_False [symmetric]) |
|
1077 done |
|
1078 |
|
1079 text{* Combining theorems for "eventually" *} |
|
1080 |
|
1081 lemma eventually_conjI: |
|
1082 "\<lbrakk>eventually (\<lambda>x. P x) net; eventually (\<lambda>x. Q x) net\<rbrakk> |
|
1083 \<Longrightarrow> eventually (\<lambda>x. P x \<and> Q x) net" |
|
1084 by (rule eventually_conj) |
|
1085 |
|
1086 lemma eventually_rev_mono: |
|
1087 "eventually P net \<Longrightarrow> (\<forall>x. P x \<longrightarrow> Q x) \<Longrightarrow> eventually Q net" |
|
1088 using eventually_mono [of P Q] by fast |
|
1089 |
|
1090 lemma eventually_and: " eventually (\<lambda>x. P x \<and> Q x) net \<longleftrightarrow> eventually P net \<and> eventually Q net" |
|
1091 by (auto intro!: eventually_conjI elim: eventually_rev_mono) |
|
1092 |
|
1093 lemma eventually_false: "eventually (\<lambda>x. False) net \<longleftrightarrow> trivial_limit net" |
|
1094 by (auto simp add: eventually_False) |
|
1095 |
|
1096 lemma not_eventually: "(\<forall>x. \<not> P x ) \<Longrightarrow> ~(trivial_limit net) ==> ~(eventually (\<lambda>x. P x) net)" |
|
1097 by (simp add: eventually_False) |
|
1098 |
|
1099 subsection{* Limits, defined as vacuously true when the limit is trivial. *} |
|
1100 |
|
1101 text{* Notation Lim to avoid collition with lim defined in analysis *} |
|
1102 definition |
|
1103 Lim :: "'a net \<Rightarrow> ('a \<Rightarrow> 'b::t2_space) \<Rightarrow> 'b" where |
|
1104 "Lim net f = (THE l. (f ---> l) net)" |
|
1105 |
|
1106 lemma Lim: |
|
1107 "(f ---> l) net \<longleftrightarrow> |
|
1108 trivial_limit net \<or> |
|
1109 (\<forall>e>0. eventually (\<lambda>x. dist (f x) l < e) net)" |
|
1110 unfolding tendsto_iff trivial_limit_eq by auto |
|
1111 |
|
1112 |
|
1113 text{* Show that they yield usual definitions in the various cases. *} |
|
1114 |
|
1115 lemma Lim_within_le: "(f ---> l)(at a within S) \<longleftrightarrow> |
|
1116 (\<forall>e>0. \<exists>d>0. \<forall>x\<in>S. 0 < dist x a \<and> dist x a <= d \<longrightarrow> dist (f x) l < e)" |
|
1117 by (auto simp add: tendsto_iff eventually_within_le) |
|
1118 |
|
1119 lemma Lim_within: "(f ---> l) (at a within S) \<longleftrightarrow> |
|
1120 (\<forall>e >0. \<exists>d>0. \<forall>x \<in> S. 0 < dist x a \<and> dist x a < d \<longrightarrow> dist (f x) l < e)" |
|
1121 by (auto simp add: tendsto_iff eventually_within) |
|
1122 |
|
1123 lemma Lim_at: "(f ---> l) (at a) \<longleftrightarrow> |
|
1124 (\<forall>e >0. \<exists>d>0. \<forall>x. 0 < dist x a \<and> dist x a < d \<longrightarrow> dist (f x) l < e)" |
|
1125 by (auto simp add: tendsto_iff eventually_at) |
|
1126 |
|
1127 lemma Lim_at_iff_LIM: "(f ---> l) (at a) \<longleftrightarrow> f -- a --> l" |
|
1128 unfolding Lim_at LIM_def by (simp only: zero_less_dist_iff) |
|
1129 |
|
1130 lemma Lim_at_infinity: |
|
1131 "(f ---> l) at_infinity \<longleftrightarrow> (\<forall>e>0. \<exists>b. \<forall>x. norm x >= b \<longrightarrow> dist (f x) l < e)" |
|
1132 by (auto simp add: tendsto_iff eventually_at_infinity) |
|
1133 |
|
1134 lemma Lim_sequentially: |
|
1135 "(S ---> l) sequentially \<longleftrightarrow> |
|
1136 (\<forall>e>0. \<exists>N. \<forall>n\<ge>N. dist (S n) l < e)" |
|
1137 by (auto simp add: tendsto_iff eventually_sequentially) |
|
1138 |
|
1139 lemma Lim_sequentially_iff_LIMSEQ: "(S ---> l) sequentially \<longleftrightarrow> S ----> l" |
|
1140 unfolding Lim_sequentially LIMSEQ_def .. |
|
1141 |
|
1142 lemma Lim_eventually: "eventually (\<lambda>x. f x = l) net \<Longrightarrow> (f ---> l) net" |
|
1143 by (rule topological_tendstoI, auto elim: eventually_rev_mono) |
|
1144 |
|
1145 text{* The expected monotonicity property. *} |
|
1146 |
|
1147 lemma Lim_within_empty: "(f ---> l) (net within {})" |
|
1148 unfolding tendsto_def Limits.eventually_within by simp |
|
1149 |
|
1150 lemma Lim_within_subset: "(f ---> l) (net within S) \<Longrightarrow> T \<subseteq> S \<Longrightarrow> (f ---> l) (net within T)" |
|
1151 unfolding tendsto_def Limits.eventually_within |
|
1152 by (auto elim!: eventually_elim1) |
|
1153 |
|
1154 lemma Lim_Un: assumes "(f ---> l) (net within S)" "(f ---> l) (net within T)" |
|
1155 shows "(f ---> l) (net within (S \<union> T))" |
|
1156 using assms unfolding tendsto_def Limits.eventually_within |
|
1157 apply clarify |
|
1158 apply (drule spec, drule (1) mp, drule (1) mp) |
|
1159 apply (drule spec, drule (1) mp, drule (1) mp) |
|
1160 apply (auto elim: eventually_elim2) |
|
1161 done |
|
1162 |
|
1163 lemma Lim_Un_univ: |
|
1164 "(f ---> l) (net within S) \<Longrightarrow> (f ---> l) (net within T) \<Longrightarrow> S \<union> T = UNIV |
|
1165 ==> (f ---> l) net" |
|
1166 by (metis Lim_Un within_UNIV) |
|
1167 |
|
1168 text{* Interrelations between restricted and unrestricted limits. *} |
|
1169 |
|
1170 lemma Lim_at_within: "(f ---> l) net ==> (f ---> l)(net within S)" |
|
1171 (* FIXME: rename *) |
|
1172 unfolding tendsto_def Limits.eventually_within |
|
1173 apply (clarify, drule spec, drule (1) mp, drule (1) mp) |
|
1174 by (auto elim!: eventually_elim1) |
|
1175 |
|
1176 lemma Lim_within_open: |
|
1177 fixes f :: "'a::topological_space \<Rightarrow> 'b::topological_space" |
|
1178 assumes"a \<in> S" "open S" |
|
1179 shows "(f ---> l)(at a within S) \<longleftrightarrow> (f ---> l)(at a)" (is "?lhs \<longleftrightarrow> ?rhs") |
|
1180 proof |
|
1181 assume ?lhs |
|
1182 { fix A assume "open A" "l \<in> A" |
|
1183 with `?lhs` have "eventually (\<lambda>x. f x \<in> A) (at a within S)" |
|
1184 by (rule topological_tendstoD) |
|
1185 hence "eventually (\<lambda>x. x \<in> S \<longrightarrow> f x \<in> A) (at a)" |
|
1186 unfolding Limits.eventually_within . |
|
1187 then obtain T where "open T" "a \<in> T" "\<forall>x\<in>T. x \<noteq> a \<longrightarrow> x \<in> S \<longrightarrow> f x \<in> A" |
|
1188 unfolding eventually_at_topological by fast |
|
1189 hence "open (T \<inter> S)" "a \<in> T \<inter> S" "\<forall>x\<in>(T \<inter> S). x \<noteq> a \<longrightarrow> f x \<in> A" |
|
1190 using assms by auto |
|
1191 hence "\<exists>T. open T \<and> a \<in> T \<and> (\<forall>x\<in>T. x \<noteq> a \<longrightarrow> f x \<in> A)" |
|
1192 by fast |
|
1193 hence "eventually (\<lambda>x. f x \<in> A) (at a)" |
|
1194 unfolding eventually_at_topological . |
|
1195 } |
|
1196 thus ?rhs by (rule topological_tendstoI) |
|
1197 next |
|
1198 assume ?rhs |
|
1199 thus ?lhs by (rule Lim_at_within) |
|
1200 qed |
|
1201 |
|
1202 text{* Another limit point characterization. *} |
|
1203 |
|
1204 lemma islimpt_sequential: |
|
1205 fixes x :: "'a::metric_space" (* FIXME: generalize to topological_space *) |
|
1206 shows "x islimpt S \<longleftrightarrow> (\<exists>f. (\<forall>n::nat. f n \<in> S -{x}) \<and> (f ---> x) sequentially)" |
|
1207 (is "?lhs = ?rhs") |
|
1208 proof |
|
1209 assume ?lhs |
|
1210 then obtain f where f:"\<forall>y. y>0 \<longrightarrow> f y \<in> S \<and> f y \<noteq> x \<and> dist (f y) x < y" |
|
1211 unfolding islimpt_approachable using choice[of "\<lambda>e y. e>0 \<longrightarrow> y\<in>S \<and> y\<noteq>x \<and> dist y x < e"] by auto |
|
1212 { fix n::nat |
|
1213 have "f (inverse (real n + 1)) \<in> S - {x}" using f by auto |
|
1214 } |
|
1215 moreover |
|
1216 { fix e::real assume "e>0" |
|
1217 hence "\<exists>N::nat. inverse (real (N + 1)) < e" using real_arch_inv[of e] apply (auto simp add: Suc_pred') apply(rule_tac x="n - 1" in exI) by auto |
|
1218 then obtain N::nat where "inverse (real (N + 1)) < e" by auto |
|
1219 hence "\<forall>n\<ge>N. inverse (real n + 1) < e" by (auto, metis Suc_le_mono le_SucE less_imp_inverse_less nat_le_real_less order_less_trans real_of_nat_Suc real_of_nat_Suc_gt_zero) |
|
1220 moreover have "\<forall>n\<ge>N. dist (f (inverse (real n + 1))) x < (inverse (real n + 1))" using f `e>0` by auto |
|
1221 ultimately have "\<exists>N::nat. \<forall>n\<ge>N. dist (f (inverse (real n + 1))) x < e" apply(rule_tac x=N in exI) apply auto apply(erule_tac x=n in allE)+ by auto |
|
1222 } |
|
1223 hence " ((\<lambda>n. f (inverse (real n + 1))) ---> x) sequentially" |
|
1224 unfolding Lim_sequentially using f by auto |
|
1225 ultimately show ?rhs apply (rule_tac x="(\<lambda>n::nat. f (inverse (real n + 1)))" in exI) by auto |
|
1226 next |
|
1227 assume ?rhs |
|
1228 then obtain f::"nat\<Rightarrow>'a" where f:"(\<forall>n. f n \<in> S - {x})" "(\<forall>e>0. \<exists>N. \<forall>n\<ge>N. dist (f n) x < e)" unfolding Lim_sequentially by auto |
|
1229 { fix e::real assume "e>0" |
|
1230 then obtain N where "dist (f N) x < e" using f(2) by auto |
|
1231 moreover have "f N\<in>S" "f N \<noteq> x" using f(1) by auto |
|
1232 ultimately have "\<exists>x'\<in>S. x' \<noteq> x \<and> dist x' x < e" by auto |
|
1233 } |
|
1234 thus ?lhs unfolding islimpt_approachable by auto |
|
1235 qed |
|
1236 |
|
1237 text{* Basic arithmetical combining theorems for limits. *} |
|
1238 |
|
1239 lemma Lim_linear: |
|
1240 assumes "(f ---> l) net" "bounded_linear h" |
|
1241 shows "((\<lambda>x. h (f x)) ---> h l) net" |
|
1242 using `bounded_linear h` `(f ---> l) net` |
|
1243 by (rule bounded_linear.tendsto) |
|
1244 |
|
1245 lemma Lim_ident_at: "((\<lambda>x. x) ---> a) (at a)" |
|
1246 unfolding tendsto_def Limits.eventually_at_topological by fast |
|
1247 |
|
1248 lemma Lim_const: "((\<lambda>x. a) ---> a) net" |
|
1249 by (rule tendsto_const) |
|
1250 |
|
1251 lemma Lim_cmul: |
|
1252 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1253 shows "(f ---> l) net ==> ((\<lambda>x. c *\<^sub>R f x) ---> c *\<^sub>R l) net" |
|
1254 by (intro tendsto_intros) |
|
1255 |
|
1256 lemma Lim_neg: |
|
1257 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1258 shows "(f ---> l) net ==> ((\<lambda>x. -(f x)) ---> -l) net" |
|
1259 by (rule tendsto_minus) |
|
1260 |
|
1261 lemma Lim_add: fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" shows |
|
1262 "(f ---> l) net \<Longrightarrow> (g ---> m) net \<Longrightarrow> ((\<lambda>x. f(x) + g(x)) ---> l + m) net" |
|
1263 by (rule tendsto_add) |
|
1264 |
|
1265 lemma Lim_sub: |
|
1266 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1267 shows "(f ---> l) net \<Longrightarrow> (g ---> m) net \<Longrightarrow> ((\<lambda>x. f(x) - g(x)) ---> l - m) net" |
|
1268 by (rule tendsto_diff) |
|
1269 |
|
1270 lemma Lim_null: |
|
1271 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1272 shows "(f ---> l) net \<longleftrightarrow> ((\<lambda>x. f(x) - l) ---> 0) net" by (simp add: Lim dist_norm) |
|
1273 |
|
1274 lemma Lim_null_norm: |
|
1275 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1276 shows "(f ---> 0) net \<longleftrightarrow> ((\<lambda>x. norm(f x)) ---> 0) net" |
|
1277 by (simp add: Lim dist_norm) |
|
1278 |
|
1279 lemma Lim_null_comparison: |
|
1280 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1281 assumes "eventually (\<lambda>x. norm (f x) \<le> g x) net" "(g ---> 0) net" |
|
1282 shows "(f ---> 0) net" |
|
1283 proof(simp add: tendsto_iff, rule+) |
|
1284 fix e::real assume "0<e" |
|
1285 { fix x |
|
1286 assume "norm (f x) \<le> g x" "dist (g x) 0 < e" |
|
1287 hence "dist (f x) 0 < e" by (simp add: dist_norm) |
|
1288 } |
|
1289 thus "eventually (\<lambda>x. dist (f x) 0 < e) net" |
|
1290 using eventually_and[of "\<lambda>x. norm(f x) <= g x" "\<lambda>x. dist (g x) 0 < e" net] |
|
1291 using eventually_mono[of "(\<lambda>x. norm (f x) \<le> g x \<and> dist (g x) 0 < e)" "(\<lambda>x. dist (f x) 0 < e)" net] |
|
1292 using assms `e>0` unfolding tendsto_iff by auto |
|
1293 qed |
|
1294 |
|
1295 lemma Lim_component: |
|
1296 fixes f :: "'a \<Rightarrow> 'b::metric_space ^ 'n::finite" |
|
1297 shows "(f ---> l) net \<Longrightarrow> ((\<lambda>a. f a $i) ---> l$i) net" |
|
1298 unfolding tendsto_iff |
|
1299 apply (clarify) |
|
1300 apply (drule spec, drule (1) mp) |
|
1301 apply (erule eventually_elim1) |
|
1302 apply (erule le_less_trans [OF dist_nth_le]) |
|
1303 done |
|
1304 |
|
1305 lemma Lim_transform_bound: |
|
1306 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1307 fixes g :: "'a \<Rightarrow> 'c::real_normed_vector" |
|
1308 assumes "eventually (\<lambda>n. norm(f n) <= norm(g n)) net" "(g ---> 0) net" |
|
1309 shows "(f ---> 0) net" |
|
1310 proof (rule tendstoI) |
|
1311 fix e::real assume "e>0" |
|
1312 { fix x |
|
1313 assume "norm (f x) \<le> norm (g x)" "dist (g x) 0 < e" |
|
1314 hence "dist (f x) 0 < e" by (simp add: dist_norm)} |
|
1315 thus "eventually (\<lambda>x. dist (f x) 0 < e) net" |
|
1316 using eventually_and[of "\<lambda>x. norm (f x) \<le> norm (g x)" "\<lambda>x. dist (g x) 0 < e" net] |
|
1317 using eventually_mono[of "\<lambda>x. norm (f x) \<le> norm (g x) \<and> dist (g x) 0 < e" "\<lambda>x. dist (f x) 0 < e" net] |
|
1318 using assms `e>0` unfolding tendsto_iff by blast |
|
1319 qed |
|
1320 |
|
1321 text{* Deducing things about the limit from the elements. *} |
|
1322 |
|
1323 lemma Lim_in_closed_set: |
|
1324 assumes "closed S" "eventually (\<lambda>x. f(x) \<in> S) net" "\<not>(trivial_limit net)" "(f ---> l) net" |
|
1325 shows "l \<in> S" |
|
1326 proof (rule ccontr) |
|
1327 assume "l \<notin> S" |
|
1328 with `closed S` have "open (- S)" "l \<in> - S" |
|
1329 by (simp_all add: open_Compl) |
|
1330 with assms(4) have "eventually (\<lambda>x. f x \<in> - S) net" |
|
1331 by (rule topological_tendstoD) |
|
1332 with assms(2) have "eventually (\<lambda>x. False) net" |
|
1333 by (rule eventually_elim2) simp |
|
1334 with assms(3) show "False" |
|
1335 by (simp add: eventually_False) |
|
1336 qed |
|
1337 |
|
1338 text{* Need to prove closed(cball(x,e)) before deducing this as a corollary. *} |
|
1339 |
|
1340 lemma Lim_dist_ubound: |
|
1341 assumes "\<not>(trivial_limit net)" "(f ---> l) net" "eventually (\<lambda>x. dist a (f x) <= e) net" |
|
1342 shows "dist a l <= e" |
|
1343 proof (rule ccontr) |
|
1344 assume "\<not> dist a l \<le> e" |
|
1345 then have "0 < dist a l - e" by simp |
|
1346 with assms(2) have "eventually (\<lambda>x. dist (f x) l < dist a l - e) net" |
|
1347 by (rule tendstoD) |
|
1348 with assms(3) have "eventually (\<lambda>x. dist a (f x) \<le> e \<and> dist (f x) l < dist a l - e) net" |
|
1349 by (rule eventually_conjI) |
|
1350 then obtain w where "dist a (f w) \<le> e" "dist (f w) l < dist a l - e" |
|
1351 using assms(1) eventually_happens by auto |
|
1352 hence "dist a (f w) + dist (f w) l < e + (dist a l - e)" |
|
1353 by (rule add_le_less_mono) |
|
1354 hence "dist a (f w) + dist (f w) l < dist a l" |
|
1355 by simp |
|
1356 also have "\<dots> \<le> dist a (f w) + dist (f w) l" |
|
1357 by (rule dist_triangle) |
|
1358 finally show False by simp |
|
1359 qed |
|
1360 |
|
1361 lemma Lim_norm_ubound: |
|
1362 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1363 assumes "\<not>(trivial_limit net)" "(f ---> l) net" "eventually (\<lambda>x. norm(f x) <= e) net" |
|
1364 shows "norm(l) <= e" |
|
1365 proof (rule ccontr) |
|
1366 assume "\<not> norm l \<le> e" |
|
1367 then have "0 < norm l - e" by simp |
|
1368 with assms(2) have "eventually (\<lambda>x. dist (f x) l < norm l - e) net" |
|
1369 by (rule tendstoD) |
|
1370 with assms(3) have "eventually (\<lambda>x. norm (f x) \<le> e \<and> dist (f x) l < norm l - e) net" |
|
1371 by (rule eventually_conjI) |
|
1372 then obtain w where "norm (f w) \<le> e" "dist (f w) l < norm l - e" |
|
1373 using assms(1) eventually_happens by auto |
|
1374 hence "norm (f w - l) < norm l - e" "norm (f w) \<le> e" by (simp_all add: dist_norm) |
|
1375 hence "norm (f w - l) + norm (f w) < norm l" by simp |
|
1376 hence "norm (f w - l - f w) < norm l" by (rule le_less_trans [OF norm_triangle_ineq4]) |
|
1377 thus False using `\<not> norm l \<le> e` by simp |
|
1378 qed |
|
1379 |
|
1380 lemma Lim_norm_lbound: |
|
1381 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1382 assumes "\<not> (trivial_limit net)" "(f ---> l) net" "eventually (\<lambda>x. e <= norm(f x)) net" |
|
1383 shows "e \<le> norm l" |
|
1384 proof (rule ccontr) |
|
1385 assume "\<not> e \<le> norm l" |
|
1386 then have "0 < e - norm l" by simp |
|
1387 with assms(2) have "eventually (\<lambda>x. dist (f x) l < e - norm l) net" |
|
1388 by (rule tendstoD) |
|
1389 with assms(3) have "eventually (\<lambda>x. e \<le> norm (f x) \<and> dist (f x) l < e - norm l) net" |
|
1390 by (rule eventually_conjI) |
|
1391 then obtain w where "e \<le> norm (f w)" "dist (f w) l < e - norm l" |
|
1392 using assms(1) eventually_happens by auto |
|
1393 hence "norm (f w - l) + norm l < e" "e \<le> norm (f w)" by (simp_all add: dist_norm) |
|
1394 hence "norm (f w - l) + norm l < norm (f w)" by (rule less_le_trans) |
|
1395 hence "norm (f w - l + l) < norm (f w)" by (rule le_less_trans [OF norm_triangle_ineq]) |
|
1396 thus False by simp |
|
1397 qed |
|
1398 |
|
1399 text{* Uniqueness of the limit, when nontrivial. *} |
|
1400 |
|
1401 lemma Lim_unique: |
|
1402 fixes f :: "'a \<Rightarrow> 'b::t2_space" |
|
1403 assumes "\<not> trivial_limit net" "(f ---> l) net" "(f ---> l') net" |
|
1404 shows "l = l'" |
|
1405 proof (rule ccontr) |
|
1406 assume "l \<noteq> l'" |
|
1407 obtain U V where "open U" "open V" "l \<in> U" "l' \<in> V" "U \<inter> V = {}" |
|
1408 using hausdorff [OF `l \<noteq> l'`] by fast |
|
1409 have "eventually (\<lambda>x. f x \<in> U) net" |
|
1410 using `(f ---> l) net` `open U` `l \<in> U` by (rule topological_tendstoD) |
|
1411 moreover |
|
1412 have "eventually (\<lambda>x. f x \<in> V) net" |
|
1413 using `(f ---> l') net` `open V` `l' \<in> V` by (rule topological_tendstoD) |
|
1414 ultimately |
|
1415 have "eventually (\<lambda>x. False) net" |
|
1416 proof (rule eventually_elim2) |
|
1417 fix x |
|
1418 assume "f x \<in> U" "f x \<in> V" |
|
1419 hence "f x \<in> U \<inter> V" by simp |
|
1420 with `U \<inter> V = {}` show "False" by simp |
|
1421 qed |
|
1422 with `\<not> trivial_limit net` show "False" |
|
1423 by (simp add: eventually_False) |
|
1424 qed |
|
1425 |
|
1426 lemma tendsto_Lim: |
|
1427 fixes f :: "'a \<Rightarrow> 'b::t2_space" |
|
1428 shows "~(trivial_limit net) \<Longrightarrow> (f ---> l) net ==> Lim net f = l" |
|
1429 unfolding Lim_def using Lim_unique[of net f] by auto |
|
1430 |
|
1431 text{* Limit under bilinear function *} |
|
1432 |
|
1433 lemma Lim_bilinear: |
|
1434 assumes "(f ---> l) net" and "(g ---> m) net" and "bounded_bilinear h" |
|
1435 shows "((\<lambda>x. h (f x) (g x)) ---> (h l m)) net" |
|
1436 using `bounded_bilinear h` `(f ---> l) net` `(g ---> m) net` |
|
1437 by (rule bounded_bilinear.tendsto) |
|
1438 |
|
1439 text{* These are special for limits out of the same vector space. *} |
|
1440 |
|
1441 lemma Lim_within_id: "(id ---> a) (at a within s)" |
|
1442 unfolding tendsto_def Limits.eventually_within eventually_at_topological |
|
1443 by auto |
|
1444 |
|
1445 lemma Lim_at_id: "(id ---> a) (at a)" |
|
1446 apply (subst within_UNIV[symmetric]) by (simp add: Lim_within_id) |
|
1447 |
|
1448 lemma Lim_at_zero: |
|
1449 fixes a :: "'a::real_normed_vector" |
|
1450 fixes l :: "'b::topological_space" |
|
1451 shows "(f ---> l) (at a) \<longleftrightarrow> ((\<lambda>x. f(a + x)) ---> l) (at 0)" (is "?lhs = ?rhs") |
|
1452 proof |
|
1453 assume "?lhs" |
|
1454 { fix S assume "open S" "l \<in> S" |
|
1455 with `?lhs` have "eventually (\<lambda>x. f x \<in> S) (at a)" |
|
1456 by (rule topological_tendstoD) |
|
1457 then obtain d where d: "d>0" "\<forall>x. x \<noteq> a \<and> dist x a < d \<longrightarrow> f x \<in> S" |
|
1458 unfolding Limits.eventually_at by fast |
|
1459 { fix x::"'a" assume "x \<noteq> 0 \<and> dist x 0 < d" |
|
1460 hence "f (a + x) \<in> S" using d |
|
1461 apply(erule_tac x="x+a" in allE) |
|
1462 by(auto simp add: comm_monoid_add.mult_commute dist_norm dist_commute) |
|
1463 } |
|
1464 hence "\<exists>d>0. \<forall>x. x \<noteq> 0 \<and> dist x 0 < d \<longrightarrow> f (a + x) \<in> S" |
|
1465 using d(1) by auto |
|
1466 hence "eventually (\<lambda>x. f (a + x) \<in> S) (at 0)" |
|
1467 unfolding Limits.eventually_at . |
|
1468 } |
|
1469 thus "?rhs" by (rule topological_tendstoI) |
|
1470 next |
|
1471 assume "?rhs" |
|
1472 { fix S assume "open S" "l \<in> S" |
|
1473 with `?rhs` have "eventually (\<lambda>x. f (a + x) \<in> S) (at 0)" |
|
1474 by (rule topological_tendstoD) |
|
1475 then obtain d where d: "d>0" "\<forall>x. x \<noteq> 0 \<and> dist x 0 < d \<longrightarrow> f (a + x) \<in> S" |
|
1476 unfolding Limits.eventually_at by fast |
|
1477 { fix x::"'a" assume "x \<noteq> a \<and> dist x a < d" |
|
1478 hence "f x \<in> S" using d apply(erule_tac x="x-a" in allE) |
|
1479 by(auto simp add: comm_monoid_add.mult_commute dist_norm dist_commute) |
|
1480 } |
|
1481 hence "\<exists>d>0. \<forall>x. x \<noteq> a \<and> dist x a < d \<longrightarrow> f x \<in> S" using d(1) by auto |
|
1482 hence "eventually (\<lambda>x. f x \<in> S) (at a)" unfolding Limits.eventually_at . |
|
1483 } |
|
1484 thus "?lhs" by (rule topological_tendstoI) |
|
1485 qed |
|
1486 |
|
1487 text{* It's also sometimes useful to extract the limit point from the net. *} |
|
1488 |
|
1489 definition |
|
1490 netlimit :: "'a::t2_space net \<Rightarrow> 'a" where |
|
1491 "netlimit net = (SOME a. ((\<lambda>x. x) ---> a) net)" |
|
1492 |
|
1493 lemma netlimit_within: |
|
1494 assumes "\<not> trivial_limit (at a within S)" |
|
1495 shows "netlimit (at a within S) = a" |
|
1496 unfolding netlimit_def |
|
1497 apply (rule some_equality) |
|
1498 apply (rule Lim_at_within) |
|
1499 apply (rule Lim_ident_at) |
|
1500 apply (erule Lim_unique [OF assms]) |
|
1501 apply (rule Lim_at_within) |
|
1502 apply (rule Lim_ident_at) |
|
1503 done |
|
1504 |
|
1505 lemma netlimit_at: |
|
1506 fixes a :: "'a::perfect_space" |
|
1507 shows "netlimit (at a) = a" |
|
1508 apply (subst within_UNIV[symmetric]) |
|
1509 using netlimit_within[of a UNIV] |
|
1510 by (simp add: trivial_limit_at within_UNIV) |
|
1511 |
|
1512 text{* Transformation of limit. *} |
|
1513 |
|
1514 lemma Lim_transform: |
|
1515 fixes f g :: "'a::type \<Rightarrow> 'b::real_normed_vector" |
|
1516 assumes "((\<lambda>x. f x - g x) ---> 0) net" "(f ---> l) net" |
|
1517 shows "(g ---> l) net" |
|
1518 proof- |
|
1519 from assms have "((\<lambda>x. f x - g x - f x) ---> 0 - l) net" using Lim_sub[of "\<lambda>x. f x - g x" 0 net f l] by auto |
|
1520 thus "?thesis" using Lim_neg [of "\<lambda> x. - g x" "-l" net] by auto |
|
1521 qed |
|
1522 |
|
1523 lemma Lim_transform_eventually: |
|
1524 "eventually (\<lambda>x. f x = g x) net \<Longrightarrow> (f ---> l) net ==> (g ---> l) net" |
|
1525 apply (rule topological_tendstoI) |
|
1526 apply (drule (2) topological_tendstoD) |
|
1527 apply (erule (1) eventually_elim2, simp) |
|
1528 done |
|
1529 |
|
1530 lemma Lim_transform_within: |
|
1531 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1532 assumes "0 < d" "(\<forall>x'\<in>S. 0 < dist x' x \<and> dist x' x < d \<longrightarrow> f x' = g x')" |
|
1533 "(f ---> l) (at x within S)" |
|
1534 shows "(g ---> l) (at x within S)" |
|
1535 using assms(1,3) unfolding Lim_within |
|
1536 apply - |
|
1537 apply (clarify, rename_tac e) |
|
1538 apply (drule_tac x=e in spec, clarsimp, rename_tac r) |
|
1539 apply (rule_tac x="min d r" in exI, clarsimp, rename_tac y) |
|
1540 apply (drule_tac x=y in bspec, assumption, clarsimp) |
|
1541 apply (simp add: assms(2)) |
|
1542 done |
|
1543 |
|
1544 lemma Lim_transform_at: |
|
1545 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1546 shows "0 < d \<Longrightarrow> (\<forall>x'. 0 < dist x' x \<and> dist x' x < d \<longrightarrow> f x' = g x') \<Longrightarrow> |
|
1547 (f ---> l) (at x) ==> (g ---> l) (at x)" |
|
1548 apply (subst within_UNIV[symmetric]) |
|
1549 using Lim_transform_within[of d UNIV x f g l] |
|
1550 by (auto simp add: within_UNIV) |
|
1551 |
|
1552 text{* Common case assuming being away from some crucial point like 0. *} |
|
1553 |
|
1554 lemma Lim_transform_away_within: |
|
1555 fixes a b :: "'a::metric_space" |
|
1556 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1557 assumes "a\<noteq>b" "\<forall>x\<in> S. x \<noteq> a \<and> x \<noteq> b \<longrightarrow> f x = g x" |
|
1558 and "(f ---> l) (at a within S)" |
|
1559 shows "(g ---> l) (at a within S)" |
|
1560 proof- |
|
1561 have "\<forall>x'\<in>S. 0 < dist x' a \<and> dist x' a < dist a b \<longrightarrow> f x' = g x'" using assms(2) |
|
1562 apply auto apply(erule_tac x=x' in ballE) by (auto simp add: dist_commute) |
|
1563 thus ?thesis using Lim_transform_within[of "dist a b" S a f g l] using assms(1,3) unfolding dist_nz by auto |
|
1564 qed |
|
1565 |
|
1566 lemma Lim_transform_away_at: |
|
1567 fixes a b :: "'a::metric_space" |
|
1568 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1569 assumes ab: "a\<noteq>b" and fg: "\<forall>x. x \<noteq> a \<and> x \<noteq> b \<longrightarrow> f x = g x" |
|
1570 and fl: "(f ---> l) (at a)" |
|
1571 shows "(g ---> l) (at a)" |
|
1572 using Lim_transform_away_within[OF ab, of UNIV f g l] fg fl |
|
1573 by (auto simp add: within_UNIV) |
|
1574 |
|
1575 text{* Alternatively, within an open set. *} |
|
1576 |
|
1577 lemma Lim_transform_within_open: |
|
1578 fixes a :: "'a::metric_space" |
|
1579 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1580 assumes "open S" "a \<in> S" "\<forall>x\<in>S. x \<noteq> a \<longrightarrow> f x = g x" "(f ---> l) (at a)" |
|
1581 shows "(g ---> l) (at a)" |
|
1582 proof- |
|
1583 from assms(1,2) obtain e::real where "e>0" and e:"ball a e \<subseteq> S" unfolding open_contains_ball by auto |
|
1584 hence "\<forall>x'. 0 < dist x' a \<and> dist x' a < e \<longrightarrow> f x' = g x'" using assms(3) |
|
1585 unfolding ball_def subset_eq apply auto apply(erule_tac x=x' in allE) apply(erule_tac x=x' in ballE) by(auto simp add: dist_commute) |
|
1586 thus ?thesis using Lim_transform_at[of e a f g l] `e>0` assms(4) by auto |
|
1587 qed |
|
1588 |
|
1589 text{* A congruence rule allowing us to transform limits assuming not at point. *} |
|
1590 |
|
1591 (* FIXME: Only one congruence rule for tendsto can be used at a time! *) |
|
1592 |
|
1593 lemma Lim_cong_within[cong add]: |
|
1594 fixes a :: "'a::metric_space" |
|
1595 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1596 shows "(\<And>x. x \<noteq> a \<Longrightarrow> f x = g x) ==> ((\<lambda>x. f x) ---> l) (at a within S) \<longleftrightarrow> ((g ---> l) (at a within S))" |
|
1597 by (simp add: Lim_within dist_nz[symmetric]) |
|
1598 |
|
1599 lemma Lim_cong_at[cong add]: |
|
1600 fixes a :: "'a::metric_space" |
|
1601 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1602 shows "(\<And>x. x \<noteq> a ==> f x = g x) ==> (((\<lambda>x. f x) ---> l) (at a) \<longleftrightarrow> ((g ---> l) (at a)))" |
|
1603 by (simp add: Lim_at dist_nz[symmetric]) |
|
1604 |
|
1605 text{* Useful lemmas on closure and set of possible sequential limits.*} |
|
1606 |
|
1607 lemma closure_sequential: |
|
1608 fixes l :: "'a::metric_space" (* TODO: generalize *) |
|
1609 shows "l \<in> closure S \<longleftrightarrow> (\<exists>x. (\<forall>n. x n \<in> S) \<and> (x ---> l) sequentially)" (is "?lhs = ?rhs") |
|
1610 proof |
|
1611 assume "?lhs" moreover |
|
1612 { assume "l \<in> S" |
|
1613 hence "?rhs" using Lim_const[of l sequentially] by auto |
|
1614 } moreover |
|
1615 { assume "l islimpt S" |
|
1616 hence "?rhs" unfolding islimpt_sequential by auto |
|
1617 } ultimately |
|
1618 show "?rhs" unfolding closure_def by auto |
|
1619 next |
|
1620 assume "?rhs" |
|
1621 thus "?lhs" unfolding closure_def unfolding islimpt_sequential by auto |
|
1622 qed |
|
1623 |
|
1624 lemma closed_sequential_limits: |
|
1625 fixes S :: "'a::metric_space set" |
|
1626 shows "closed S \<longleftrightarrow> (\<forall>x l. (\<forall>n. x n \<in> S) \<and> (x ---> l) sequentially \<longrightarrow> l \<in> S)" |
|
1627 unfolding closed_limpt |
|
1628 using closure_sequential [where 'a='a] closure_closed [where 'a='a] closed_limpt [where 'a='a] islimpt_sequential [where 'a='a] mem_delete [where 'a='a] |
|
1629 by metis |
|
1630 |
|
1631 lemma closure_approachable: |
|
1632 fixes S :: "'a::metric_space set" |
|
1633 shows "x \<in> closure S \<longleftrightarrow> (\<forall>e>0. \<exists>y\<in>S. dist y x < e)" |
|
1634 apply (auto simp add: closure_def islimpt_approachable) |
|
1635 by (metis dist_self) |
|
1636 |
|
1637 lemma closed_approachable: |
|
1638 fixes S :: "'a::metric_space set" |
|
1639 shows "closed S ==> (\<forall>e>0. \<exists>y\<in>S. dist y x < e) \<longleftrightarrow> x \<in> S" |
|
1640 by (metis closure_closed closure_approachable) |
|
1641 |
|
1642 text{* Some other lemmas about sequences. *} |
|
1643 |
|
1644 lemma seq_offset: |
|
1645 fixes l :: "'a::metric_space" (* TODO: generalize *) |
|
1646 shows "(f ---> l) sequentially ==> ((\<lambda>i. f( i + k)) ---> l) sequentially" |
|
1647 apply (auto simp add: Lim_sequentially) |
|
1648 by (metis trans_le_add1 ) |
|
1649 |
|
1650 lemma seq_offset_neg: |
|
1651 "(f ---> l) sequentially ==> ((\<lambda>i. f(i - k)) ---> l) sequentially" |
|
1652 apply (rule topological_tendstoI) |
|
1653 apply (drule (2) topological_tendstoD) |
|
1654 apply (simp only: eventually_sequentially) |
|
1655 apply (subgoal_tac "\<And>N k (n::nat). N + k <= n ==> N <= n - k") |
|
1656 apply metis |
|
1657 by arith |
|
1658 |
|
1659 lemma seq_offset_rev: |
|
1660 "((\<lambda>i. f(i + k)) ---> l) sequentially ==> (f ---> l) sequentially" |
|
1661 apply (rule topological_tendstoI) |
|
1662 apply (drule (2) topological_tendstoD) |
|
1663 apply (simp only: eventually_sequentially) |
|
1664 apply (subgoal_tac "\<And>N k (n::nat). N + k <= n ==> N <= n - k \<and> (n - k) + k = n") |
|
1665 by metis arith |
|
1666 |
|
1667 lemma seq_harmonic: "((\<lambda>n. inverse (real n)) ---> 0) sequentially" |
|
1668 proof- |
|
1669 { fix e::real assume "e>0" |
|
1670 hence "\<exists>N::nat. \<forall>n::nat\<ge>N. inverse (real n) < e" |
|
1671 using real_arch_inv[of e] apply auto apply(rule_tac x=n in exI) |
|
1672 by (metis not_le le_imp_inverse_le not_less real_of_nat_gt_zero_cancel_iff real_of_nat_less_iff xt1(7)) |
|
1673 } |
|
1674 thus ?thesis unfolding Lim_sequentially dist_norm by simp |
|
1675 qed |
|
1676 |
|
1677 text{* More properties of closed balls. *} |
|
1678 |
|
1679 lemma closed_cball: "closed (cball x e)" |
|
1680 unfolding cball_def closed_def |
|
1681 unfolding Collect_neg_eq [symmetric] not_le |
|
1682 apply (clarsimp simp add: open_dist, rename_tac y) |
|
1683 apply (rule_tac x="dist x y - e" in exI, clarsimp) |
|
1684 apply (rename_tac x') |
|
1685 apply (cut_tac x=x and y=x' and z=y in dist_triangle) |
|
1686 apply simp |
|
1687 done |
|
1688 |
|
1689 lemma open_contains_cball: "open S \<longleftrightarrow> (\<forall>x\<in>S. \<exists>e>0. cball x e \<subseteq> S)" |
|
1690 proof- |
|
1691 { fix x and e::real assume "x\<in>S" "e>0" "ball x e \<subseteq> S" |
|
1692 hence "\<exists>d>0. cball x d \<subseteq> S" unfolding subset_eq by (rule_tac x="e/2" in exI, auto) |
|
1693 } moreover |
|
1694 { fix x and e::real assume "x\<in>S" "e>0" "cball x e \<subseteq> S" |
|
1695 hence "\<exists>d>0. ball x d \<subseteq> S" unfolding subset_eq apply(rule_tac x="e/2" in exI) by auto |
|
1696 } ultimately |
|
1697 show ?thesis unfolding open_contains_ball by auto |
|
1698 qed |
|
1699 |
|
1700 lemma open_contains_cball_eq: "open S ==> (\<forall>x. x \<in> S \<longleftrightarrow> (\<exists>e>0. cball x e \<subseteq> S))" |
|
1701 by (metis open_contains_cball subset_eq order_less_imp_le centre_in_cball mem_def) |
|
1702 |
|
1703 lemma mem_interior_cball: "x \<in> interior S \<longleftrightarrow> (\<exists>e>0. cball x e \<subseteq> S)" |
|
1704 apply (simp add: interior_def, safe) |
|
1705 apply (force simp add: open_contains_cball) |
|
1706 apply (rule_tac x="ball x e" in exI) |
|
1707 apply (simp add: open_ball centre_in_ball subset_trans [OF ball_subset_cball]) |
|
1708 done |
|
1709 |
|
1710 lemma islimpt_ball: |
|
1711 fixes x y :: "'a::{real_normed_vector,perfect_space}" |
|
1712 shows "y islimpt ball x e \<longleftrightarrow> 0 < e \<and> y \<in> cball x e" (is "?lhs = ?rhs") |
|
1713 proof |
|
1714 assume "?lhs" |
|
1715 { assume "e \<le> 0" |
|
1716 hence *:"ball x e = {}" using ball_eq_empty[of x e] by auto |
|
1717 have False using `?lhs` unfolding * using islimpt_EMPTY[of y] by auto |
|
1718 } |
|
1719 hence "e > 0" by (metis not_less) |
|
1720 moreover |
|
1721 have "y \<in> cball x e" using closed_cball[of x e] islimpt_subset[of y "ball x e" "cball x e"] ball_subset_cball[of x e] `?lhs` unfolding closed_limpt by auto |
|
1722 ultimately show "?rhs" by auto |
|
1723 next |
|
1724 assume "?rhs" hence "e>0" by auto |
|
1725 { fix d::real assume "d>0" |
|
1726 have "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1727 proof(cases "d \<le> dist x y") |
|
1728 case True thus "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1729 proof(cases "x=y") |
|
1730 case True hence False using `d \<le> dist x y` `d>0` by auto |
|
1731 thus "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" by auto |
|
1732 next |
|
1733 case False |
|
1734 |
|
1735 have "dist x (y - (d / (2 * dist y x)) *\<^sub>R (y - x)) |
|
1736 = norm (x - y + (d / (2 * norm (y - x))) *\<^sub>R (y - x))" |
|
1737 unfolding mem_cball mem_ball dist_norm diff_diff_eq2 diff_add_eq[THEN sym] by auto |
|
1738 also have "\<dots> = \<bar>- 1 + d / (2 * norm (x - y))\<bar> * norm (x - y)" |
|
1739 using scaleR_left_distrib[of "- 1" "d / (2 * norm (y - x))", THEN sym, of "y - x"] |
|
1740 unfolding scaleR_minus_left scaleR_one |
|
1741 by (auto simp add: norm_minus_commute) |
|
1742 also have "\<dots> = \<bar>- norm (x - y) + d / 2\<bar>" |
|
1743 unfolding abs_mult_pos[of "norm (x - y)", OF norm_ge_zero[of "x - y"]] |
|
1744 unfolding real_add_mult_distrib using `x\<noteq>y`[unfolded dist_nz, unfolded dist_norm] by auto |
|
1745 also have "\<dots> \<le> e - d/2" using `d \<le> dist x y` and `d>0` and `?rhs` by(auto simp add: dist_norm) |
|
1746 finally have "y - (d / (2 * dist y x)) *\<^sub>R (y - x) \<in> ball x e" using `d>0` by auto |
|
1747 |
|
1748 moreover |
|
1749 |
|
1750 have "(d / (2*dist y x)) *\<^sub>R (y - x) \<noteq> 0" |
|
1751 using `x\<noteq>y`[unfolded dist_nz] `d>0` unfolding scaleR_eq_0_iff by (auto simp add: dist_commute) |
|
1752 moreover |
|
1753 have "dist (y - (d / (2 * dist y x)) *\<^sub>R (y - x)) y < d" unfolding dist_norm apply simp unfolding norm_minus_cancel |
|
1754 using `d>0` `x\<noteq>y`[unfolded dist_nz] dist_commute[of x y] |
|
1755 unfolding dist_norm by auto |
|
1756 ultimately show "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" by (rule_tac x="y - (d / (2*dist y x)) *\<^sub>R (y - x)" in bexI) auto |
|
1757 qed |
|
1758 next |
|
1759 case False hence "d > dist x y" by auto |
|
1760 show "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1761 proof(cases "x=y") |
|
1762 case True |
|
1763 obtain z where **: "z \<noteq> y" "dist z y < min e d" |
|
1764 using perfect_choose_dist[of "min e d" y] |
|
1765 using `d > 0` `e>0` by auto |
|
1766 show "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1767 unfolding `x = y` |
|
1768 using `z \<noteq> y` ** |
|
1769 by (rule_tac x=z in bexI, auto simp add: dist_commute) |
|
1770 next |
|
1771 case False thus "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1772 using `d>0` `d > dist x y` `?rhs` by(rule_tac x=x in bexI, auto) |
|
1773 qed |
|
1774 qed } |
|
1775 thus "?lhs" unfolding mem_cball islimpt_approachable mem_ball by auto |
|
1776 qed |
|
1777 |
|
1778 lemma closure_ball_lemma: |
|
1779 fixes x y :: "'a::real_normed_vector" |
|
1780 assumes "x \<noteq> y" shows "y islimpt ball x (dist x y)" |
|
1781 proof (rule islimptI) |
|
1782 fix T assume "y \<in> T" "open T" |
|
1783 then obtain r where "0 < r" "\<forall>z. dist z y < r \<longrightarrow> z \<in> T" |
|
1784 unfolding open_dist by fast |
|
1785 (* choose point between x and y, within distance r of y. *) |
|
1786 def k \<equiv> "min 1 (r / (2 * dist x y))" |
|
1787 def z \<equiv> "y + scaleR k (x - y)" |
|
1788 have z_def2: "z = x + scaleR (1 - k) (y - x)" |
|
1789 unfolding z_def by (simp add: algebra_simps) |
|
1790 have "dist z y < r" |
|
1791 unfolding z_def k_def using `0 < r` |
|
1792 by (simp add: dist_norm min_def) |
|
1793 hence "z \<in> T" using `\<forall>z. dist z y < r \<longrightarrow> z \<in> T` by simp |
|
1794 have "dist x z < dist x y" |
|
1795 unfolding z_def2 dist_norm |
|
1796 apply (simp add: norm_minus_commute) |
|
1797 apply (simp only: dist_norm [symmetric]) |
|
1798 apply (subgoal_tac "\<bar>1 - k\<bar> * dist x y < 1 * dist x y", simp) |
|
1799 apply (rule mult_strict_right_mono) |
|
1800 apply (simp add: k_def divide_pos_pos zero_less_dist_iff `0 < r` `x \<noteq> y`) |
|
1801 apply (simp add: zero_less_dist_iff `x \<noteq> y`) |
|
1802 done |
|
1803 hence "z \<in> ball x (dist x y)" by simp |
|
1804 have "z \<noteq> y" |
|
1805 unfolding z_def k_def using `x \<noteq> y` `0 < r` |
|
1806 by (simp add: min_def) |
|
1807 show "\<exists>z\<in>ball x (dist x y). z \<in> T \<and> z \<noteq> y" |
|
1808 using `z \<in> ball x (dist x y)` `z \<in> T` `z \<noteq> y` |
|
1809 by fast |
|
1810 qed |
|
1811 |
|
1812 lemma closure_ball: |
|
1813 fixes x :: "'a::real_normed_vector" |
|
1814 shows "0 < e \<Longrightarrow> closure (ball x e) = cball x e" |
|
1815 apply (rule equalityI) |
|
1816 apply (rule closure_minimal) |
|
1817 apply (rule ball_subset_cball) |
|
1818 apply (rule closed_cball) |
|
1819 apply (rule subsetI, rename_tac y) |
|
1820 apply (simp add: le_less [where 'a=real]) |
|
1821 apply (erule disjE) |
|
1822 apply (rule subsetD [OF closure_subset], simp) |
|
1823 apply (simp add: closure_def) |
|
1824 apply clarify |
|
1825 apply (rule closure_ball_lemma) |
|
1826 apply (simp add: zero_less_dist_iff) |
|
1827 done |
|
1828 |
|
1829 (* In a trivial vector space, this fails for e = 0. *) |
|
1830 lemma interior_cball: |
|
1831 fixes x :: "'a::{real_normed_vector, perfect_space}" |
|
1832 shows "interior (cball x e) = ball x e" |
|
1833 proof(cases "e\<ge>0") |
|
1834 case False note cs = this |
|
1835 from cs have "ball x e = {}" using ball_empty[of e x] by auto moreover |
|
1836 { fix y assume "y \<in> cball x e" |
|
1837 hence False unfolding mem_cball using dist_nz[of x y] cs by auto } |
|
1838 hence "cball x e = {}" by auto |
|
1839 hence "interior (cball x e) = {}" using interior_empty by auto |
|
1840 ultimately show ?thesis by blast |
|
1841 next |
|
1842 case True note cs = this |
|
1843 have "ball x e \<subseteq> cball x e" using ball_subset_cball by auto moreover |
|
1844 { fix S y assume as: "S \<subseteq> cball x e" "open S" "y\<in>S" |
|
1845 then obtain d where "d>0" and d:"\<forall>x'. dist x' y < d \<longrightarrow> x' \<in> S" unfolding open_dist by blast |
|
1846 |
|
1847 then obtain xa where xa_y: "xa \<noteq> y" and xa: "dist xa y < d" |
|
1848 using perfect_choose_dist [of d] by auto |
|
1849 have "xa\<in>S" using d[THEN spec[where x=xa]] using xa by(auto simp add: dist_commute) |
|
1850 hence xa_cball:"xa \<in> cball x e" using as(1) by auto |
|
1851 |
|
1852 hence "y \<in> ball x e" proof(cases "x = y") |
|
1853 case True |
|
1854 hence "e>0" using xa_y[unfolded dist_nz] xa_cball[unfolded mem_cball] by (auto simp add: dist_commute) |
|
1855 thus "y \<in> ball x e" using `x = y ` by simp |
|
1856 next |
|
1857 case False |
|
1858 have "dist (y + (d / 2 / dist y x) *\<^sub>R (y - x)) y < d" unfolding dist_norm |
|
1859 using `d>0` norm_ge_zero[of "y - x"] `x \<noteq> y` by auto |
|
1860 hence *:"y + (d / 2 / dist y x) *\<^sub>R (y - x) \<in> cball x e" using d as(1)[unfolded subset_eq] by blast |
|
1861 have "y - x \<noteq> 0" using `x \<noteq> y` by auto |
|
1862 hence **:"d / (2 * norm (y - x)) > 0" unfolding zero_less_norm_iff[THEN sym] |
|
1863 using `d>0` divide_pos_pos[of d "2*norm (y - x)"] by auto |
|
1864 |
|
1865 have "dist (y + (d / 2 / dist y x) *\<^sub>R (y - x)) x = norm (y + (d / (2 * norm (y - x))) *\<^sub>R y - (d / (2 * norm (y - x))) *\<^sub>R x - x)" |
|
1866 by (auto simp add: dist_norm algebra_simps) |
|
1867 also have "\<dots> = norm ((1 + d / (2 * norm (y - x))) *\<^sub>R (y - x))" |
|
1868 by (auto simp add: algebra_simps) |
|
1869 also have "\<dots> = \<bar>1 + d / (2 * norm (y - x))\<bar> * norm (y - x)" |
|
1870 using ** by auto |
|
1871 also have "\<dots> = (dist y x) + d/2"using ** by (auto simp add: left_distrib dist_norm) |
|
1872 finally have "e \<ge> dist x y +d/2" using *[unfolded mem_cball] by (auto simp add: dist_commute) |
|
1873 thus "y \<in> ball x e" unfolding mem_ball using `d>0` by auto |
|
1874 qed } |
|
1875 hence "\<forall>S \<subseteq> cball x e. open S \<longrightarrow> S \<subseteq> ball x e" by auto |
|
1876 ultimately show ?thesis using interior_unique[of "ball x e" "cball x e"] using open_ball[of x e] by auto |
|
1877 qed |
|
1878 |
|
1879 lemma frontier_ball: |
|
1880 fixes a :: "'a::real_normed_vector" |
|
1881 shows "0 < e ==> frontier(ball a e) = {x. dist a x = e}" |
|
1882 apply (simp add: frontier_def closure_ball interior_open open_ball order_less_imp_le) |
|
1883 apply (simp add: expand_set_eq) |
|
1884 by arith |
|
1885 |
|
1886 lemma frontier_cball: |
|
1887 fixes a :: "'a::{real_normed_vector, perfect_space}" |
|
1888 shows "frontier(cball a e) = {x. dist a x = e}" |
|
1889 apply (simp add: frontier_def interior_cball closed_cball closure_closed order_less_imp_le) |
|
1890 apply (simp add: expand_set_eq) |
|
1891 by arith |
|
1892 |
|
1893 lemma cball_eq_empty: "(cball x e = {}) \<longleftrightarrow> e < 0" |
|
1894 apply (simp add: expand_set_eq not_le) |
|
1895 by (metis zero_le_dist dist_self order_less_le_trans) |
|
1896 lemma cball_empty: "e < 0 ==> cball x e = {}" by (simp add: cball_eq_empty) |
|
1897 |
|
1898 lemma cball_eq_sing: |
|
1899 fixes x :: "'a::perfect_space" |
|
1900 shows "(cball x e = {x}) \<longleftrightarrow> e = 0" |
|
1901 proof (rule linorder_cases) |
|
1902 assume e: "0 < e" |
|
1903 obtain a where "a \<noteq> x" "dist a x < e" |
|
1904 using perfect_choose_dist [OF e] by auto |
|
1905 hence "a \<noteq> x" "dist x a \<le> e" by (auto simp add: dist_commute) |
|
1906 with e show ?thesis by (auto simp add: expand_set_eq) |
|
1907 qed auto |
|
1908 |
|
1909 lemma cball_sing: |
|
1910 fixes x :: "'a::metric_space" |
|
1911 shows "e = 0 ==> cball x e = {x}" |
|
1912 by (auto simp add: expand_set_eq) |
|
1913 |
|
1914 text{* For points in the interior, localization of limits makes no difference. *} |
|
1915 |
|
1916 lemma eventually_within_interior: |
|
1917 assumes "x \<in> interior S" |
|
1918 shows "eventually P (at x within S) \<longleftrightarrow> eventually P (at x)" (is "?lhs = ?rhs") |
|
1919 proof- |
|
1920 from assms obtain T where T: "open T" "x \<in> T" "T \<subseteq> S" |
|
1921 unfolding interior_def by fast |
|
1922 { assume "?lhs" |
|
1923 then obtain A where "open A" "x \<in> A" "\<forall>y\<in>A. y \<noteq> x \<longrightarrow> y \<in> S \<longrightarrow> P y" |
|
1924 unfolding Limits.eventually_within Limits.eventually_at_topological |
|
1925 by auto |
|
1926 with T have "open (A \<inter> T)" "x \<in> A \<inter> T" "\<forall>y\<in>(A \<inter> T). y \<noteq> x \<longrightarrow> P y" |
|
1927 by auto |
|
1928 then have "?rhs" |
|
1929 unfolding Limits.eventually_at_topological by auto |
|
1930 } moreover |
|
1931 { assume "?rhs" hence "?lhs" |
|
1932 unfolding Limits.eventually_within |
|
1933 by (auto elim: eventually_elim1) |
|
1934 } ultimately |
|
1935 show "?thesis" .. |
|
1936 qed |
|
1937 |
|
1938 lemma lim_within_interior: |
|
1939 "x \<in> interior S \<Longrightarrow> (f ---> l) (at x within S) \<longleftrightarrow> (f ---> l) (at x)" |
|
1940 unfolding tendsto_def by (simp add: eventually_within_interior) |
|
1941 |
|
1942 lemma netlimit_within_interior: |
|
1943 fixes x :: "'a::{perfect_space, real_normed_vector}" |
|
1944 (* FIXME: generalize to perfect_space *) |
|
1945 assumes "x \<in> interior S" |
|
1946 shows "netlimit(at x within S) = x" (is "?lhs = ?rhs") |
|
1947 proof- |
|
1948 from assms obtain e::real where e:"e>0" "ball x e \<subseteq> S" using open_interior[of S] unfolding open_contains_ball using interior_subset[of S] by auto |
|
1949 hence "\<not> trivial_limit (at x within S)" using islimpt_subset[of x "ball x e" S] unfolding trivial_limit_within islimpt_ball centre_in_cball by auto |
|
1950 thus ?thesis using netlimit_within by auto |
|
1951 qed |
|
1952 |
|
1953 subsection{* Boundedness. *} |
|
1954 |
|
1955 (* FIXME: This has to be unified with BSEQ!! *) |
|
1956 definition |
|
1957 bounded :: "'a::metric_space set \<Rightarrow> bool" where |
|
1958 "bounded S \<longleftrightarrow> (\<exists>x e. \<forall>y\<in>S. dist x y \<le> e)" |
|
1959 |
|
1960 lemma bounded_any_center: "bounded S \<longleftrightarrow> (\<exists>e. \<forall>y\<in>S. dist a y \<le> e)" |
|
1961 unfolding bounded_def |
|
1962 apply safe |
|
1963 apply (rule_tac x="dist a x + e" in exI, clarify) |
|
1964 apply (drule (1) bspec) |
|
1965 apply (erule order_trans [OF dist_triangle add_left_mono]) |
|
1966 apply auto |
|
1967 done |
|
1968 |
|
1969 lemma bounded_iff: "bounded S \<longleftrightarrow> (\<exists>a. \<forall>x\<in>S. norm x \<le> a)" |
|
1970 unfolding bounded_any_center [where a=0] |
|
1971 by (simp add: dist_norm) |
|
1972 |
|
1973 lemma bounded_empty[simp]: "bounded {}" by (simp add: bounded_def) |
|
1974 lemma bounded_subset: "bounded T \<Longrightarrow> S \<subseteq> T ==> bounded S" |
|
1975 by (metis bounded_def subset_eq) |
|
1976 |
|
1977 lemma bounded_interior[intro]: "bounded S ==> bounded(interior S)" |
|
1978 by (metis bounded_subset interior_subset) |
|
1979 |
|
1980 lemma bounded_closure[intro]: assumes "bounded S" shows "bounded(closure S)" |
|
1981 proof- |
|
1982 from assms obtain x and a where a: "\<forall>y\<in>S. dist x y \<le> a" unfolding bounded_def by auto |
|
1983 { fix y assume "y \<in> closure S" |
|
1984 then obtain f where f: "\<forall>n. f n \<in> S" "(f ---> y) sequentially" |
|
1985 unfolding closure_sequential by auto |
|
1986 have "\<forall>n. f n \<in> S \<longrightarrow> dist x (f n) \<le> a" using a by simp |
|
1987 hence "eventually (\<lambda>n. dist x (f n) \<le> a) sequentially" |
|
1988 by (rule eventually_mono, simp add: f(1)) |
|
1989 have "dist x y \<le> a" |
|
1990 apply (rule Lim_dist_ubound [of sequentially f]) |
|
1991 apply (rule trivial_limit_sequentially) |
|
1992 apply (rule f(2)) |
|
1993 apply fact |
|
1994 done |
|
1995 } |
|
1996 thus ?thesis unfolding bounded_def by auto |
|
1997 qed |
|
1998 |
|
1999 lemma bounded_cball[simp,intro]: "bounded (cball x e)" |
|
2000 apply (simp add: bounded_def) |
|
2001 apply (rule_tac x=x in exI) |
|
2002 apply (rule_tac x=e in exI) |
|
2003 apply auto |
|
2004 done |
|
2005 |
|
2006 lemma bounded_ball[simp,intro]: "bounded(ball x e)" |
|
2007 by (metis ball_subset_cball bounded_cball bounded_subset) |
|
2008 |
|
2009 lemma finite_imp_bounded[intro]: assumes "finite S" shows "bounded S" |
|
2010 proof- |
|
2011 { fix a F assume as:"bounded F" |
|
2012 then obtain x e where "\<forall>y\<in>F. dist x y \<le> e" unfolding bounded_def by auto |
|
2013 hence "\<forall>y\<in>(insert a F). dist x y \<le> max e (dist x a)" by auto |
|
2014 hence "bounded (insert a F)" unfolding bounded_def by (intro exI) |
|
2015 } |
|
2016 thus ?thesis using finite_induct[of S bounded] using bounded_empty assms by auto |
|
2017 qed |
|
2018 |
|
2019 lemma bounded_Un[simp]: "bounded (S \<union> T) \<longleftrightarrow> bounded S \<and> bounded T" |
|
2020 apply (auto simp add: bounded_def) |
|
2021 apply (rename_tac x y r s) |
|
2022 apply (rule_tac x=x in exI) |
|
2023 apply (rule_tac x="max r (dist x y + s)" in exI) |
|
2024 apply (rule ballI, rename_tac z, safe) |
|
2025 apply (drule (1) bspec, simp) |
|
2026 apply (drule (1) bspec) |
|
2027 apply (rule min_max.le_supI2) |
|
2028 apply (erule order_trans [OF dist_triangle add_left_mono]) |
|
2029 done |
|
2030 |
|
2031 lemma bounded_Union[intro]: "finite F \<Longrightarrow> (\<forall>S\<in>F. bounded S) \<Longrightarrow> bounded(\<Union>F)" |
|
2032 by (induct rule: finite_induct[of F], auto) |
|
2033 |
|
2034 lemma bounded_pos: "bounded S \<longleftrightarrow> (\<exists>b>0. \<forall>x\<in> S. norm x <= b)" |
|
2035 apply (simp add: bounded_iff) |
|
2036 apply (subgoal_tac "\<And>x (y::real). 0 < 1 + abs y \<and> (x <= y \<longrightarrow> x <= 1 + abs y)") |
|
2037 by metis arith |
|
2038 |
|
2039 lemma bounded_Int[intro]: "bounded S \<or> bounded T \<Longrightarrow> bounded (S \<inter> T)" |
|
2040 by (metis Int_lower1 Int_lower2 bounded_subset) |
|
2041 |
|
2042 lemma bounded_diff[intro]: "bounded S ==> bounded (S - T)" |
|
2043 apply (metis Diff_subset bounded_subset) |
|
2044 done |
|
2045 |
|
2046 lemma bounded_insert[intro]:"bounded(insert x S) \<longleftrightarrow> bounded S" |
|
2047 by (metis Diff_cancel Un_empty_right Un_insert_right bounded_Un bounded_subset finite.emptyI finite_imp_bounded infinite_remove subset_insertI) |
|
2048 |
|
2049 lemma not_bounded_UNIV[simp, intro]: |
|
2050 "\<not> bounded (UNIV :: 'a::{real_normed_vector, perfect_space} set)" |
|
2051 proof(auto simp add: bounded_pos not_le) |
|
2052 obtain x :: 'a where "x \<noteq> 0" |
|
2053 using perfect_choose_dist [OF zero_less_one] by fast |
|
2054 fix b::real assume b: "b >0" |
|
2055 have b1: "b +1 \<ge> 0" using b by simp |
|
2056 with `x \<noteq> 0` have "b < norm (scaleR (b + 1) (sgn x))" |
|
2057 by (simp add: norm_sgn) |
|
2058 then show "\<exists>x::'a. b < norm x" .. |
|
2059 qed |
|
2060 |
|
2061 lemma bounded_linear_image: |
|
2062 assumes "bounded S" "bounded_linear f" |
|
2063 shows "bounded(f ` S)" |
|
2064 proof- |
|
2065 from assms(1) obtain b where b:"b>0" "\<forall>x\<in>S. norm x \<le> b" unfolding bounded_pos by auto |
|
2066 from assms(2) obtain B where B:"B>0" "\<forall>x. norm (f x) \<le> B * norm x" using bounded_linear.pos_bounded by (auto simp add: mult_ac) |
|
2067 { fix x assume "x\<in>S" |
|
2068 hence "norm x \<le> b" using b by auto |
|
2069 hence "norm (f x) \<le> B * b" using B(2) apply(erule_tac x=x in allE) |
|
2070 by (metis B(1) B(2) real_le_trans real_mult_le_cancel_iff2) |
|
2071 } |
|
2072 thus ?thesis unfolding bounded_pos apply(rule_tac x="b*B" in exI) |
|
2073 using b B real_mult_order[of b B] by (auto simp add: real_mult_commute) |
|
2074 qed |
|
2075 |
|
2076 lemma bounded_scaling: |
|
2077 fixes S :: "'a::real_normed_vector set" |
|
2078 shows "bounded S \<Longrightarrow> bounded ((\<lambda>x. c *\<^sub>R x) ` S)" |
|
2079 apply (rule bounded_linear_image, assumption) |
|
2080 apply (rule scaleR.bounded_linear_right) |
|
2081 done |
|
2082 |
|
2083 lemma bounded_translation: |
|
2084 fixes S :: "'a::real_normed_vector set" |
|
2085 assumes "bounded S" shows "bounded ((\<lambda>x. a + x) ` S)" |
|
2086 proof- |
|
2087 from assms obtain b where b:"b>0" "\<forall>x\<in>S. norm x \<le> b" unfolding bounded_pos by auto |
|
2088 { fix x assume "x\<in>S" |
|
2089 hence "norm (a + x) \<le> b + norm a" using norm_triangle_ineq[of a x] b by auto |
|
2090 } |
|
2091 thus ?thesis unfolding bounded_pos using norm_ge_zero[of a] b(1) using add_strict_increasing[of b 0 "norm a"] |
|
2092 by (auto intro!: add exI[of _ "b + norm a"]) |
|
2093 qed |
|
2094 |
|
2095 |
|
2096 text{* Some theorems on sups and infs using the notion "bounded". *} |
|
2097 |
|
2098 lemma bounded_real: |
|
2099 fixes S :: "real set" |
|
2100 shows "bounded S \<longleftrightarrow> (\<exists>a. \<forall>x\<in>S. abs x <= a)" |
|
2101 by (simp add: bounded_iff) |
|
2102 |
|
2103 lemma bounded_has_rsup: assumes "bounded S" "S \<noteq> {}" |
|
2104 shows "\<forall>x\<in>S. x <= rsup S" and "\<forall>b. (\<forall>x\<in>S. x <= b) \<longrightarrow> rsup S <= b" |
|
2105 proof |
|
2106 fix x assume "x\<in>S" |
|
2107 from assms(1) obtain a where a:"\<forall>x\<in>S. \<bar>x\<bar> \<le> a" unfolding bounded_real by auto |
|
2108 hence *:"S *<= a" using setleI[of S a] by (metis abs_le_interval_iff mem_def) |
|
2109 thus "x \<le> rsup S" using rsup[OF `S\<noteq>{}`] using assms(1)[unfolded bounded_real] using isLubD2[of UNIV S "rsup S" x] using `x\<in>S` by auto |
|
2110 next |
|
2111 show "\<forall>b. (\<forall>x\<in>S. x \<le> b) \<longrightarrow> rsup S \<le> b" using assms |
|
2112 using rsup[of S, unfolded isLub_def isUb_def leastP_def setle_def setge_def] |
|
2113 apply (auto simp add: bounded_real) |
|
2114 by (auto simp add: isLub_def isUb_def leastP_def setle_def setge_def) |
|
2115 qed |
|
2116 |
|
2117 lemma rsup_insert: assumes "bounded S" |
|
2118 shows "rsup(insert x S) = (if S = {} then x else max x (rsup S))" |
|
2119 proof(cases "S={}") |
|
2120 case True thus ?thesis using rsup_finite_in[of "{x}"] by auto |
|
2121 next |
|
2122 let ?S = "insert x S" |
|
2123 case False |
|
2124 hence *:"\<forall>x\<in>S. x \<le> rsup S" using bounded_has_rsup(1)[of S] using assms by auto |
|
2125 hence "insert x S *<= max x (rsup S)" unfolding setle_def by auto |
|
2126 hence "isLub UNIV ?S (rsup ?S)" using rsup[of ?S] by auto |
|
2127 moreover |
|
2128 have **:"isUb UNIV ?S (max x (rsup S))" unfolding isUb_def setle_def using * by auto |
|
2129 { fix y assume as:"isUb UNIV (insert x S) y" |
|
2130 hence "max x (rsup S) \<le> y" unfolding isUb_def using rsup_le[OF `S\<noteq>{}`] |
|
2131 unfolding setle_def by auto } |
|
2132 hence "max x (rsup S) <=* isUb UNIV (insert x S)" unfolding setge_def Ball_def mem_def by auto |
|
2133 hence "isLub UNIV ?S (max x (rsup S))" using ** isLubI2[of UNIV ?S "max x (rsup S)"] unfolding Collect_def by auto |
|
2134 ultimately show ?thesis using real_isLub_unique[of UNIV ?S] using `S\<noteq>{}` by auto |
|
2135 qed |
|
2136 |
|
2137 lemma sup_insert_finite: "finite S \<Longrightarrow> rsup(insert x S) = (if S = {} then x else max x (rsup S))" |
|
2138 apply (rule rsup_insert) |
|
2139 apply (rule finite_imp_bounded) |
|
2140 by simp |
|
2141 |
|
2142 lemma bounded_has_rinf: |
|
2143 assumes "bounded S" "S \<noteq> {}" |
|
2144 shows "\<forall>x\<in>S. x >= rinf S" and "\<forall>b. (\<forall>x\<in>S. x >= b) \<longrightarrow> rinf S >= b" |
|
2145 proof |
|
2146 fix x assume "x\<in>S" |
|
2147 from assms(1) obtain a where a:"\<forall>x\<in>S. \<bar>x\<bar> \<le> a" unfolding bounded_real by auto |
|
2148 hence *:"- a <=* S" using setgeI[of S "-a"] unfolding abs_le_interval_iff by auto |
|
2149 thus "x \<ge> rinf S" using rinf[OF `S\<noteq>{}`] using isGlbD2[of UNIV S "rinf S" x] using `x\<in>S` by auto |
|
2150 next |
|
2151 show "\<forall>b. (\<forall>x\<in>S. x >= b) \<longrightarrow> rinf S \<ge> b" using assms |
|
2152 using rinf[of S, unfolded isGlb_def isLb_def greatestP_def setle_def setge_def] |
|
2153 apply (auto simp add: bounded_real) |
|
2154 by (auto simp add: isGlb_def isLb_def greatestP_def setle_def setge_def) |
|
2155 qed |
|
2156 |
|
2157 (* TODO: Move this to RComplete.thy -- would need to include Glb into RComplete *) |
|
2158 lemma real_isGlb_unique: "[| isGlb R S x; isGlb R S y |] ==> x = (y::real)" |
|
2159 apply (frule isGlb_isLb) |
|
2160 apply (frule_tac x = y in isGlb_isLb) |
|
2161 apply (blast intro!: order_antisym dest!: isGlb_le_isLb) |
|
2162 done |
|
2163 |
|
2164 lemma rinf_insert: assumes "bounded S" |
|
2165 shows "rinf(insert x S) = (if S = {} then x else min x (rinf S))" (is "?lhs = ?rhs") |
|
2166 proof(cases "S={}") |
|
2167 case True thus ?thesis using rinf_finite_in[of "{x}"] by auto |
|
2168 next |
|
2169 let ?S = "insert x S" |
|
2170 case False |
|
2171 hence *:"\<forall>x\<in>S. x \<ge> rinf S" using bounded_has_rinf(1)[of S] using assms by auto |
|
2172 hence "min x (rinf S) <=* insert x S" unfolding setge_def by auto |
|
2173 hence "isGlb UNIV ?S (rinf ?S)" using rinf[of ?S] by auto |
|
2174 moreover |
|
2175 have **:"isLb UNIV ?S (min x (rinf S))" unfolding isLb_def setge_def using * by auto |
|
2176 { fix y assume as:"isLb UNIV (insert x S) y" |
|
2177 hence "min x (rinf S) \<ge> y" unfolding isLb_def using rinf_ge[OF `S\<noteq>{}`] |
|
2178 unfolding setge_def by auto } |
|
2179 hence "isLb UNIV (insert x S) *<= min x (rinf S)" unfolding setle_def Ball_def mem_def by auto |
|
2180 hence "isGlb UNIV ?S (min x (rinf S))" using ** isGlbI2[of UNIV ?S "min x (rinf S)"] unfolding Collect_def by auto |
|
2181 ultimately show ?thesis using real_isGlb_unique[of UNIV ?S] using `S\<noteq>{}` by auto |
|
2182 qed |
|
2183 |
|
2184 lemma inf_insert_finite: "finite S ==> rinf(insert x S) = (if S = {} then x else min x (rinf S))" |
|
2185 by (rule rinf_insert, rule finite_imp_bounded, simp) |
|
2186 |
|
2187 subsection{* Compactness (the definition is the one based on convegent subsequences). *} |
|
2188 |
|
2189 definition |
|
2190 compact :: "'a::metric_space set \<Rightarrow> bool" where (* TODO: generalize *) |
|
2191 "compact S \<longleftrightarrow> |
|
2192 (\<forall>f. (\<forall>n. f n \<in> S) \<longrightarrow> |
|
2193 (\<exists>l\<in>S. \<exists>r. subseq r \<and> ((f o r) ---> l) sequentially))" |
|
2194 |
|
2195 text {* |
|
2196 A metric space (or topological vector space) is said to have the |
|
2197 Heine-Borel property if every closed and bounded subset is compact. |
|
2198 *} |
|
2199 |
|
2200 class heine_borel = |
|
2201 assumes bounded_imp_convergent_subsequence: |
|
2202 "bounded s \<Longrightarrow> \<forall>n. f n \<in> s |
|
2203 \<Longrightarrow> \<exists>l r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" |
|
2204 |
|
2205 lemma bounded_closed_imp_compact: |
|
2206 fixes s::"'a::heine_borel set" |
|
2207 assumes "bounded s" and "closed s" shows "compact s" |
|
2208 proof (unfold compact_def, clarify) |
|
2209 fix f :: "nat \<Rightarrow> 'a" assume f: "\<forall>n. f n \<in> s" |
|
2210 obtain l r where r: "subseq r" and l: "((f \<circ> r) ---> l) sequentially" |
|
2211 using bounded_imp_convergent_subsequence [OF `bounded s` `\<forall>n. f n \<in> s`] by auto |
|
2212 from f have fr: "\<forall>n. (f \<circ> r) n \<in> s" by simp |
|
2213 have "l \<in> s" using `closed s` fr l |
|
2214 unfolding closed_sequential_limits by blast |
|
2215 show "\<exists>l\<in>s. \<exists>r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" |
|
2216 using `l \<in> s` r l by blast |
|
2217 qed |
|
2218 |
|
2219 lemma subseq_bigger: assumes "subseq r" shows "n \<le> r n" |
|
2220 proof(induct n) |
|
2221 show "0 \<le> r 0" by auto |
|
2222 next |
|
2223 fix n assume "n \<le> r n" |
|
2224 moreover have "r n < r (Suc n)" |
|
2225 using assms [unfolded subseq_def] by auto |
|
2226 ultimately show "Suc n \<le> r (Suc n)" by auto |
|
2227 qed |
|
2228 |
|
2229 lemma eventually_subseq: |
|
2230 assumes r: "subseq r" |
|
2231 shows "eventually P sequentially \<Longrightarrow> eventually (\<lambda>n. P (r n)) sequentially" |
|
2232 unfolding eventually_sequentially |
|
2233 by (metis subseq_bigger [OF r] le_trans) |
|
2234 |
|
2235 lemma lim_subseq: |
|
2236 "subseq r \<Longrightarrow> (s ---> l) sequentially \<Longrightarrow> ((s o r) ---> l) sequentially" |
|
2237 unfolding tendsto_def eventually_sequentially o_def |
|
2238 by (metis subseq_bigger le_trans) |
|
2239 |
|
2240 lemma num_Axiom: "EX! g. g 0 = e \<and> (\<forall>n. g (Suc n) = f n (g n))" |
|
2241 unfolding Ex1_def |
|
2242 apply (rule_tac x="nat_rec e f" in exI) |
|
2243 apply (rule conjI)+ |
|
2244 apply (rule def_nat_rec_0, simp) |
|
2245 apply (rule allI, rule def_nat_rec_Suc, simp) |
|
2246 apply (rule allI, rule impI, rule ext) |
|
2247 apply (erule conjE) |
|
2248 apply (induct_tac x) |
|
2249 apply (simp add: nat_rec_0) |
|
2250 apply (erule_tac x="n" in allE) |
|
2251 apply (simp) |
|
2252 done |
|
2253 |
|
2254 lemma convergent_bounded_increasing: fixes s ::"nat\<Rightarrow>real" |
|
2255 assumes "incseq s" and "\<forall>n. abs(s n) \<le> b" |
|
2256 shows "\<exists> l. \<forall>e::real>0. \<exists> N. \<forall>n \<ge> N. abs(s n - l) < e" |
|
2257 proof- |
|
2258 have "isUb UNIV (range s) b" using assms(2) and abs_le_D1 unfolding isUb_def and setle_def by auto |
|
2259 then obtain t where t:"isLub UNIV (range s) t" using reals_complete[of "range s" ] by auto |
|
2260 { fix e::real assume "e>0" and as:"\<forall>N. \<exists>n\<ge>N. \<not> \<bar>s n - t\<bar> < e" |
|
2261 { fix n::nat |
|
2262 obtain N where "N\<ge>n" and n:"\<bar>s N - t\<bar> \<ge> e" using as[THEN spec[where x=n]] by auto |
|
2263 have "t \<ge> s N" using isLub_isUb[OF t, unfolded isUb_def setle_def] by auto |
|
2264 with n have "s N \<le> t - e" using `e>0` by auto |
|
2265 hence "s n \<le> t - e" using assms(1)[unfolded incseq_def, THEN spec[where x=n], THEN spec[where x=N]] using `n\<le>N` by auto } |
|
2266 hence "isUb UNIV (range s) (t - e)" unfolding isUb_def and setle_def by auto |
|
2267 hence False using isLub_le_isUb[OF t, of "t - e"] and `e>0` by auto } |
|
2268 thus ?thesis by blast |
|
2269 qed |
|
2270 |
|
2271 lemma convergent_bounded_monotone: fixes s::"nat \<Rightarrow> real" |
|
2272 assumes "\<forall>n. abs(s n) \<le> b" and "monoseq s" |
|
2273 shows "\<exists>l. \<forall>e::real>0. \<exists>N. \<forall>n\<ge>N. abs(s n - l) < e" |
|
2274 using convergent_bounded_increasing[of s b] assms using convergent_bounded_increasing[of "\<lambda>n. - s n" b] |
|
2275 unfolding monoseq_def incseq_def |
|
2276 apply auto unfolding minus_add_distrib[THEN sym, unfolded diff_minus[THEN sym]] |
|
2277 unfolding abs_minus_cancel by(rule_tac x="-l" in exI)auto |
|
2278 |
|
2279 lemma compact_real_lemma: |
|
2280 assumes "\<forall>n::nat. abs(s n) \<le> b" |
|
2281 shows "\<exists>(l::real) r. subseq r \<and> ((s \<circ> r) ---> l) sequentially" |
|
2282 proof- |
|
2283 obtain r where r:"subseq r" "monoseq (\<lambda>n. s (r n))" |
|
2284 using seq_monosub[of s] by auto |
|
2285 thus ?thesis using convergent_bounded_monotone[of "\<lambda>n. s (r n)" b] and assms |
|
2286 unfolding tendsto_iff dist_norm eventually_sequentially by auto |
|
2287 qed |
|
2288 |
|
2289 instance real :: heine_borel |
|
2290 proof |
|
2291 fix s :: "real set" and f :: "nat \<Rightarrow> real" |
|
2292 assume s: "bounded s" and f: "\<forall>n. f n \<in> s" |
|
2293 then obtain b where b: "\<forall>n. abs (f n) \<le> b" |
|
2294 unfolding bounded_iff by auto |
|
2295 obtain l :: real and r :: "nat \<Rightarrow> nat" where |
|
2296 r: "subseq r" and l: "((f \<circ> r) ---> l) sequentially" |
|
2297 using compact_real_lemma [OF b] by auto |
|
2298 thus "\<exists>l r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" |
|
2299 by auto |
|
2300 qed |
|
2301 |
|
2302 lemma bounded_component: "bounded s \<Longrightarrow> bounded ((\<lambda>x. x $ i) ` s)" |
|
2303 unfolding bounded_def |
|
2304 apply clarify |
|
2305 apply (rule_tac x="x $ i" in exI) |
|
2306 apply (rule_tac x="e" in exI) |
|
2307 apply clarify |
|
2308 apply (rule order_trans [OF dist_nth_le], simp) |
|
2309 done |
|
2310 |
|
2311 lemma compact_lemma: |
|
2312 fixes f :: "nat \<Rightarrow> 'a::heine_borel ^ 'n::finite" |
|
2313 assumes "bounded s" and "\<forall>n. f n \<in> s" |
|
2314 shows "\<forall>d. |
|
2315 \<exists>l r. subseq r \<and> |
|
2316 (\<forall>e>0. eventually (\<lambda>n. \<forall>i\<in>d. dist (f (r n) $ i) (l $ i) < e) sequentially)" |
|
2317 proof |
|
2318 fix d::"'n set" have "finite d" by simp |
|
2319 thus "\<exists>l::'a ^ 'n. \<exists>r. subseq r \<and> |
|
2320 (\<forall>e>0. eventually (\<lambda>n. \<forall>i\<in>d. dist (f (r n) $ i) (l $ i) < e) sequentially)" |
|
2321 proof(induct d) case empty thus ?case unfolding subseq_def by auto |
|
2322 next case (insert k d) |
|
2323 have s': "bounded ((\<lambda>x. x $ k) ` s)" using `bounded s` by (rule bounded_component) |
|
2324 obtain l1::"'a^'n" and r1 where r1:"subseq r1" and lr1:"\<forall>e>0. eventually (\<lambda>n. \<forall>i\<in>d. dist (f (r1 n) $ i) (l1 $ i) < e) sequentially" |
|
2325 using insert(3) by auto |
|
2326 have f': "\<forall>n. f (r1 n) $ k \<in> (\<lambda>x. x $ k) ` s" using `\<forall>n. f n \<in> s` by simp |
|
2327 obtain l2 r2 where r2:"subseq r2" and lr2:"((\<lambda>i. f (r1 (r2 i)) $ k) ---> l2) sequentially" |
|
2328 using bounded_imp_convergent_subsequence[OF s' f'] unfolding o_def by auto |
|
2329 def r \<equiv> "r1 \<circ> r2" have r:"subseq r" |
|
2330 using r1 and r2 unfolding r_def o_def subseq_def by auto |
|
2331 moreover |
|
2332 def l \<equiv> "(\<chi> i. if i = k then l2 else l1$i)::'a^'n" |
|
2333 { fix e::real assume "e>0" |
|
2334 from lr1 `e>0` have N1:"eventually (\<lambda>n. \<forall>i\<in>d. dist (f (r1 n) $ i) (l1 $ i) < e) sequentially" by blast |
|
2335 from lr2 `e>0` have N2:"eventually (\<lambda>n. dist (f (r1 (r2 n)) $ k) l2 < e) sequentially" by (rule tendstoD) |
|
2336 from r2 N1 have N1': "eventually (\<lambda>n. \<forall>i\<in>d. dist (f (r1 (r2 n)) $ i) (l1 $ i) < e) sequentially" |
|
2337 by (rule eventually_subseq) |
|
2338 have "eventually (\<lambda>n. \<forall>i\<in>(insert k d). dist (f (r n) $ i) (l $ i) < e) sequentially" |
|
2339 using N1' N2 by (rule eventually_elim2, simp add: l_def r_def) |
|
2340 } |
|
2341 ultimately show ?case by auto |
|
2342 qed |
|
2343 qed |
|
2344 |
|
2345 instance "^" :: (heine_borel, finite) heine_borel |
|
2346 proof |
|
2347 fix s :: "('a ^ 'b) set" and f :: "nat \<Rightarrow> 'a ^ 'b" |
|
2348 assume s: "bounded s" and f: "\<forall>n. f n \<in> s" |
|
2349 then obtain l r where r: "subseq r" |
|
2350 and l: "\<forall>e>0. eventually (\<lambda>n. \<forall>i\<in>UNIV. dist (f (r n) $ i) (l $ i) < e) sequentially" |
|
2351 using compact_lemma [OF s f] by blast |
|
2352 let ?d = "UNIV::'b set" |
|
2353 { fix e::real assume "e>0" |
|
2354 hence "0 < e / (real_of_nat (card ?d))" |
|
2355 using zero_less_card_finite using divide_pos_pos[of e, of "real_of_nat (card ?d)"] by auto |
|
2356 with l have "eventually (\<lambda>n. \<forall>i. dist (f (r n) $ i) (l $ i) < e / (real_of_nat (card ?d))) sequentially" |
|
2357 by simp |
|
2358 moreover |
|
2359 { fix n assume n: "\<forall>i. dist (f (r n) $ i) (l $ i) < e / (real_of_nat (card ?d))" |
|
2360 have "dist (f (r n)) l \<le> (\<Sum>i\<in>?d. dist (f (r n) $ i) (l $ i))" |
|
2361 unfolding dist_vector_def using zero_le_dist by (rule setL2_le_setsum) |
|
2362 also have "\<dots> < (\<Sum>i\<in>?d. e / (real_of_nat (card ?d)))" |
|
2363 by (rule setsum_strict_mono) (simp_all add: n) |
|
2364 finally have "dist (f (r n)) l < e" by simp |
|
2365 } |
|
2366 ultimately have "eventually (\<lambda>n. dist (f (r n)) l < e) sequentially" |
|
2367 by (rule eventually_elim1) |
|
2368 } |
|
2369 hence *:"((f \<circ> r) ---> l) sequentially" unfolding o_def tendsto_iff by simp |
|
2370 with r show "\<exists>l r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" by auto |
|
2371 qed |
|
2372 |
|
2373 lemma bounded_fst: "bounded s \<Longrightarrow> bounded (fst ` s)" |
|
2374 unfolding bounded_def |
|
2375 apply clarify |
|
2376 apply (rule_tac x="a" in exI) |
|
2377 apply (rule_tac x="e" in exI) |
|
2378 apply clarsimp |
|
2379 apply (drule (1) bspec) |
|
2380 apply (simp add: dist_Pair_Pair) |
|
2381 apply (erule order_trans [OF real_sqrt_sum_squares_ge1]) |
|
2382 done |
|
2383 |
|
2384 lemma bounded_snd: "bounded s \<Longrightarrow> bounded (snd ` s)" |
|
2385 unfolding bounded_def |
|
2386 apply clarify |
|
2387 apply (rule_tac x="b" in exI) |
|
2388 apply (rule_tac x="e" in exI) |
|
2389 apply clarsimp |
|
2390 apply (drule (1) bspec) |
|
2391 apply (simp add: dist_Pair_Pair) |
|
2392 apply (erule order_trans [OF real_sqrt_sum_squares_ge2]) |
|
2393 done |
|
2394 |
|
2395 instance "*" :: (heine_borel, heine_borel) heine_borel |
|
2396 proof |
|
2397 fix s :: "('a * 'b) set" and f :: "nat \<Rightarrow> 'a * 'b" |
|
2398 assume s: "bounded s" and f: "\<forall>n. f n \<in> s" |
|
2399 from s have s1: "bounded (fst ` s)" by (rule bounded_fst) |
|
2400 from f have f1: "\<forall>n. fst (f n) \<in> fst ` s" by simp |
|
2401 obtain l1 r1 where r1: "subseq r1" |
|
2402 and l1: "((\<lambda>n. fst (f (r1 n))) ---> l1) sequentially" |
|
2403 using bounded_imp_convergent_subsequence [OF s1 f1] |
|
2404 unfolding o_def by fast |
|
2405 from s have s2: "bounded (snd ` s)" by (rule bounded_snd) |
|
2406 from f have f2: "\<forall>n. snd (f (r1 n)) \<in> snd ` s" by simp |
|
2407 obtain l2 r2 where r2: "subseq r2" |
|
2408 and l2: "((\<lambda>n. snd (f (r1 (r2 n)))) ---> l2) sequentially" |
|
2409 using bounded_imp_convergent_subsequence [OF s2 f2] |
|
2410 unfolding o_def by fast |
|
2411 have l1': "((\<lambda>n. fst (f (r1 (r2 n)))) ---> l1) sequentially" |
|
2412 using lim_subseq [OF r2 l1] unfolding o_def . |
|
2413 have l: "((f \<circ> (r1 \<circ> r2)) ---> (l1, l2)) sequentially" |
|
2414 using tendsto_Pair [OF l1' l2] unfolding o_def by simp |
|
2415 have r: "subseq (r1 \<circ> r2)" |
|
2416 using r1 r2 unfolding subseq_def by simp |
|
2417 show "\<exists>l r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" |
|
2418 using l r by fast |
|
2419 qed |
|
2420 |
|
2421 subsection{* Completeness. *} |
|
2422 |
|
2423 lemma cauchy_def: |
|
2424 "Cauchy s \<longleftrightarrow> (\<forall>e>0. \<exists>N. \<forall>m n. m \<ge> N \<and> n \<ge> N --> dist(s m)(s n) < e)" |
|
2425 unfolding Cauchy_def by blast |
|
2426 |
|
2427 definition |
|
2428 complete :: "'a::metric_space set \<Rightarrow> bool" where |
|
2429 "complete s \<longleftrightarrow> (\<forall>f. (\<forall>n. f n \<in> s) \<and> Cauchy f |
|
2430 --> (\<exists>l \<in> s. (f ---> l) sequentially))" |
|
2431 |
|
2432 lemma cauchy: "Cauchy s \<longleftrightarrow> (\<forall>e>0.\<exists> N::nat. \<forall>n\<ge>N. dist(s n)(s N) < e)" (is "?lhs = ?rhs") |
|
2433 proof- |
|
2434 { assume ?rhs |
|
2435 { fix e::real |
|
2436 assume "e>0" |
|
2437 with `?rhs` obtain N where N:"\<forall>n\<ge>N. dist (s n) (s N) < e/2" |
|
2438 by (erule_tac x="e/2" in allE) auto |
|
2439 { fix n m |
|
2440 assume nm:"N \<le> m \<and> N \<le> n" |
|
2441 hence "dist (s m) (s n) < e" using N |
|
2442 using dist_triangle_half_l[of "s m" "s N" "e" "s n"] |
|
2443 by blast |
|
2444 } |
|
2445 hence "\<exists>N. \<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist (s m) (s n) < e" |
|
2446 by blast |
|
2447 } |
|
2448 hence ?lhs |
|
2449 unfolding cauchy_def |
|
2450 by blast |
|
2451 } |
|
2452 thus ?thesis |
|
2453 unfolding cauchy_def |
|
2454 using dist_triangle_half_l |
|
2455 by blast |
|
2456 qed |
|
2457 |
|
2458 lemma convergent_imp_cauchy: |
|
2459 "(s ---> l) sequentially ==> Cauchy s" |
|
2460 proof(simp only: cauchy_def, rule, rule) |
|
2461 fix e::real assume "e>0" "(s ---> l) sequentially" |
|
2462 then obtain N::nat where N:"\<forall>n\<ge>N. dist (s n) l < e/2" unfolding Lim_sequentially by(erule_tac x="e/2" in allE) auto |
|
2463 thus "\<exists>N. \<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist (s m) (s n) < e" using dist_triangle_half_l[of _ l e _] by (rule_tac x=N in exI) auto |
|
2464 qed |
|
2465 |
|
2466 lemma cauchy_imp_bounded: assumes "Cauchy s" shows "bounded {y. (\<exists>n::nat. y = s n)}" |
|
2467 proof- |
|
2468 from assms obtain N::nat where "\<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist (s m) (s n) < 1" unfolding cauchy_def apply(erule_tac x= 1 in allE) by auto |
|
2469 hence N:"\<forall>n. N \<le> n \<longrightarrow> dist (s N) (s n) < 1" by auto |
|
2470 moreover |
|
2471 have "bounded (s ` {0..N})" using finite_imp_bounded[of "s ` {1..N}"] by auto |
|
2472 then obtain a where a:"\<forall>x\<in>s ` {0..N}. dist (s N) x \<le> a" |
|
2473 unfolding bounded_any_center [where a="s N"] by auto |
|
2474 ultimately show "?thesis" |
|
2475 unfolding bounded_any_center [where a="s N"] |
|
2476 apply(rule_tac x="max a 1" in exI) apply auto |
|
2477 apply(erule_tac x=n in allE) apply(erule_tac x=n in ballE) by auto |
|
2478 qed |
|
2479 |
|
2480 lemma compact_imp_complete: assumes "compact s" shows "complete s" |
|
2481 proof- |
|
2482 { fix f assume as: "(\<forall>n::nat. f n \<in> s)" "Cauchy f" |
|
2483 from as(1) obtain l r where lr: "l\<in>s" "subseq r" "((f \<circ> r) ---> l) sequentially" using assms unfolding compact_def by blast |
|
2484 |
|
2485 note lr' = subseq_bigger [OF lr(2)] |
|
2486 |
|
2487 { fix e::real assume "e>0" |
|
2488 from as(2) obtain N where N:"\<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist (f m) (f n) < e/2" unfolding cauchy_def using `e>0` apply (erule_tac x="e/2" in allE) by auto |
|
2489 from lr(3)[unfolded Lim_sequentially, THEN spec[where x="e/2"]] obtain M where M:"\<forall>n\<ge>M. dist ((f \<circ> r) n) l < e/2" using `e>0` by auto |
|
2490 { fix n::nat assume n:"n \<ge> max N M" |
|
2491 have "dist ((f \<circ> r) n) l < e/2" using n M by auto |
|
2492 moreover have "r n \<ge> N" using lr'[of n] n by auto |
|
2493 hence "dist (f n) ((f \<circ> r) n) < e / 2" using N using n by auto |
|
2494 ultimately have "dist (f n) l < e" using dist_triangle_half_r[of "f (r n)" "f n" e l] by (auto simp add: dist_commute) } |
|
2495 hence "\<exists>N. \<forall>n\<ge>N. dist (f n) l < e" by blast } |
|
2496 hence "\<exists>l\<in>s. (f ---> l) sequentially" using `l\<in>s` unfolding Lim_sequentially by auto } |
|
2497 thus ?thesis unfolding complete_def by auto |
|
2498 qed |
|
2499 |
|
2500 instance heine_borel < complete_space |
|
2501 proof |
|
2502 fix f :: "nat \<Rightarrow> 'a" assume "Cauchy f" |
|
2503 hence "bounded (range f)" unfolding image_def |
|
2504 using cauchy_imp_bounded [of f] by auto |
|
2505 hence "compact (closure (range f))" |
|
2506 using bounded_closed_imp_compact [of "closure (range f)"] by auto |
|
2507 hence "complete (closure (range f))" |
|
2508 using compact_imp_complete by auto |
|
2509 moreover have "\<forall>n. f n \<in> closure (range f)" |
|
2510 using closure_subset [of "range f"] by auto |
|
2511 ultimately have "\<exists>l\<in>closure (range f). (f ---> l) sequentially" |
|
2512 using `Cauchy f` unfolding complete_def by auto |
|
2513 then show "convergent f" |
|
2514 unfolding convergent_def LIMSEQ_conv_tendsto [symmetric] by auto |
|
2515 qed |
|
2516 |
|
2517 lemma complete_univ: "complete (UNIV :: 'a::complete_space set)" |
|
2518 proof(simp add: complete_def, rule, rule) |
|
2519 fix f :: "nat \<Rightarrow> 'a" assume "Cauchy f" |
|
2520 hence "convergent f" by (rule Cauchy_convergent) |
|
2521 hence "\<exists>l. f ----> l" unfolding convergent_def . |
|
2522 thus "\<exists>l. (f ---> l) sequentially" unfolding LIMSEQ_conv_tendsto . |
|
2523 qed |
|
2524 |
|
2525 lemma complete_imp_closed: assumes "complete s" shows "closed s" |
|
2526 proof - |
|
2527 { fix x assume "x islimpt s" |
|
2528 then obtain f where f: "\<forall>n. f n \<in> s - {x}" "(f ---> x) sequentially" |
|
2529 unfolding islimpt_sequential by auto |
|
2530 then obtain l where l: "l\<in>s" "(f ---> l) sequentially" |
|
2531 using `complete s`[unfolded complete_def] using convergent_imp_cauchy[of f x] by auto |
|
2532 hence "x \<in> s" using Lim_unique[of sequentially f l x] trivial_limit_sequentially f(2) by auto |
|
2533 } |
|
2534 thus "closed s" unfolding closed_limpt by auto |
|
2535 qed |
|
2536 |
|
2537 lemma complete_eq_closed: |
|
2538 fixes s :: "'a::complete_space set" |
|
2539 shows "complete s \<longleftrightarrow> closed s" (is "?lhs = ?rhs") |
|
2540 proof |
|
2541 assume ?lhs thus ?rhs by (rule complete_imp_closed) |
|
2542 next |
|
2543 assume ?rhs |
|
2544 { fix f assume as:"\<forall>n::nat. f n \<in> s" "Cauchy f" |
|
2545 then obtain l where "(f ---> l) sequentially" using complete_univ[unfolded complete_def, THEN spec[where x=f]] by auto |
|
2546 hence "\<exists>l\<in>s. (f ---> l) sequentially" using `?rhs`[unfolded closed_sequential_limits, THEN spec[where x=f], THEN spec[where x=l]] using as(1) by auto } |
|
2547 thus ?lhs unfolding complete_def by auto |
|
2548 qed |
|
2549 |
|
2550 lemma convergent_eq_cauchy: |
|
2551 fixes s :: "nat \<Rightarrow> 'a::complete_space" |
|
2552 shows "(\<exists>l. (s ---> l) sequentially) \<longleftrightarrow> Cauchy s" (is "?lhs = ?rhs") |
|
2553 proof |
|
2554 assume ?lhs then obtain l where "(s ---> l) sequentially" by auto |
|
2555 thus ?rhs using convergent_imp_cauchy by auto |
|
2556 next |
|
2557 assume ?rhs thus ?lhs using complete_univ[unfolded complete_def, THEN spec[where x=s]] by auto |
|
2558 qed |
|
2559 |
|
2560 lemma convergent_imp_bounded: |
|
2561 fixes s :: "nat \<Rightarrow> 'a::metric_space" |
|
2562 shows "(s ---> l) sequentially ==> bounded (s ` (UNIV::(nat set)))" |
|
2563 using convergent_imp_cauchy[of s] |
|
2564 using cauchy_imp_bounded[of s] |
|
2565 unfolding image_def |
|
2566 by auto |
|
2567 |
|
2568 subsection{* Total boundedness. *} |
|
2569 |
|
2570 fun helper_1::"('a::metric_space set) \<Rightarrow> real \<Rightarrow> nat \<Rightarrow> 'a" where |
|
2571 "helper_1 s e n = (SOME y::'a. y \<in> s \<and> (\<forall>m<n. \<not> (dist (helper_1 s e m) y < e)))" |
|
2572 declare helper_1.simps[simp del] |
|
2573 |
|
2574 lemma compact_imp_totally_bounded: |
|
2575 assumes "compact s" |
|
2576 shows "\<forall>e>0. \<exists>k. finite k \<and> k \<subseteq> s \<and> s \<subseteq> (\<Union>((\<lambda>x. ball x e) ` k))" |
|
2577 proof(rule, rule, rule ccontr) |
|
2578 fix e::real assume "e>0" and assm:"\<not> (\<exists>k. finite k \<and> k \<subseteq> s \<and> s \<subseteq> \<Union>(\<lambda>x. ball x e) ` k)" |
|
2579 def x \<equiv> "helper_1 s e" |
|
2580 { fix n |
|
2581 have "x n \<in> s \<and> (\<forall>m<n. \<not> dist (x m) (x n) < e)" |
|
2582 proof(induct_tac rule:nat_less_induct) |
|
2583 fix n def Q \<equiv> "(\<lambda>y. y \<in> s \<and> (\<forall>m<n. \<not> dist (x m) y < e))" |
|
2584 assume as:"\<forall>m<n. x m \<in> s \<and> (\<forall>ma<m. \<not> dist (x ma) (x m) < e)" |
|
2585 have "\<not> s \<subseteq> (\<Union>x\<in>x ` {0..<n}. ball x e)" using assm apply simp apply(erule_tac x="x ` {0 ..< n}" in allE) using as by auto |
|
2586 then obtain z where z:"z\<in>s" "z \<notin> (\<Union>x\<in>x ` {0..<n}. ball x e)" unfolding subset_eq by auto |
|
2587 have "Q (x n)" unfolding x_def and helper_1.simps[of s e n] |
|
2588 apply(rule someI2[where a=z]) unfolding x_def[symmetric] and Q_def using z by auto |
|
2589 thus "x n \<in> s \<and> (\<forall>m<n. \<not> dist (x m) (x n) < e)" unfolding Q_def by auto |
|
2590 qed } |
|
2591 hence "\<forall>n::nat. x n \<in> s" and x:"\<forall>n. \<forall>m < n. \<not> (dist (x m) (x n) < e)" by blast+ |
|
2592 then obtain l r where "l\<in>s" and r:"subseq r" and "((x \<circ> r) ---> l) sequentially" using assms(1)[unfolded compact_def, THEN spec[where x=x]] by auto |
|
2593 from this(3) have "Cauchy (x \<circ> r)" using convergent_imp_cauchy by auto |
|
2594 then obtain N::nat where N:"\<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist ((x \<circ> r) m) ((x \<circ> r) n) < e" unfolding cauchy_def using `e>0` by auto |
|
2595 show False |
|
2596 using N[THEN spec[where x=N], THEN spec[where x="N+1"]] |
|
2597 using r[unfolded subseq_def, THEN spec[where x=N], THEN spec[where x="N+1"]] |
|
2598 using x[THEN spec[where x="r (N+1)"], THEN spec[where x="r (N)"]] by auto |
|
2599 qed |
|
2600 |
|
2601 subsection{* Heine-Borel theorem (following Burkill \& Burkill vol. 2) *} |
|
2602 |
|
2603 lemma heine_borel_lemma: fixes s::"'a::metric_space set" |
|
2604 assumes "compact s" "s \<subseteq> (\<Union> t)" "\<forall>b \<in> t. open b" |
|
2605 shows "\<exists>e>0. \<forall>x \<in> s. \<exists>b \<in> t. ball x e \<subseteq> b" |
|
2606 proof(rule ccontr) |
|
2607 assume "\<not> (\<exists>e>0. \<forall>x\<in>s. \<exists>b\<in>t. ball x e \<subseteq> b)" |
|
2608 hence cont:"\<forall>e>0. \<exists>x\<in>s. \<forall>xa\<in>t. \<not> (ball x e \<subseteq> xa)" by auto |
|
2609 { fix n::nat |
|
2610 have "1 / real (n + 1) > 0" by auto |
|
2611 hence "\<exists>x. x\<in>s \<and> (\<forall>xa\<in>t. \<not> (ball x (inverse (real (n+1))) \<subseteq> xa))" using cont unfolding Bex_def by auto } |
|
2612 hence "\<forall>n::nat. \<exists>x. x \<in> s \<and> (\<forall>xa\<in>t. \<not> ball x (inverse (real (n + 1))) \<subseteq> xa)" by auto |
|
2613 then obtain f where f:"\<forall>n::nat. f n \<in> s \<and> (\<forall>xa\<in>t. \<not> ball (f n) (inverse (real (n + 1))) \<subseteq> xa)" |
|
2614 using choice[of "\<lambda>n::nat. \<lambda>x. x\<in>s \<and> (\<forall>xa\<in>t. \<not> ball x (inverse (real (n + 1))) \<subseteq> xa)"] by auto |
|
2615 |
|
2616 then obtain l r where l:"l\<in>s" and r:"subseq r" and lr:"((f \<circ> r) ---> l) sequentially" |
|
2617 using assms(1)[unfolded compact_def, THEN spec[where x=f]] by auto |
|
2618 |
|
2619 obtain b where "l\<in>b" "b\<in>t" using assms(2) and l by auto |
|
2620 then obtain e where "e>0" and e:"\<forall>z. dist z l < e \<longrightarrow> z\<in>b" |
|
2621 using assms(3)[THEN bspec[where x=b]] unfolding open_dist by auto |
|
2622 |
|
2623 then obtain N1 where N1:"\<forall>n\<ge>N1. dist ((f \<circ> r) n) l < e / 2" |
|
2624 using lr[unfolded Lim_sequentially, THEN spec[where x="e/2"]] by auto |
|
2625 |
|
2626 obtain N2::nat where N2:"N2>0" "inverse (real N2) < e /2" using real_arch_inv[of "e/2"] and `e>0` by auto |
|
2627 have N2':"inverse (real (r (N1 + N2) +1 )) < e/2" |
|
2628 apply(rule order_less_trans) apply(rule less_imp_inverse_less) using N2 |
|
2629 using subseq_bigger[OF r, of "N1 + N2"] by auto |
|
2630 |
|
2631 def x \<equiv> "(f (r (N1 + N2)))" |
|
2632 have x:"\<not> ball x (inverse (real (r (N1 + N2) + 1))) \<subseteq> b" unfolding x_def |
|
2633 using f[THEN spec[where x="r (N1 + N2)"]] using `b\<in>t` by auto |
|
2634 have "\<exists>y\<in>ball x (inverse (real (r (N1 + N2) + 1))). y\<notin>b" apply(rule ccontr) using x by auto |
|
2635 then obtain y where y:"y \<in> ball x (inverse (real (r (N1 + N2) + 1)))" "y \<notin> b" by auto |
|
2636 |
|
2637 have "dist x l < e/2" using N1 unfolding x_def o_def by auto |
|
2638 hence "dist y l < e" using y N2' using dist_triangle[of y l x]by (auto simp add:dist_commute) |
|
2639 |
|
2640 thus False using e and `y\<notin>b` by auto |
|
2641 qed |
|
2642 |
|
2643 lemma compact_imp_heine_borel: "compact s ==> (\<forall>f. (\<forall>t \<in> f. open t) \<and> s \<subseteq> (\<Union> f) |
|
2644 \<longrightarrow> (\<exists>f'. f' \<subseteq> f \<and> finite f' \<and> s \<subseteq> (\<Union> f')))" |
|
2645 proof clarify |
|
2646 fix f assume "compact s" " \<forall>t\<in>f. open t" "s \<subseteq> \<Union>f" |
|
2647 then obtain e::real where "e>0" and "\<forall>x\<in>s. \<exists>b\<in>f. ball x e \<subseteq> b" using heine_borel_lemma[of s f] by auto |
|
2648 hence "\<forall>x\<in>s. \<exists>b. b\<in>f \<and> ball x e \<subseteq> b" by auto |
|
2649 hence "\<exists>bb. \<forall>x\<in>s. bb x \<in>f \<and> ball x e \<subseteq> bb x" using bchoice[of s "\<lambda>x b. b\<in>f \<and> ball x e \<subseteq> b"] by auto |
|
2650 then obtain bb where bb:"\<forall>x\<in>s. (bb x) \<in> f \<and> ball x e \<subseteq> (bb x)" by blast |
|
2651 |
|
2652 from `compact s` have "\<exists> k. finite k \<and> k \<subseteq> s \<and> s \<subseteq> \<Union>(\<lambda>x. ball x e) ` k" using compact_imp_totally_bounded[of s] `e>0` by auto |
|
2653 then obtain k where k:"finite k" "k \<subseteq> s" "s \<subseteq> \<Union>(\<lambda>x. ball x e) ` k" by auto |
|
2654 |
|
2655 have "finite (bb ` k)" using k(1) by auto |
|
2656 moreover |
|
2657 { fix x assume "x\<in>s" |
|
2658 hence "x\<in>\<Union>(\<lambda>x. ball x e) ` k" using k(3) unfolding subset_eq by auto |
|
2659 hence "\<exists>X\<in>bb ` k. x \<in> X" using bb k(2) by blast |
|
2660 hence "x \<in> \<Union>(bb ` k)" using Union_iff[of x "bb ` k"] by auto |
|
2661 } |
|
2662 ultimately show "\<exists>f'\<subseteq>f. finite f' \<and> s \<subseteq> \<Union>f'" using bb k(2) by (rule_tac x="bb ` k" in exI) auto |
|
2663 qed |
|
2664 |
|
2665 subsection{* Bolzano-Weierstrass property. *} |
|
2666 |
|
2667 lemma heine_borel_imp_bolzano_weierstrass: |
|
2668 assumes "\<forall>f. (\<forall>t \<in> f. open t) \<and> s \<subseteq> (\<Union> f) --> (\<exists>f'. f' \<subseteq> f \<and> finite f' \<and> s \<subseteq> (\<Union> f'))" |
|
2669 "infinite t" "t \<subseteq> s" |
|
2670 shows "\<exists>x \<in> s. x islimpt t" |
|
2671 proof(rule ccontr) |
|
2672 assume "\<not> (\<exists>x \<in> s. x islimpt t)" |
|
2673 then obtain f where f:"\<forall>x\<in>s. x \<in> f x \<and> open (f x) \<and> (\<forall>y\<in>t. y \<in> f x \<longrightarrow> y = x)" unfolding islimpt_def |
|
2674 using bchoice[of s "\<lambda> x T. x \<in> T \<and> open T \<and> (\<forall>y\<in>t. y \<in> T \<longrightarrow> y = x)"] by auto |
|
2675 obtain g where g:"g\<subseteq>{t. \<exists>x. x \<in> s \<and> t = f x}" "finite g" "s \<subseteq> \<Union>g" |
|
2676 using assms(1)[THEN spec[where x="{t. \<exists>x. x\<in>s \<and> t = f x}"]] using f by auto |
|
2677 from g(1,3) have g':"\<forall>x\<in>g. \<exists>xa \<in> s. x = f xa" by auto |
|
2678 { fix x y assume "x\<in>t" "y\<in>t" "f x = f y" |
|
2679 hence "x \<in> f x" "y \<in> f x \<longrightarrow> y = x" using f[THEN bspec[where x=x]] and `t\<subseteq>s` by auto |
|
2680 hence "x = y" using `f x = f y` and f[THEN bspec[where x=y]] and `y\<in>t` and `t\<subseteq>s` by auto } |
|
2681 hence "infinite (f ` t)" using assms(2) using finite_imageD[unfolded inj_on_def, of f t] by auto |
|
2682 moreover |
|
2683 { fix x assume "x\<in>t" "f x \<notin> g" |
|
2684 from g(3) assms(3) `x\<in>t` obtain h where "h\<in>g" and "x\<in>h" by auto |
|
2685 then obtain y where "y\<in>s" "h = f y" using g'[THEN bspec[where x=h]] by auto |
|
2686 hence "y = x" using f[THEN bspec[where x=y]] and `x\<in>t` and `x\<in>h`[unfolded `h = f y`] by auto |
|
2687 hence False using `f x \<notin> g` `h\<in>g` unfolding `h = f y` by auto } |
|
2688 hence "f ` t \<subseteq> g" by auto |
|
2689 ultimately show False using g(2) using finite_subset by auto |
|
2690 qed |
|
2691 |
|
2692 subsection{* Complete the chain of compactness variants. *} |
|
2693 |
|
2694 primrec helper_2::"(real \<Rightarrow> 'a::metric_space) \<Rightarrow> nat \<Rightarrow> 'a" where |
|
2695 "helper_2 beyond 0 = beyond 0" | |
|
2696 "helper_2 beyond (Suc n) = beyond (dist undefined (helper_2 beyond n) + 1 )" |
|
2697 |
|
2698 lemma bolzano_weierstrass_imp_bounded: fixes s::"'a::metric_space set" |
|
2699 assumes "\<forall>t. infinite t \<and> t \<subseteq> s --> (\<exists>x \<in> s. x islimpt t)" |
|
2700 shows "bounded s" |
|
2701 proof(rule ccontr) |
|
2702 assume "\<not> bounded s" |
|
2703 then obtain beyond where "\<forall>a. beyond a \<in>s \<and> \<not> dist undefined (beyond a) \<le> a" |
|
2704 unfolding bounded_any_center [where a=undefined] |
|
2705 apply simp using choice[of "\<lambda>a x. x\<in>s \<and> \<not> dist undefined x \<le> a"] by auto |
|
2706 hence beyond:"\<And>a. beyond a \<in>s" "\<And>a. dist undefined (beyond a) > a" |
|
2707 unfolding linorder_not_le by auto |
|
2708 def x \<equiv> "helper_2 beyond" |
|
2709 |
|
2710 { fix m n ::nat assume "m<n" |
|
2711 hence "dist undefined (x m) + 1 < dist undefined (x n)" |
|
2712 proof(induct n) |
|
2713 case 0 thus ?case by auto |
|
2714 next |
|
2715 case (Suc n) |
|
2716 have *:"dist undefined (x n) + 1 < dist undefined (x (Suc n))" |
|
2717 unfolding x_def and helper_2.simps |
|
2718 using beyond(2)[of "dist undefined (helper_2 beyond n) + 1"] by auto |
|
2719 thus ?case proof(cases "m < n") |
|
2720 case True thus ?thesis using Suc and * by auto |
|
2721 next |
|
2722 case False hence "m = n" using Suc(2) by auto |
|
2723 thus ?thesis using * by auto |
|
2724 qed |
|
2725 qed } note * = this |
|
2726 { fix m n ::nat assume "m\<noteq>n" |
|
2727 have "1 < dist (x m) (x n)" |
|
2728 proof(cases "m<n") |
|
2729 case True |
|
2730 hence "1 < dist undefined (x n) - dist undefined (x m)" using *[of m n] by auto |
|
2731 thus ?thesis using dist_triangle [of undefined "x n" "x m"] by arith |
|
2732 next |
|
2733 case False hence "n<m" using `m\<noteq>n` by auto |
|
2734 hence "1 < dist undefined (x m) - dist undefined (x n)" using *[of n m] by auto |
|
2735 thus ?thesis using dist_triangle2 [of undefined "x m" "x n"] by arith |
|
2736 qed } note ** = this |
|
2737 { fix a b assume "x a = x b" "a \<noteq> b" |
|
2738 hence False using **[of a b] by auto } |
|
2739 hence "inj x" unfolding inj_on_def by auto |
|
2740 moreover |
|
2741 { fix n::nat |
|
2742 have "x n \<in> s" |
|
2743 proof(cases "n = 0") |
|
2744 case True thus ?thesis unfolding x_def using beyond by auto |
|
2745 next |
|
2746 case False then obtain z where "n = Suc z" using not0_implies_Suc by auto |
|
2747 thus ?thesis unfolding x_def using beyond by auto |
|
2748 qed } |
|
2749 ultimately have "infinite (range x) \<and> range x \<subseteq> s" unfolding x_def using range_inj_infinite[of "helper_2 beyond"] using beyond(1) by auto |
|
2750 |
|
2751 then obtain l where "l\<in>s" and l:"l islimpt range x" using assms[THEN spec[where x="range x"]] by auto |
|
2752 then obtain y where "x y \<noteq> l" and y:"dist (x y) l < 1/2" unfolding islimpt_approachable apply(erule_tac x="1/2" in allE) by auto |
|
2753 then obtain z where "x z \<noteq> l" and z:"dist (x z) l < dist (x y) l" using l[unfolded islimpt_approachable, THEN spec[where x="dist (x y) l"]] |
|
2754 unfolding dist_nz by auto |
|
2755 show False using y and z and dist_triangle_half_l[of "x y" l 1 "x z"] and **[of y z] by auto |
|
2756 qed |
|
2757 |
|
2758 lemma sequence_infinite_lemma: |
|
2759 fixes l :: "'a::metric_space" (* TODO: generalize *) |
|
2760 assumes "\<forall>n::nat. (f n \<noteq> l)" "(f ---> l) sequentially" |
|
2761 shows "infinite {y. (\<exists> n. y = f n)}" |
|
2762 proof(rule ccontr) |
|
2763 let ?A = "(\<lambda>x. dist x l) ` {y. \<exists>n. y = f n}" |
|
2764 assume "\<not> infinite {y. \<exists>n. y = f n}" |
|
2765 hence **:"finite ?A" "?A \<noteq> {}" by auto |
|
2766 obtain k where k:"dist (f k) l = Min ?A" using Min_in[OF **] by auto |
|
2767 have "0 < Min ?A" using assms(1) unfolding dist_nz unfolding Min_gr_iff[OF **] by auto |
|
2768 then obtain N where "dist (f N) l < Min ?A" using assms(2)[unfolded Lim_sequentially, THEN spec[where x="Min ?A"]] by auto |
|
2769 moreover have "dist (f N) l \<in> ?A" by auto |
|
2770 ultimately show False using Min_le[OF **(1), of "dist (f N) l"] by auto |
|
2771 qed |
|
2772 |
|
2773 lemma sequence_unique_limpt: |
|
2774 fixes l :: "'a::metric_space" (* TODO: generalize *) |
|
2775 assumes "\<forall>n::nat. (f n \<noteq> l)" "(f ---> l) sequentially" "l' islimpt {y. (\<exists>n. y = f n)}" |
|
2776 shows "l' = l" |
|
2777 proof(rule ccontr) |
|
2778 def e \<equiv> "dist l' l" |
|
2779 assume "l' \<noteq> l" hence "e>0" unfolding dist_nz e_def by auto |
|
2780 then obtain N::nat where N:"\<forall>n\<ge>N. dist (f n) l < e / 2" |
|
2781 using assms(2)[unfolded Lim_sequentially, THEN spec[where x="e/2"]] by auto |
|
2782 def d \<equiv> "Min (insert (e/2) ((\<lambda>n. if dist (f n) l' = 0 then e/2 else dist (f n) l') ` {0 .. N}))" |
|
2783 have "d>0" using `e>0` unfolding d_def e_def using zero_le_dist[of _ l', unfolded order_le_less] by auto |
|
2784 obtain k where k:"f k \<noteq> l'" "dist (f k) l' < d" using `d>0` and assms(3)[unfolded islimpt_approachable, THEN spec[where x="d"]] by auto |
|
2785 have "k\<ge>N" using k(1)[unfolded dist_nz] using k(2)[unfolded d_def] |
|
2786 by force |
|
2787 hence "dist l' l < e" using N[THEN spec[where x=k]] using k(2)[unfolded d_def] and dist_triangle_half_r[of "f k" l' e l] by auto |
|
2788 thus False unfolding e_def by auto |
|
2789 qed |
|
2790 |
|
2791 lemma bolzano_weierstrass_imp_closed: |
|
2792 fixes s :: "'a::metric_space set" (* TODO: can this be generalized? *) |
|
2793 assumes "\<forall>t. infinite t \<and> t \<subseteq> s --> (\<exists>x \<in> s. x islimpt t)" |
|
2794 shows "closed s" |
|
2795 proof- |
|
2796 { fix x l assume as: "\<forall>n::nat. x n \<in> s" "(x ---> l) sequentially" |
|
2797 hence "l \<in> s" |
|
2798 proof(cases "\<forall>n. x n \<noteq> l") |
|
2799 case False thus "l\<in>s" using as(1) by auto |
|
2800 next |
|
2801 case True note cas = this |
|
2802 with as(2) have "infinite {y. \<exists>n. y = x n}" using sequence_infinite_lemma[of x l] by auto |
|
2803 then obtain l' where "l'\<in>s" "l' islimpt {y. \<exists>n. y = x n}" using assms[THEN spec[where x="{y. \<exists>n. y = x n}"]] as(1) by auto |
|
2804 thus "l\<in>s" using sequence_unique_limpt[of x l l'] using as cas by auto |
|
2805 qed } |
|
2806 thus ?thesis unfolding closed_sequential_limits by fast |
|
2807 qed |
|
2808 |
|
2809 text{* Hence express everything as an equivalence. *} |
|
2810 |
|
2811 lemma compact_eq_heine_borel: |
|
2812 fixes s :: "'a::heine_borel set" |
|
2813 shows "compact s \<longleftrightarrow> |
|
2814 (\<forall>f. (\<forall>t \<in> f. open t) \<and> s \<subseteq> (\<Union> f) |
|
2815 --> (\<exists>f'. f' \<subseteq> f \<and> finite f' \<and> s \<subseteq> (\<Union> f')))" (is "?lhs = ?rhs") |
|
2816 proof |
|
2817 assume ?lhs thus ?rhs using compact_imp_heine_borel[of s] by blast |
|
2818 next |
|
2819 assume ?rhs |
|
2820 hence "\<forall>t. infinite t \<and> t \<subseteq> s \<longrightarrow> (\<exists>x\<in>s. x islimpt t)" |
|
2821 by (blast intro: heine_borel_imp_bolzano_weierstrass[of s]) |
|
2822 thus ?lhs using bolzano_weierstrass_imp_bounded[of s] bolzano_weierstrass_imp_closed[of s] bounded_closed_imp_compact[of s] by blast |
|
2823 qed |
|
2824 |
|
2825 lemma compact_eq_bolzano_weierstrass: |
|
2826 fixes s :: "'a::heine_borel set" |
|
2827 shows "compact s \<longleftrightarrow> (\<forall>t. infinite t \<and> t \<subseteq> s --> (\<exists>x \<in> s. x islimpt t))" (is "?lhs = ?rhs") |
|
2828 proof |
|
2829 assume ?lhs thus ?rhs unfolding compact_eq_heine_borel using heine_borel_imp_bolzano_weierstrass[of s] by auto |
|
2830 next |
|
2831 assume ?rhs thus ?lhs using bolzano_weierstrass_imp_bounded bolzano_weierstrass_imp_closed bounded_closed_imp_compact by auto |
|
2832 qed |
|
2833 |
|
2834 lemma compact_eq_bounded_closed: |
|
2835 fixes s :: "'a::heine_borel set" |
|
2836 shows "compact s \<longleftrightarrow> bounded s \<and> closed s" (is "?lhs = ?rhs") |
|
2837 proof |
|
2838 assume ?lhs thus ?rhs unfolding compact_eq_bolzano_weierstrass using bolzano_weierstrass_imp_bounded bolzano_weierstrass_imp_closed by auto |
|
2839 next |
|
2840 assume ?rhs thus ?lhs using bounded_closed_imp_compact by auto |
|
2841 qed |
|
2842 |
|
2843 lemma compact_imp_bounded: |
|
2844 fixes s :: "'a::metric_space set" |
|
2845 shows "compact s ==> bounded s" |
|
2846 proof - |
|
2847 assume "compact s" |
|
2848 hence "\<forall>f. (\<forall>t\<in>f. open t) \<and> s \<subseteq> \<Union>f \<longrightarrow> (\<exists>f'\<subseteq>f. finite f' \<and> s \<subseteq> \<Union>f')" |
|
2849 by (rule compact_imp_heine_borel) |
|
2850 hence "\<forall>t. infinite t \<and> t \<subseteq> s \<longrightarrow> (\<exists>x \<in> s. x islimpt t)" |
|
2851 using heine_borel_imp_bolzano_weierstrass[of s] by auto |
|
2852 thus "bounded s" |
|
2853 by (rule bolzano_weierstrass_imp_bounded) |
|
2854 qed |
|
2855 |
|
2856 lemma compact_imp_closed: |
|
2857 fixes s :: "'a::metric_space set" |
|
2858 shows "compact s ==> closed s" |
|
2859 proof - |
|
2860 assume "compact s" |
|
2861 hence "\<forall>f. (\<forall>t\<in>f. open t) \<and> s \<subseteq> \<Union>f \<longrightarrow> (\<exists>f'\<subseteq>f. finite f' \<and> s \<subseteq> \<Union>f')" |
|
2862 by (rule compact_imp_heine_borel) |
|
2863 hence "\<forall>t. infinite t \<and> t \<subseteq> s \<longrightarrow> (\<exists>x \<in> s. x islimpt t)" |
|
2864 using heine_borel_imp_bolzano_weierstrass[of s] by auto |
|
2865 thus "closed s" |
|
2866 by (rule bolzano_weierstrass_imp_closed) |
|
2867 qed |
|
2868 |
|
2869 text{* In particular, some common special cases. *} |
|
2870 |
|
2871 lemma compact_empty[simp]: |
|
2872 "compact {}" |
|
2873 unfolding compact_def |
|
2874 by simp |
|
2875 |
|
2876 (* TODO: can any of the next 3 lemmas be generalized to metric spaces? *) |
|
2877 |
|
2878 (* FIXME : Rename *) |
|
2879 lemma compact_union[intro]: |
|
2880 fixes s t :: "'a::heine_borel set" |
|
2881 shows "compact s \<Longrightarrow> compact t ==> compact (s \<union> t)" |
|
2882 unfolding compact_eq_bounded_closed |
|
2883 using bounded_Un[of s t] |
|
2884 using closed_Un[of s t] |
|
2885 by simp |
|
2886 |
|
2887 lemma compact_inter[intro]: |
|
2888 fixes s t :: "'a::heine_borel set" |
|
2889 shows "compact s \<Longrightarrow> compact t ==> compact (s \<inter> t)" |
|
2890 unfolding compact_eq_bounded_closed |
|
2891 using bounded_Int[of s t] |
|
2892 using closed_Int[of s t] |
|
2893 by simp |
|
2894 |
|
2895 lemma compact_inter_closed[intro]: |
|
2896 fixes s t :: "'a::heine_borel set" |
|
2897 shows "compact s \<Longrightarrow> closed t ==> compact (s \<inter> t)" |
|
2898 unfolding compact_eq_bounded_closed |
|
2899 using closed_Int[of s t] |
|
2900 using bounded_subset[of "s \<inter> t" s] |
|
2901 by blast |
|
2902 |
|
2903 lemma closed_inter_compact[intro]: |
|
2904 fixes s t :: "'a::heine_borel set" |
|
2905 shows "closed s \<Longrightarrow> compact t ==> compact (s \<inter> t)" |
|
2906 proof- |
|
2907 assume "closed s" "compact t" |
|
2908 moreover |
|
2909 have "s \<inter> t = t \<inter> s" by auto ultimately |
|
2910 show ?thesis |
|
2911 using compact_inter_closed[of t s] |
|
2912 by auto |
|
2913 qed |
|
2914 |
|
2915 lemma closed_sing [simp]: |
|
2916 fixes a :: "'a::metric_space" |
|
2917 shows "closed {a}" |
|
2918 apply (clarsimp simp add: closed_def open_dist) |
|
2919 apply (rule ccontr) |
|
2920 apply (drule_tac x="dist x a" in spec) |
|
2921 apply (simp add: dist_nz dist_commute) |
|
2922 done |
|
2923 |
|
2924 lemma finite_imp_closed: |
|
2925 fixes s :: "'a::metric_space set" |
|
2926 shows "finite s ==> closed s" |
|
2927 proof (induct set: finite) |
|
2928 case empty show "closed {}" by simp |
|
2929 next |
|
2930 case (insert x F) |
|
2931 hence "closed ({x} \<union> F)" by (simp only: closed_Un closed_sing) |
|
2932 thus "closed (insert x F)" by simp |
|
2933 qed |
|
2934 |
|
2935 lemma finite_imp_compact: |
|
2936 fixes s :: "'a::heine_borel set" |
|
2937 shows "finite s ==> compact s" |
|
2938 unfolding compact_eq_bounded_closed |
|
2939 using finite_imp_closed finite_imp_bounded |
|
2940 by blast |
|
2941 |
|
2942 lemma compact_sing [simp]: "compact {a}" |
|
2943 unfolding compact_def o_def subseq_def |
|
2944 by (auto simp add: tendsto_const) |
|
2945 |
|
2946 lemma compact_cball[simp]: |
|
2947 fixes x :: "'a::heine_borel" |
|
2948 shows "compact(cball x e)" |
|
2949 using compact_eq_bounded_closed bounded_cball closed_cball |
|
2950 by blast |
|
2951 |
|
2952 lemma compact_frontier_bounded[intro]: |
|
2953 fixes s :: "'a::heine_borel set" |
|
2954 shows "bounded s ==> compact(frontier s)" |
|
2955 unfolding frontier_def |
|
2956 using compact_eq_bounded_closed |
|
2957 by blast |
|
2958 |
|
2959 lemma compact_frontier[intro]: |
|
2960 fixes s :: "'a::heine_borel set" |
|
2961 shows "compact s ==> compact (frontier s)" |
|
2962 using compact_eq_bounded_closed compact_frontier_bounded |
|
2963 by blast |
|
2964 |
|
2965 lemma frontier_subset_compact: |
|
2966 fixes s :: "'a::heine_borel set" |
|
2967 shows "compact s ==> frontier s \<subseteq> s" |
|
2968 using frontier_subset_closed compact_eq_bounded_closed |
|
2969 by blast |
|
2970 |
|
2971 lemma open_delete: |
|
2972 fixes s :: "'a::metric_space set" |
|
2973 shows "open s ==> open(s - {x})" |
|
2974 using open_Diff[of s "{x}"] closed_sing |
|
2975 by blast |
|
2976 |
|
2977 text{* Finite intersection property. I could make it an equivalence in fact. *} |
|
2978 |
|
2979 lemma compact_imp_fip: |
|
2980 fixes s :: "'a::heine_borel set" |
|
2981 assumes "compact s" "\<forall>t \<in> f. closed t" |
|
2982 "\<forall>f'. finite f' \<and> f' \<subseteq> f --> (s \<inter> (\<Inter> f') \<noteq> {})" |
|
2983 shows "s \<inter> (\<Inter> f) \<noteq> {}" |
|
2984 proof |
|
2985 assume as:"s \<inter> (\<Inter> f) = {}" |
|
2986 hence "s \<subseteq> \<Union>op - UNIV ` f" by auto |
|
2987 moreover have "Ball (op - UNIV ` f) open" using open_Diff closed_Diff using assms(2) by auto |
|
2988 ultimately obtain f' where f':"f' \<subseteq> op - UNIV ` f" "finite f'" "s \<subseteq> \<Union>f'" using assms(1)[unfolded compact_eq_heine_borel, THEN spec[where x="(\<lambda>t. UNIV - t) ` f"]] by auto |
|
2989 hence "finite (op - UNIV ` f') \<and> op - UNIV ` f' \<subseteq> f" by(auto simp add: Diff_Diff_Int) |
|
2990 hence "s \<inter> \<Inter>op - UNIV ` f' \<noteq> {}" using assms(3)[THEN spec[where x="op - UNIV ` f'"]] by auto |
|
2991 thus False using f'(3) unfolding subset_eq and Union_iff by blast |
|
2992 qed |
|
2993 |
|
2994 subsection{* Bounded closed nest property (proof does not use Heine-Borel). *} |
|
2995 |
|
2996 lemma bounded_closed_nest: |
|
2997 assumes "\<forall>n. closed(s n)" "\<forall>n. (s n \<noteq> {})" |
|
2998 "(\<forall>m n. m \<le> n --> s n \<subseteq> s m)" "bounded(s 0)" |
|
2999 shows "\<exists>a::'a::heine_borel. \<forall>n::nat. a \<in> s(n)" |
|
3000 proof- |
|
3001 from assms(2) obtain x where x:"\<forall>n::nat. x n \<in> s n" using choice[of "\<lambda>n x. x\<in> s n"] by auto |
|
3002 from assms(4,1) have *:"compact (s 0)" using bounded_closed_imp_compact[of "s 0"] by auto |
|
3003 |
|
3004 then obtain l r where lr:"l\<in>s 0" "subseq r" "((x \<circ> r) ---> l) sequentially" |
|
3005 unfolding compact_def apply(erule_tac x=x in allE) using x using assms(3) by blast |
|
3006 |
|
3007 { fix n::nat |
|
3008 { fix e::real assume "e>0" |
|
3009 with lr(3) obtain N where N:"\<forall>m\<ge>N. dist ((x \<circ> r) m) l < e" unfolding Lim_sequentially by auto |
|
3010 hence "dist ((x \<circ> r) (max N n)) l < e" by auto |
|
3011 moreover |
|
3012 have "r (max N n) \<ge> n" using lr(2) using subseq_bigger[of r "max N n"] by auto |
|
3013 hence "(x \<circ> r) (max N n) \<in> s n" |
|
3014 using x apply(erule_tac x=n in allE) |
|
3015 using x apply(erule_tac x="r (max N n)" in allE) |
|
3016 using assms(3) apply(erule_tac x=n in allE)apply( erule_tac x="r (max N n)" in allE) by auto |
|
3017 ultimately have "\<exists>y\<in>s n. dist y l < e" by auto |
|
3018 } |
|
3019 hence "l \<in> s n" using closed_approachable[of "s n" l] assms(1) by blast |
|
3020 } |
|
3021 thus ?thesis by auto |
|
3022 qed |
|
3023 |
|
3024 text{* Decreasing case does not even need compactness, just completeness. *} |
|
3025 |
|
3026 lemma decreasing_closed_nest: |
|
3027 assumes "\<forall>n. closed(s n)" |
|
3028 "\<forall>n. (s n \<noteq> {})" |
|
3029 "\<forall>m n. m \<le> n --> s n \<subseteq> s m" |
|
3030 "\<forall>e>0. \<exists>n. \<forall>x \<in> (s n). \<forall> y \<in> (s n). dist x y < e" |
|
3031 shows "\<exists>a::'a::heine_borel. \<forall>n::nat. a \<in> s n" |
|
3032 proof- |
|
3033 have "\<forall>n. \<exists> x. x\<in>s n" using assms(2) by auto |
|
3034 hence "\<exists>t. \<forall>n. t n \<in> s n" using choice[of "\<lambda> n x. x \<in> s n"] by auto |
|
3035 then obtain t where t: "\<forall>n. t n \<in> s n" by auto |
|
3036 { fix e::real assume "e>0" |
|
3037 then obtain N where N:"\<forall>x\<in>s N. \<forall>y\<in>s N. dist x y < e" using assms(4) by auto |
|
3038 { fix m n ::nat assume "N \<le> m \<and> N \<le> n" |
|
3039 hence "t m \<in> s N" "t n \<in> s N" using assms(3) t unfolding subset_eq t by blast+ |
|
3040 hence "dist (t m) (t n) < e" using N by auto |
|
3041 } |
|
3042 hence "\<exists>N. \<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist (t m) (t n) < e" by auto |
|
3043 } |
|
3044 hence "Cauchy t" unfolding cauchy_def by auto |
|
3045 then obtain l where l:"(t ---> l) sequentially" using complete_univ unfolding complete_def by auto |
|
3046 { fix n::nat |
|
3047 { fix e::real assume "e>0" |
|
3048 then obtain N::nat where N:"\<forall>n\<ge>N. dist (t n) l < e" using l[unfolded Lim_sequentially] by auto |
|
3049 have "t (max n N) \<in> s n" using assms(3) unfolding subset_eq apply(erule_tac x=n in allE) apply (erule_tac x="max n N" in allE) using t by auto |
|
3050 hence "\<exists>y\<in>s n. dist y l < e" apply(rule_tac x="t (max n N)" in bexI) using N by auto |
|
3051 } |
|
3052 hence "l \<in> s n" using closed_approachable[of "s n" l] assms(1) by auto |
|
3053 } |
|
3054 then show ?thesis by auto |
|
3055 qed |
|
3056 |
|
3057 text{* Strengthen it to the intersection actually being a singleton. *} |
|
3058 |
|
3059 lemma decreasing_closed_nest_sing: |
|
3060 assumes "\<forall>n. closed(s n)" |
|
3061 "\<forall>n. s n \<noteq> {}" |
|
3062 "\<forall>m n. m \<le> n --> s n \<subseteq> s m" |
|
3063 "\<forall>e>0. \<exists>n. \<forall>x \<in> (s n). \<forall> y\<in>(s n). dist x y < e" |
|
3064 shows "\<exists>a::'a::heine_borel. \<Inter> {t. (\<exists>n::nat. t = s n)} = {a}" |
|
3065 proof- |
|
3066 obtain a where a:"\<forall>n. a \<in> s n" using decreasing_closed_nest[of s] using assms by auto |
|
3067 { fix b assume b:"b \<in> \<Inter>{t. \<exists>n. t = s n}" |
|
3068 { fix e::real assume "e>0" |
|
3069 hence "dist a b < e" using assms(4 )using b using a by blast |
|
3070 } |
|
3071 hence "dist a b = 0" by (metis dist_eq_0_iff dist_nz real_less_def) |
|
3072 } |
|
3073 with a have "\<Inter>{t. \<exists>n. t = s n} = {a}" by auto |
|
3074 thus ?thesis by auto |
|
3075 qed |
|
3076 |
|
3077 text{* Cauchy-type criteria for uniform convergence. *} |
|
3078 |
|
3079 lemma uniformly_convergent_eq_cauchy: fixes s::"nat \<Rightarrow> 'b \<Rightarrow> 'a::heine_borel" shows |
|
3080 "(\<exists>l. \<forall>e>0. \<exists>N. \<forall>n x. N \<le> n \<and> P x --> dist(s n x)(l x) < e) \<longleftrightarrow> |
|
3081 (\<forall>e>0. \<exists>N. \<forall>m n x. N \<le> m \<and> N \<le> n \<and> P x --> dist (s m x) (s n x) < e)" (is "?lhs = ?rhs") |
|
3082 proof(rule) |
|
3083 assume ?lhs |
|
3084 then obtain l where l:"\<forall>e>0. \<exists>N. \<forall>n x. N \<le> n \<and> P x \<longrightarrow> dist (s n x) (l x) < e" by auto |
|
3085 { fix e::real assume "e>0" |
|
3086 then obtain N::nat where N:"\<forall>n x. N \<le> n \<and> P x \<longrightarrow> dist (s n x) (l x) < e / 2" using l[THEN spec[where x="e/2"]] by auto |
|
3087 { fix n m::nat and x::"'b" assume "N \<le> m \<and> N \<le> n \<and> P x" |
|
3088 hence "dist (s m x) (s n x) < e" |
|
3089 using N[THEN spec[where x=m], THEN spec[where x=x]] |
|
3090 using N[THEN spec[where x=n], THEN spec[where x=x]] |
|
3091 using dist_triangle_half_l[of "s m x" "l x" e "s n x"] by auto } |
|
3092 hence "\<exists>N. \<forall>m n x. N \<le> m \<and> N \<le> n \<and> P x --> dist (s m x) (s n x) < e" by auto } |
|
3093 thus ?rhs by auto |
|
3094 next |
|
3095 assume ?rhs |
|
3096 hence "\<forall>x. P x \<longrightarrow> Cauchy (\<lambda>n. s n x)" unfolding cauchy_def apply auto by (erule_tac x=e in allE)auto |
|
3097 then obtain l where l:"\<forall>x. P x \<longrightarrow> ((\<lambda>n. s n x) ---> l x) sequentially" unfolding convergent_eq_cauchy[THEN sym] |
|
3098 using choice[of "\<lambda>x l. P x \<longrightarrow> ((\<lambda>n. s n x) ---> l) sequentially"] by auto |
|
3099 { fix e::real assume "e>0" |
|
3100 then obtain N where N:"\<forall>m n x. N \<le> m \<and> N \<le> n \<and> P x \<longrightarrow> dist (s m x) (s n x) < e/2" |
|
3101 using `?rhs`[THEN spec[where x="e/2"]] by auto |
|
3102 { fix x assume "P x" |
|
3103 then obtain M where M:"\<forall>n\<ge>M. dist (s n x) (l x) < e/2" |
|
3104 using l[THEN spec[where x=x], unfolded Lim_sequentially] using `e>0` by(auto elim!: allE[where x="e/2"]) |
|
3105 fix n::nat assume "n\<ge>N" |
|
3106 hence "dist(s n x)(l x) < e" using `P x`and N[THEN spec[where x=n], THEN spec[where x="N+M"], THEN spec[where x=x]] |
|
3107 using M[THEN spec[where x="N+M"]] and dist_triangle_half_l[of "s n x" "s (N+M) x" e "l x"] by (auto simp add: dist_commute) } |
|
3108 hence "\<exists>N. \<forall>n x. N \<le> n \<and> P x \<longrightarrow> dist(s n x)(l x) < e" by auto } |
|
3109 thus ?lhs by auto |
|
3110 qed |
|
3111 |
|
3112 lemma uniformly_cauchy_imp_uniformly_convergent: |
|
3113 fixes s :: "nat \<Rightarrow> 'a \<Rightarrow> 'b::heine_borel" |
|
3114 assumes "\<forall>e>0.\<exists>N. \<forall>m (n::nat) x. N \<le> m \<and> N \<le> n \<and> P x --> dist(s m x)(s n x) < e" |
|
3115 "\<forall>x. P x --> (\<forall>e>0. \<exists>N. \<forall>n. N \<le> n --> dist(s n x)(l x) < e)" |
|
3116 shows "\<forall>e>0. \<exists>N. \<forall>n x. N \<le> n \<and> P x --> dist(s n x)(l x) < e" |
|
3117 proof- |
|
3118 obtain l' where l:"\<forall>e>0. \<exists>N. \<forall>n x. N \<le> n \<and> P x \<longrightarrow> dist (s n x) (l' x) < e" |
|
3119 using assms(1) unfolding uniformly_convergent_eq_cauchy[THEN sym] by auto |
|
3120 moreover |
|
3121 { fix x assume "P x" |
|
3122 hence "l x = l' x" using Lim_unique[OF trivial_limit_sequentially, of "\<lambda>n. s n x" "l x" "l' x"] |
|
3123 using l and assms(2) unfolding Lim_sequentially by blast } |
|
3124 ultimately show ?thesis by auto |
|
3125 qed |
|
3126 |
|
3127 subsection{* Define continuity over a net to take in restrictions of the set. *} |
|
3128 |
|
3129 definition |
|
3130 continuous :: "'a::t2_space net \<Rightarrow> ('a \<Rightarrow> 'b::topological_space) \<Rightarrow> bool" where |
|
3131 "continuous net f \<longleftrightarrow> (f ---> f(netlimit net)) net" |
|
3132 |
|
3133 lemma continuous_trivial_limit: |
|
3134 "trivial_limit net ==> continuous net f" |
|
3135 unfolding continuous_def tendsto_def trivial_limit_eq by auto |
|
3136 |
|
3137 lemma continuous_within: "continuous (at x within s) f \<longleftrightarrow> (f ---> f(x)) (at x within s)" |
|
3138 unfolding continuous_def |
|
3139 unfolding tendsto_def |
|
3140 using netlimit_within[of x s] |
|
3141 by (cases "trivial_limit (at x within s)") (auto simp add: trivial_limit_eventually) |
|
3142 |
|
3143 lemma continuous_at: "continuous (at x) f \<longleftrightarrow> (f ---> f(x)) (at x)" |
|
3144 using continuous_within [of x UNIV f] by (simp add: within_UNIV) |
|
3145 |
|
3146 lemma continuous_at_within: |
|
3147 assumes "continuous (at x) f" shows "continuous (at x within s) f" |
|
3148 using assms unfolding continuous_at continuous_within |
|
3149 by (rule Lim_at_within) |
|
3150 |
|
3151 text{* Derive the epsilon-delta forms, which we often use as "definitions" *} |
|
3152 |
|
3153 lemma continuous_within_eps_delta: |
|
3154 "continuous (at x within s) f \<longleftrightarrow> (\<forall>e>0. \<exists>d>0. \<forall>x'\<in> s. dist x' x < d --> dist (f x') (f x) < e)" |
|
3155 unfolding continuous_within and Lim_within |
|
3156 apply auto unfolding dist_nz[THEN sym] apply(auto elim!:allE) apply(rule_tac x=d in exI) by auto |
|
3157 |
|
3158 lemma continuous_at_eps_delta: "continuous (at x) f \<longleftrightarrow> (\<forall>e>0. \<exists>d>0. |
|
3159 \<forall>x'. dist x' x < d --> dist(f x')(f x) < e)" |
|
3160 using continuous_within_eps_delta[of x UNIV f] |
|
3161 unfolding within_UNIV by blast |
|
3162 |
|
3163 text{* Versions in terms of open balls. *} |
|
3164 |
|
3165 lemma continuous_within_ball: |
|
3166 "continuous (at x within s) f \<longleftrightarrow> (\<forall>e>0. \<exists>d>0. |
|
3167 f ` (ball x d \<inter> s) \<subseteq> ball (f x) e)" (is "?lhs = ?rhs") |
|
3168 proof |
|
3169 assume ?lhs |
|
3170 { fix e::real assume "e>0" |
|
3171 then obtain d where d: "d>0" "\<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (f x) < e" |
|
3172 using `?lhs`[unfolded continuous_within Lim_within] by auto |
|
3173 { fix y assume "y\<in>f ` (ball x d \<inter> s)" |
|
3174 hence "y \<in> ball (f x) e" using d(2) unfolding dist_nz[THEN sym] |
|
3175 apply (auto simp add: dist_commute mem_ball) apply(erule_tac x=xa in ballE) apply auto using `e>0` by auto |
|
3176 } |
|
3177 hence "\<exists>d>0. f ` (ball x d \<inter> s) \<subseteq> ball (f x) e" using `d>0` unfolding subset_eq ball_def by (auto simp add: dist_commute) } |
|
3178 thus ?rhs by auto |
|
3179 next |
|
3180 assume ?rhs thus ?lhs unfolding continuous_within Lim_within ball_def subset_eq |
|
3181 apply (auto simp add: dist_commute) apply(erule_tac x=e in allE) by auto |
|
3182 qed |
|
3183 |
|
3184 lemma continuous_at_ball: |
|
3185 "continuous (at x) f \<longleftrightarrow> (\<forall>e>0. \<exists>d>0. f ` (ball x d) \<subseteq> ball (f x) e)" (is "?lhs = ?rhs") |
|
3186 proof |
|
3187 assume ?lhs thus ?rhs unfolding continuous_at Lim_at subset_eq Ball_def Bex_def image_iff mem_ball |
|
3188 apply auto apply(erule_tac x=e in allE) apply auto apply(rule_tac x=d in exI) apply auto apply(erule_tac x=xa in allE) apply (auto simp add: dist_commute dist_nz) |
|
3189 unfolding dist_nz[THEN sym] by auto |
|
3190 next |
|
3191 assume ?rhs thus ?lhs unfolding continuous_at Lim_at subset_eq Ball_def Bex_def image_iff mem_ball |
|
3192 apply auto apply(erule_tac x=e in allE) apply auto apply(rule_tac x=d in exI) apply auto apply(erule_tac x="f xa" in allE) by (auto simp add: dist_commute dist_nz) |
|
3193 qed |
|
3194 |
|
3195 text{* For setwise continuity, just start from the epsilon-delta definitions. *} |
|
3196 |
|
3197 definition |
|
3198 continuous_on :: "'a::metric_space set \<Rightarrow> ('a \<Rightarrow> 'b::metric_space) \<Rightarrow> bool" where |
|
3199 "continuous_on s f \<longleftrightarrow> (\<forall>x \<in> s. \<forall>e>0. \<exists>d::real>0. \<forall>x' \<in> s. dist x' x < d --> dist (f x') (f x) < e)" |
|
3200 |
|
3201 |
|
3202 definition |
|
3203 uniformly_continuous_on :: |
|
3204 "'a::metric_space set \<Rightarrow> ('a \<Rightarrow> 'b::metric_space) \<Rightarrow> bool" where |
|
3205 "uniformly_continuous_on s f \<longleftrightarrow> |
|
3206 (\<forall>e>0. \<exists>d>0. \<forall>x\<in>s. \<forall> x'\<in>s. dist x' x < d |
|
3207 --> dist (f x') (f x) < e)" |
|
3208 |
|
3209 text{* Some simple consequential lemmas. *} |
|
3210 |
|
3211 lemma uniformly_continuous_imp_continuous: |
|
3212 " uniformly_continuous_on s f ==> continuous_on s f" |
|
3213 unfolding uniformly_continuous_on_def continuous_on_def by blast |
|
3214 |
|
3215 lemma continuous_at_imp_continuous_within: |
|
3216 "continuous (at x) f ==> continuous (at x within s) f" |
|
3217 unfolding continuous_within continuous_at using Lim_at_within by auto |
|
3218 |
|
3219 lemma continuous_at_imp_continuous_on: assumes "(\<forall>x \<in> s. continuous (at x) f)" |
|
3220 shows "continuous_on s f" |
|
3221 proof(simp add: continuous_at continuous_on_def, rule, rule, rule) |
|
3222 fix x and e::real assume "x\<in>s" "e>0" |
|
3223 hence "eventually (\<lambda>xa. dist (f xa) (f x) < e) (at x)" using assms unfolding continuous_at tendsto_iff by auto |
|
3224 then obtain d where d:"d>0" "\<forall>xa. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (f x) < e" unfolding eventually_at by auto |
|
3225 { fix x' assume "\<not> 0 < dist x' x" |
|
3226 hence "x=x'" |
|
3227 using dist_nz[of x' x] by auto |
|
3228 hence "dist (f x') (f x) < e" using `e>0` by auto |
|
3229 } |
|
3230 thus "\<exists>d>0. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (f x') (f x) < e" using d by auto |
|
3231 qed |
|
3232 |
|
3233 lemma continuous_on_eq_continuous_within: |
|
3234 "continuous_on s f \<longleftrightarrow> (\<forall>x \<in> s. continuous (at x within s) f)" (is "?lhs = ?rhs") |
|
3235 proof |
|
3236 assume ?rhs |
|
3237 { fix x assume "x\<in>s" |
|
3238 fix e::real assume "e>0" |
|
3239 assume "\<exists>d>0. \<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (f x) < e" |
|
3240 then obtain d where "d>0" and d:"\<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (f x) < e" by auto |
|
3241 { fix x' assume as:"x'\<in>s" "dist x' x < d" |
|
3242 hence "dist (f x') (f x) < e" using `e>0` d `x'\<in>s` dist_eq_0_iff[of x' x] zero_le_dist[of x' x] as(2) by (metis dist_eq_0_iff dist_nz) } |
|
3243 hence "\<exists>d>0. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (f x') (f x) < e" using `d>0` by auto |
|
3244 } |
|
3245 thus ?lhs using `?rhs` unfolding continuous_on_def continuous_within Lim_within by auto |
|
3246 next |
|
3247 assume ?lhs |
|
3248 thus ?rhs unfolding continuous_on_def continuous_within Lim_within by blast |
|
3249 qed |
|
3250 |
|
3251 lemma continuous_on: |
|
3252 "continuous_on s f \<longleftrightarrow> (\<forall>x \<in> s. (f ---> f(x)) (at x within s))" |
|
3253 by (auto simp add: continuous_on_eq_continuous_within continuous_within) |
|
3254 |
|
3255 lemma continuous_on_eq_continuous_at: |
|
3256 "open s ==> (continuous_on s f \<longleftrightarrow> (\<forall>x \<in> s. continuous (at x) f))" |
|
3257 by (auto simp add: continuous_on continuous_at Lim_within_open) |
|
3258 |
|
3259 lemma continuous_within_subset: |
|
3260 "continuous (at x within s) f \<Longrightarrow> t \<subseteq> s |
|
3261 ==> continuous (at x within t) f" |
|
3262 unfolding continuous_within by(metis Lim_within_subset) |
|
3263 |
|
3264 lemma continuous_on_subset: |
|
3265 "continuous_on s f \<Longrightarrow> t \<subseteq> s ==> continuous_on t f" |
|
3266 unfolding continuous_on by (metis subset_eq Lim_within_subset) |
|
3267 |
|
3268 lemma continuous_on_interior: |
|
3269 "continuous_on s f \<Longrightarrow> x \<in> interior s ==> continuous (at x) f" |
|
3270 unfolding interior_def |
|
3271 apply simp |
|
3272 by (meson continuous_on_eq_continuous_at continuous_on_subset) |
|
3273 |
|
3274 lemma continuous_on_eq: |
|
3275 "(\<forall>x \<in> s. f x = g x) \<Longrightarrow> continuous_on s f |
|
3276 ==> continuous_on s g" |
|
3277 by (simp add: continuous_on_def) |
|
3278 |
|
3279 text{* Characterization of various kinds of continuity in terms of sequences. *} |
|
3280 |
|
3281 (* \<longrightarrow> could be generalized, but \<longleftarrow> requires metric space *) |
|
3282 lemma continuous_within_sequentially: |
|
3283 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" |
|
3284 shows "continuous (at a within s) f \<longleftrightarrow> |
|
3285 (\<forall>x. (\<forall>n::nat. x n \<in> s) \<and> (x ---> a) sequentially |
|
3286 --> ((f o x) ---> f a) sequentially)" (is "?lhs = ?rhs") |
|
3287 proof |
|
3288 assume ?lhs |
|
3289 { fix x::"nat \<Rightarrow> 'a" assume x:"\<forall>n. x n \<in> s" "\<forall>e>0. \<exists>N. \<forall>n\<ge>N. dist (x n) a < e" |
|
3290 fix e::real assume "e>0" |
|
3291 from `?lhs` obtain d where "d>0" and d:"\<forall>x\<in>s. 0 < dist x a \<and> dist x a < d \<longrightarrow> dist (f x) (f a) < e" unfolding continuous_within Lim_within using `e>0` by auto |
|
3292 from x(2) `d>0` obtain N where N:"\<forall>n\<ge>N. dist (x n) a < d" by auto |
|
3293 hence "\<exists>N. \<forall>n\<ge>N. dist ((f \<circ> x) n) (f a) < e" |
|
3294 apply(rule_tac x=N in exI) using N d apply auto using x(1) |
|
3295 apply(erule_tac x=n in allE) apply(erule_tac x=n in allE) |
|
3296 apply(erule_tac x="x n" in ballE) apply auto unfolding dist_nz[THEN sym] apply auto using `e>0` by auto |
|
3297 } |
|
3298 thus ?rhs unfolding continuous_within unfolding Lim_sequentially by simp |
|
3299 next |
|
3300 assume ?rhs |
|
3301 { fix e::real assume "e>0" |
|
3302 assume "\<not> (\<exists>d>0. \<forall>x\<in>s. 0 < dist x a \<and> dist x a < d \<longrightarrow> dist (f x) (f a) < e)" |
|
3303 hence "\<forall>d. \<exists>x. d>0 \<longrightarrow> x\<in>s \<and> (0 < dist x a \<and> dist x a < d \<and> \<not> dist (f x) (f a) < e)" by blast |
|
3304 then obtain x where x:"\<forall>d>0. x d \<in> s \<and> (0 < dist (x d) a \<and> dist (x d) a < d \<and> \<not> dist (f (x d)) (f a) < e)" |
|
3305 using choice[of "\<lambda>d x.0<d \<longrightarrow> x\<in>s \<and> (0 < dist x a \<and> dist x a < d \<and> \<not> dist (f x) (f a) < e)"] by auto |
|
3306 { fix d::real assume "d>0" |
|
3307 hence "\<exists>N::nat. inverse (real (N + 1)) < d" using real_arch_inv[of d] by (auto, rule_tac x="n - 1" in exI)auto |
|
3308 then obtain N::nat where N:"inverse (real (N + 1)) < d" by auto |
|
3309 { fix n::nat assume n:"n\<ge>N" |
|
3310 hence "dist (x (inverse (real (n + 1)))) a < inverse (real (n + 1))" using x[THEN spec[where x="inverse (real (n + 1))"]] by auto |
|
3311 moreover have "inverse (real (n + 1)) < d" using N n by (auto, metis Suc_le_mono le_SucE less_imp_inverse_less nat_le_real_less order_less_trans real_of_nat_Suc real_of_nat_Suc_gt_zero) |
|
3312 ultimately have "dist (x (inverse (real (n + 1)))) a < d" by auto |
|
3313 } |
|
3314 hence "\<exists>N::nat. \<forall>n\<ge>N. dist (x (inverse (real (n + 1)))) a < d" by auto |
|
3315 } |
|
3316 hence "(\<forall>n::nat. x (inverse (real (n + 1))) \<in> s) \<and> (\<forall>e>0. \<exists>N::nat. \<forall>n\<ge>N. dist (x (inverse (real (n + 1)))) a < e)" using x by auto |
|
3317 hence "\<forall>e>0. \<exists>N::nat. \<forall>n\<ge>N. dist (f (x (inverse (real (n + 1))))) (f a) < e" using `?rhs`[THEN spec[where x="\<lambda>n::nat. x (inverse (real (n+1)))"], unfolded Lim_sequentially] by auto |
|
3318 hence "False" apply(erule_tac x=e in allE) using `e>0` using x by auto |
|
3319 } |
|
3320 thus ?lhs unfolding continuous_within unfolding Lim_within unfolding Lim_sequentially by blast |
|
3321 qed |
|
3322 |
|
3323 lemma continuous_at_sequentially: |
|
3324 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" |
|
3325 shows "continuous (at a) f \<longleftrightarrow> (\<forall>x. (x ---> a) sequentially |
|
3326 --> ((f o x) ---> f a) sequentially)" |
|
3327 using continuous_within_sequentially[of a UNIV f] unfolding within_UNIV by auto |
|
3328 |
|
3329 lemma continuous_on_sequentially: |
|
3330 "continuous_on s f \<longleftrightarrow> (\<forall>x. \<forall>a \<in> s. (\<forall>n. x(n) \<in> s) \<and> (x ---> a) sequentially |
|
3331 --> ((f o x) ---> f(a)) sequentially)" (is "?lhs = ?rhs") |
|
3332 proof |
|
3333 assume ?rhs thus ?lhs using continuous_within_sequentially[of _ s f] unfolding continuous_on_eq_continuous_within by auto |
|
3334 next |
|
3335 assume ?lhs thus ?rhs unfolding continuous_on_eq_continuous_within using continuous_within_sequentially[of _ s f] by auto |
|
3336 qed |
|
3337 |
|
3338 lemma uniformly_continuous_on_sequentially: |
|
3339 fixes f :: "'a::real_normed_vector \<Rightarrow> 'b::real_normed_vector" |
|
3340 shows "uniformly_continuous_on s f \<longleftrightarrow> (\<forall>x y. (\<forall>n. x n \<in> s) \<and> (\<forall>n. y n \<in> s) \<and> |
|
3341 ((\<lambda>n. x n - y n) ---> 0) sequentially |
|
3342 \<longrightarrow> ((\<lambda>n. f(x n) - f(y n)) ---> 0) sequentially)" (is "?lhs = ?rhs") |
|
3343 proof |
|
3344 assume ?lhs |
|
3345 { fix x y assume x:"\<forall>n. x n \<in> s" and y:"\<forall>n. y n \<in> s" and xy:"((\<lambda>n. x n - y n) ---> 0) sequentially" |
|
3346 { fix e::real assume "e>0" |
|
3347 then obtain d where "d>0" and d:"\<forall>x\<in>s. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (f x') (f x) < e" |
|
3348 using `?lhs`[unfolded uniformly_continuous_on_def, THEN spec[where x=e]] by auto |
|
3349 obtain N where N:"\<forall>n\<ge>N. norm (x n - y n - 0) < d" using xy[unfolded Lim_sequentially dist_norm] and `d>0` by auto |
|
3350 { fix n assume "n\<ge>N" |
|
3351 hence "norm (f (x n) - f (y n) - 0) < e" |
|
3352 using N[THEN spec[where x=n]] using d[THEN bspec[where x="x n"], THEN bspec[where x="y n"]] using x and y |
|
3353 unfolding dist_commute and dist_norm by simp } |
|
3354 hence "\<exists>N. \<forall>n\<ge>N. norm (f (x n) - f (y n) - 0) < e" by auto } |
|
3355 hence "((\<lambda>n. f(x n) - f(y n)) ---> 0) sequentially" unfolding Lim_sequentially and dist_norm by auto } |
|
3356 thus ?rhs by auto |
|
3357 next |
|
3358 assume ?rhs |
|
3359 { assume "\<not> ?lhs" |
|
3360 then obtain e where "e>0" "\<forall>d>0. \<exists>x\<in>s. \<exists>x'\<in>s. dist x' x < d \<and> \<not> dist (f x') (f x) < e" unfolding uniformly_continuous_on_def by auto |
|
3361 then obtain fa where fa:"\<forall>x. 0 < x \<longrightarrow> fst (fa x) \<in> s \<and> snd (fa x) \<in> s \<and> dist (fst (fa x)) (snd (fa x)) < x \<and> \<not> dist (f (fst (fa x))) (f (snd (fa x))) < e" |
|
3362 using choice[of "\<lambda>d x. d>0 \<longrightarrow> fst x \<in> s \<and> snd x \<in> s \<and> dist (snd x) (fst x) < d \<and> \<not> dist (f (snd x)) (f (fst x)) < e"] unfolding Bex_def |
|
3363 by (auto simp add: dist_commute) |
|
3364 def x \<equiv> "\<lambda>n::nat. fst (fa (inverse (real n + 1)))" |
|
3365 def y \<equiv> "\<lambda>n::nat. snd (fa (inverse (real n + 1)))" |
|
3366 have xyn:"\<forall>n. x n \<in> s \<and> y n \<in> s" and xy0:"\<forall>n. dist (x n) (y n) < inverse (real n + 1)" and fxy:"\<forall>n. \<not> dist (f (x n)) (f (y n)) < e" |
|
3367 unfolding x_def and y_def using fa by auto |
|
3368 have 1:"\<And>(x::'a) y. dist (x - y) 0 = dist x y" unfolding dist_norm by auto |
|
3369 have 2:"\<And>(x::'b) y. dist (x - y) 0 = dist x y" unfolding dist_norm by auto |
|
3370 { fix e::real assume "e>0" |
|
3371 then obtain N::nat where "N \<noteq> 0" and N:"0 < inverse (real N) \<and> inverse (real N) < e" unfolding real_arch_inv[of e] by auto |
|
3372 { fix n::nat assume "n\<ge>N" |
|
3373 hence "inverse (real n + 1) < inverse (real N)" using real_of_nat_ge_zero and `N\<noteq>0` by auto |
|
3374 also have "\<dots> < e" using N by auto |
|
3375 finally have "inverse (real n + 1) < e" by auto |
|
3376 hence "dist (x n - y n) 0 < e" unfolding 1 using xy0[THEN spec[where x=n]] by auto } |
|
3377 hence "\<exists>N. \<forall>n\<ge>N. dist (x n - y n) 0 < e" by auto } |
|
3378 hence "\<forall>e>0. \<exists>N. \<forall>n\<ge>N. dist (f (x n) - f (y n)) 0 < e" using `?rhs`[THEN spec[where x=x], THEN spec[where x=y]] and xyn unfolding Lim_sequentially by auto |
|
3379 hence False unfolding 2 using fxy and `e>0` by auto } |
|
3380 thus ?lhs unfolding uniformly_continuous_on_def by blast |
|
3381 qed |
|
3382 |
|
3383 text{* The usual transformation theorems. *} |
|
3384 |
|
3385 lemma continuous_transform_within: |
|
3386 fixes f g :: "'a::metric_space \<Rightarrow> 'b::metric_space" |
|
3387 assumes "0 < d" "x \<in> s" "\<forall>x' \<in> s. dist x' x < d --> f x' = g x'" |
|
3388 "continuous (at x within s) f" |
|
3389 shows "continuous (at x within s) g" |
|
3390 proof- |
|
3391 { fix e::real assume "e>0" |
|
3392 then obtain d' where d':"d'>0" "\<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d' \<longrightarrow> dist (f xa) (f x) < e" using assms(4) unfolding continuous_within Lim_within by auto |
|
3393 { fix x' assume "x'\<in>s" "0 < dist x' x" "dist x' x < (min d d')" |
|
3394 hence "dist (f x') (g x) < e" using assms(2,3) apply(erule_tac x=x in ballE) using d' by auto } |
|
3395 hence "\<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < (min d d') \<longrightarrow> dist (f xa) (g x) < e" by blast |
|
3396 hence "\<exists>d>0. \<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (g x) < e" using `d>0` `d'>0` by(rule_tac x="min d d'" in exI)auto } |
|
3397 hence "(f ---> g x) (at x within s)" unfolding Lim_within using assms(1) by auto |
|
3398 thus ?thesis unfolding continuous_within using Lim_transform_within[of d s x f g "g x"] using assms by blast |
|
3399 qed |
|
3400 |
|
3401 lemma continuous_transform_at: |
|
3402 fixes f g :: "'a::metric_space \<Rightarrow> 'b::metric_space" |
|
3403 assumes "0 < d" "\<forall>x'. dist x' x < d --> f x' = g x'" |
|
3404 "continuous (at x) f" |
|
3405 shows "continuous (at x) g" |
|
3406 proof- |
|
3407 { fix e::real assume "e>0" |
|
3408 then obtain d' where d':"d'>0" "\<forall>xa. 0 < dist xa x \<and> dist xa x < d' \<longrightarrow> dist (f xa) (f x) < e" using assms(3) unfolding continuous_at Lim_at by auto |
|
3409 { fix x' assume "0 < dist x' x" "dist x' x < (min d d')" |
|
3410 hence "dist (f x') (g x) < e" using assms(2) apply(erule_tac x=x in allE) using d' by auto |
|
3411 } |
|
3412 hence "\<forall>xa. 0 < dist xa x \<and> dist xa x < (min d d') \<longrightarrow> dist (f xa) (g x) < e" by blast |
|
3413 hence "\<exists>d>0. \<forall>xa. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (g x) < e" using `d>0` `d'>0` by(rule_tac x="min d d'" in exI)auto |
|
3414 } |
|
3415 hence "(f ---> g x) (at x)" unfolding Lim_at using assms(1) by auto |
|
3416 thus ?thesis unfolding continuous_at using Lim_transform_at[of d x f g "g x"] using assms by blast |
|
3417 qed |
|
3418 |
|
3419 text{* Combination results for pointwise continuity. *} |
|
3420 |
|
3421 lemma continuous_const: "continuous net (\<lambda>x. c)" |
|
3422 by (auto simp add: continuous_def Lim_const) |
|
3423 |
|
3424 lemma continuous_cmul: |
|
3425 fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector" |
|
3426 shows "continuous net f ==> continuous net (\<lambda>x. c *\<^sub>R f x)" |
|
3427 by (auto simp add: continuous_def Lim_cmul) |
|
3428 |
|
3429 lemma continuous_neg: |
|
3430 fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector" |
|
3431 shows "continuous net f ==> continuous net (\<lambda>x. -(f x))" |
|
3432 by (auto simp add: continuous_def Lim_neg) |
|
3433 |
|
3434 lemma continuous_add: |
|
3435 fixes f g :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector" |
|
3436 shows "continuous net f \<Longrightarrow> continuous net g \<Longrightarrow> continuous net (\<lambda>x. f x + g x)" |
|
3437 by (auto simp add: continuous_def Lim_add) |
|
3438 |
|
3439 lemma continuous_sub: |
|
3440 fixes f g :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector" |
|
3441 shows "continuous net f \<Longrightarrow> continuous net g \<Longrightarrow> continuous net (\<lambda>x. f x - g x)" |
|
3442 by (auto simp add: continuous_def Lim_sub) |
|
3443 |
|
3444 text{* Same thing for setwise continuity. *} |
|
3445 |
|
3446 lemma continuous_on_const: |
|
3447 "continuous_on s (\<lambda>x. c)" |
|
3448 unfolding continuous_on_eq_continuous_within using continuous_const by blast |
|
3449 |
|
3450 lemma continuous_on_cmul: |
|
3451 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3452 shows "continuous_on s f ==> continuous_on s (\<lambda>x. c *\<^sub>R (f x))" |
|
3453 unfolding continuous_on_eq_continuous_within using continuous_cmul by blast |
|
3454 |
|
3455 lemma continuous_on_neg: |
|
3456 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3457 shows "continuous_on s f \<Longrightarrow> continuous_on s (\<lambda>x. - f x)" |
|
3458 unfolding continuous_on_eq_continuous_within using continuous_neg by blast |
|
3459 |
|
3460 lemma continuous_on_add: |
|
3461 fixes f g :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3462 shows "continuous_on s f \<Longrightarrow> continuous_on s g |
|
3463 \<Longrightarrow> continuous_on s (\<lambda>x. f x + g x)" |
|
3464 unfolding continuous_on_eq_continuous_within using continuous_add by blast |
|
3465 |
|
3466 lemma continuous_on_sub: |
|
3467 fixes f g :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3468 shows "continuous_on s f \<Longrightarrow> continuous_on s g |
|
3469 \<Longrightarrow> continuous_on s (\<lambda>x. f x - g x)" |
|
3470 unfolding continuous_on_eq_continuous_within using continuous_sub by blast |
|
3471 |
|
3472 text{* Same thing for uniform continuity, using sequential formulations. *} |
|
3473 |
|
3474 lemma uniformly_continuous_on_const: |
|
3475 "uniformly_continuous_on s (\<lambda>x. c)" |
|
3476 unfolding uniformly_continuous_on_def by simp |
|
3477 |
|
3478 lemma uniformly_continuous_on_cmul: |
|
3479 fixes f :: "'a::real_normed_vector \<Rightarrow> 'b::real_normed_vector" |
|
3480 (* FIXME: generalize 'a to metric_space *) |
|
3481 assumes "uniformly_continuous_on s f" |
|
3482 shows "uniformly_continuous_on s (\<lambda>x. c *\<^sub>R f(x))" |
|
3483 proof- |
|
3484 { fix x y assume "((\<lambda>n. f (x n) - f (y n)) ---> 0) sequentially" |
|
3485 hence "((\<lambda>n. c *\<^sub>R f (x n) - c *\<^sub>R f (y n)) ---> 0) sequentially" |
|
3486 using Lim_cmul[of "(\<lambda>n. f (x n) - f (y n))" 0 sequentially c] |
|
3487 unfolding scaleR_zero_right scaleR_right_diff_distrib by auto |
|
3488 } |
|
3489 thus ?thesis using assms unfolding uniformly_continuous_on_sequentially by auto |
|
3490 qed |
|
3491 |
|
3492 lemma dist_minus: |
|
3493 fixes x y :: "'a::real_normed_vector" |
|
3494 shows "dist (- x) (- y) = dist x y" |
|
3495 unfolding dist_norm minus_diff_minus norm_minus_cancel .. |
|
3496 |
|
3497 lemma uniformly_continuous_on_neg: |
|
3498 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3499 shows "uniformly_continuous_on s f |
|
3500 ==> uniformly_continuous_on s (\<lambda>x. -(f x))" |
|
3501 unfolding uniformly_continuous_on_def dist_minus . |
|
3502 |
|
3503 lemma uniformly_continuous_on_add: |
|
3504 fixes f g :: "'a::real_normed_vector \<Rightarrow> 'b::real_normed_vector" (* FIXME: generalize 'a *) |
|
3505 assumes "uniformly_continuous_on s f" "uniformly_continuous_on s g" |
|
3506 shows "uniformly_continuous_on s (\<lambda>x. f x + g x)" |
|
3507 proof- |
|
3508 { fix x y assume "((\<lambda>n. f (x n) - f (y n)) ---> 0) sequentially" |
|
3509 "((\<lambda>n. g (x n) - g (y n)) ---> 0) sequentially" |
|
3510 hence "((\<lambda>xa. f (x xa) - f (y xa) + (g (x xa) - g (y xa))) ---> 0 + 0) sequentially" |
|
3511 using Lim_add[of "\<lambda> n. f (x n) - f (y n)" 0 sequentially "\<lambda> n. g (x n) - g (y n)" 0] by auto |
|
3512 hence "((\<lambda>n. f (x n) + g (x n) - (f (y n) + g (y n))) ---> 0) sequentially" unfolding Lim_sequentially and add_diff_add [symmetric] by auto } |
|
3513 thus ?thesis using assms unfolding uniformly_continuous_on_sequentially by auto |
|
3514 qed |
|
3515 |
|
3516 lemma uniformly_continuous_on_sub: |
|
3517 fixes f :: "'a::real_normed_vector \<Rightarrow> 'b::real_normed_vector" (* FIXME: generalize 'a *) |
|
3518 shows "uniformly_continuous_on s f \<Longrightarrow> uniformly_continuous_on s g |
|
3519 ==> uniformly_continuous_on s (\<lambda>x. f x - g x)" |
|
3520 unfolding ab_diff_minus |
|
3521 using uniformly_continuous_on_add[of s f "\<lambda>x. - g x"] |
|
3522 using uniformly_continuous_on_neg[of s g] by auto |
|
3523 |
|
3524 text{* Identity function is continuous in every sense. *} |
|
3525 |
|
3526 lemma continuous_within_id: |
|
3527 "continuous (at a within s) (\<lambda>x. x)" |
|
3528 unfolding continuous_within by (rule Lim_at_within [OF Lim_ident_at]) |
|
3529 |
|
3530 lemma continuous_at_id: |
|
3531 "continuous (at a) (\<lambda>x. x)" |
|
3532 unfolding continuous_at by (rule Lim_ident_at) |
|
3533 |
|
3534 lemma continuous_on_id: |
|
3535 "continuous_on s (\<lambda>x. x)" |
|
3536 unfolding continuous_on Lim_within by auto |
|
3537 |
|
3538 lemma uniformly_continuous_on_id: |
|
3539 "uniformly_continuous_on s (\<lambda>x. x)" |
|
3540 unfolding uniformly_continuous_on_def by auto |
|
3541 |
|
3542 text{* Continuity of all kinds is preserved under composition. *} |
|
3543 |
|
3544 lemma continuous_within_compose: |
|
3545 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3546 fixes g :: "'b::metric_space \<Rightarrow> 'c::metric_space" |
|
3547 assumes "continuous (at x within s) f" "continuous (at (f x) within f ` s) g" |
|
3548 shows "continuous (at x within s) (g o f)" |
|
3549 proof- |
|
3550 { fix e::real assume "e>0" |
|
3551 with assms(2)[unfolded continuous_within Lim_within] obtain d where "d>0" and d:"\<forall>xa\<in>f ` s. 0 < dist xa (f x) \<and> dist xa (f x) < d \<longrightarrow> dist (g xa) (g (f x)) < e" by auto |
|
3552 from assms(1)[unfolded continuous_within Lim_within] obtain d' where "d'>0" and d':"\<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d' \<longrightarrow> dist (f xa) (f x) < d" using `d>0` by auto |
|
3553 { fix y assume as:"y\<in>s" "0 < dist y x" "dist y x < d'" |
|
3554 hence "dist (f y) (f x) < d" using d'[THEN bspec[where x=y]] by (auto simp add:dist_commute) |
|
3555 hence "dist (g (f y)) (g (f x)) < e" using as(1) d[THEN bspec[where x="f y"]] unfolding dist_nz[THEN sym] using `e>0` by auto } |
|
3556 hence "\<exists>d>0. \<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (g (f xa)) (g (f x)) < e" using `d'>0` by auto } |
|
3557 thus ?thesis unfolding continuous_within Lim_within by auto |
|
3558 qed |
|
3559 |
|
3560 lemma continuous_at_compose: |
|
3561 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3562 fixes g :: "'b::metric_space \<Rightarrow> 'c::metric_space" |
|
3563 assumes "continuous (at x) f" "continuous (at (f x)) g" |
|
3564 shows "continuous (at x) (g o f)" |
|
3565 proof- |
|
3566 have " continuous (at (f x) within range f) g" using assms(2) using continuous_within_subset[of "f x" UNIV g "range f", unfolded within_UNIV] by auto |
|
3567 thus ?thesis using assms(1) using continuous_within_compose[of x UNIV f g, unfolded within_UNIV] by auto |
|
3568 qed |
|
3569 |
|
3570 lemma continuous_on_compose: |
|
3571 "continuous_on s f \<Longrightarrow> continuous_on (f ` s) g \<Longrightarrow> continuous_on s (g o f)" |
|
3572 unfolding continuous_on_eq_continuous_within using continuous_within_compose[of _ s f g] by auto |
|
3573 |
|
3574 lemma uniformly_continuous_on_compose: |
|
3575 assumes "uniformly_continuous_on s f" "uniformly_continuous_on (f ` s) g" |
|
3576 shows "uniformly_continuous_on s (g o f)" |
|
3577 proof- |
|
3578 { fix e::real assume "e>0" |
|
3579 then obtain d where "d>0" and d:"\<forall>x\<in>f ` s. \<forall>x'\<in>f ` s. dist x' x < d \<longrightarrow> dist (g x') (g x) < e" using assms(2) unfolding uniformly_continuous_on_def by auto |
|
3580 obtain d' where "d'>0" "\<forall>x\<in>s. \<forall>x'\<in>s. dist x' x < d' \<longrightarrow> dist (f x') (f x) < d" using `d>0` using assms(1) unfolding uniformly_continuous_on_def by auto |
|
3581 hence "\<exists>d>0. \<forall>x\<in>s. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist ((g \<circ> f) x') ((g \<circ> f) x) < e" using `d>0` using d by auto } |
|
3582 thus ?thesis using assms unfolding uniformly_continuous_on_def by auto |
|
3583 qed |
|
3584 |
|
3585 text{* Continuity in terms of open preimages. *} |
|
3586 |
|
3587 lemma continuous_at_open: |
|
3588 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3589 shows "continuous (at x) f \<longleftrightarrow> (\<forall>t. open t \<and> f x \<in> t --> (\<exists>s. open s \<and> x \<in> s \<and> (\<forall>x' \<in> s. (f x') \<in> t)))" (is "?lhs = ?rhs") |
|
3590 proof |
|
3591 assume ?lhs |
|
3592 { fix t assume as: "open t" "f x \<in> t" |
|
3593 then obtain e where "e>0" and e:"ball (f x) e \<subseteq> t" unfolding open_contains_ball by auto |
|
3594 |
|
3595 obtain d where "d>0" and d:"\<forall>y. 0 < dist y x \<and> dist y x < d \<longrightarrow> dist (f y) (f x) < e" using `e>0` using `?lhs`[unfolded continuous_at Lim_at open_dist] by auto |
|
3596 |
|
3597 have "open (ball x d)" using open_ball by auto |
|
3598 moreover have "x \<in> ball x d" unfolding centre_in_ball using `d>0` by simp |
|
3599 moreover |
|
3600 { fix x' assume "x'\<in>ball x d" hence "f x' \<in> t" |
|
3601 using e[unfolded subset_eq Ball_def mem_ball, THEN spec[where x="f x'"]] d[THEN spec[where x=x']] |
|
3602 unfolding mem_ball apply (auto simp add: dist_commute) |
|
3603 unfolding dist_nz[THEN sym] using as(2) by auto } |
|
3604 hence "\<forall>x'\<in>ball x d. f x' \<in> t" by auto |
|
3605 ultimately have "\<exists>s. open s \<and> x \<in> s \<and> (\<forall>x'\<in>s. f x' \<in> t)" |
|
3606 apply(rule_tac x="ball x d" in exI) by simp } |
|
3607 thus ?rhs by auto |
|
3608 next |
|
3609 assume ?rhs |
|
3610 { fix e::real assume "e>0" |
|
3611 then obtain s where s: "open s" "x \<in> s" "\<forall>x'\<in>s. f x' \<in> ball (f x) e" using `?rhs`[unfolded continuous_at Lim_at, THEN spec[where x="ball (f x) e"]] |
|
3612 unfolding centre_in_ball[of "f x" e, THEN sym] by auto |
|
3613 then obtain d where "d>0" and d:"ball x d \<subseteq> s" unfolding open_contains_ball by auto |
|
3614 { fix y assume "0 < dist y x \<and> dist y x < d" |
|
3615 hence "dist (f y) (f x) < e" using d[unfolded subset_eq Ball_def mem_ball, THEN spec[where x=y]] |
|
3616 using s(3)[THEN bspec[where x=y], unfolded mem_ball] by (auto simp add: dist_commute) } |
|
3617 hence "\<exists>d>0. \<forall>xa. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (f x) < e" using `d>0` by auto } |
|
3618 thus ?lhs unfolding continuous_at Lim_at by auto |
|
3619 qed |
|
3620 |
|
3621 lemma continuous_on_open: |
|
3622 "continuous_on s f \<longleftrightarrow> |
|
3623 (\<forall>t. openin (subtopology euclidean (f ` s)) t |
|
3624 --> openin (subtopology euclidean s) {x \<in> s. f x \<in> t})" (is "?lhs = ?rhs") |
|
3625 proof |
|
3626 assume ?lhs |
|
3627 { fix t assume as:"openin (subtopology euclidean (f ` s)) t" |
|
3628 have "{x \<in> s. f x \<in> t} \<subseteq> s" using as[unfolded openin_euclidean_subtopology_iff] by auto |
|
3629 moreover |
|
3630 { fix x assume as':"x\<in>{x \<in> s. f x \<in> t}" |
|
3631 then obtain e where e: "e>0" "\<forall>x'\<in>f ` s. dist x' (f x) < e \<longrightarrow> x' \<in> t" using as[unfolded openin_euclidean_subtopology_iff, THEN conjunct2, THEN bspec[where x="f x"]] by auto |
|
3632 from this(1) obtain d where d: "d>0" "\<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (f x) < e" using `?lhs`[unfolded continuous_on Lim_within, THEN bspec[where x=x]] using as' by auto |
|
3633 have "\<exists>e>0. \<forall>x'\<in>s. dist x' x < e \<longrightarrow> x' \<in> {x \<in> s. f x \<in> t}" using d e unfolding dist_nz[THEN sym] by (rule_tac x=d in exI, auto) } |
|
3634 ultimately have "openin (subtopology euclidean s) {x \<in> s. f x \<in> t}" unfolding openin_euclidean_subtopology_iff by auto } |
|
3635 thus ?rhs unfolding continuous_on Lim_within using openin by auto |
|
3636 next |
|
3637 assume ?rhs |
|
3638 { fix e::real and x assume "x\<in>s" "e>0" |
|
3639 { fix xa x' assume "dist (f xa) (f x) < e" "xa \<in> s" "x' \<in> s" "dist (f xa) (f x') < e - dist (f xa) (f x)" |
|
3640 hence "dist (f x') (f x) < e" using dist_triangle[of "f x'" "f x" "f xa"] |
|
3641 by (auto simp add: dist_commute) } |
|
3642 hence "ball (f x) e \<inter> f ` s \<subseteq> f ` s \<and> (\<forall>xa\<in>ball (f x) e \<inter> f ` s. \<exists>ea>0. \<forall>x'\<in>f ` s. dist x' xa < ea \<longrightarrow> x' \<in> ball (f x) e \<inter> f ` s)" apply auto |
|
3643 apply(rule_tac x="e - dist (f xa) (f x)" in exI) using `e>0` by (auto simp add: dist_commute) |
|
3644 hence "\<forall>xa\<in>{xa \<in> s. f xa \<in> ball (f x) e \<inter> f ` s}. \<exists>ea>0. \<forall>x'\<in>s. dist x' xa < ea \<longrightarrow> x' \<in> {xa \<in> s. f xa \<in> ball (f x) e \<inter> f ` s}" |
|
3645 using `?rhs`[unfolded openin_euclidean_subtopology_iff, THEN spec[where x="ball (f x) e \<inter> f ` s"]] by auto |
|
3646 hence "\<exists>d>0. \<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (f x) < e" apply(erule_tac x=x in ballE) apply auto using `e>0` `x\<in>s` by (auto simp add: dist_commute) } |
|
3647 thus ?lhs unfolding continuous_on Lim_within by auto |
|
3648 qed |
|
3649 |
|
3650 (* ------------------------------------------------------------------------- *) |
|
3651 (* Similarly in terms of closed sets. *) |
|
3652 (* ------------------------------------------------------------------------- *) |
|
3653 |
|
3654 lemma continuous_on_closed: |
|
3655 "continuous_on s f \<longleftrightarrow> (\<forall>t. closedin (subtopology euclidean (f ` s)) t --> closedin (subtopology euclidean s) {x \<in> s. f x \<in> t})" (is "?lhs = ?rhs") |
|
3656 proof |
|
3657 assume ?lhs |
|
3658 { fix t |
|
3659 have *:"s - {x \<in> s. f x \<in> f ` s - t} = {x \<in> s. f x \<in> t}" by auto |
|
3660 have **:"f ` s - (f ` s - (f ` s - t)) = f ` s - t" by auto |
|
3661 assume as:"closedin (subtopology euclidean (f ` s)) t" |
|
3662 hence "closedin (subtopology euclidean (f ` s)) (f ` s - (f ` s - t))" unfolding closedin_def topspace_euclidean_subtopology unfolding ** by auto |
|
3663 hence "closedin (subtopology euclidean s) {x \<in> s. f x \<in> t}" using `?lhs`[unfolded continuous_on_open, THEN spec[where x="(f ` s) - t"]] |
|
3664 unfolding openin_closedin_eq topspace_euclidean_subtopology unfolding * by auto } |
|
3665 thus ?rhs by auto |
|
3666 next |
|
3667 assume ?rhs |
|
3668 { fix t |
|
3669 have *:"s - {x \<in> s. f x \<in> f ` s - t} = {x \<in> s. f x \<in> t}" by auto |
|
3670 assume as:"openin (subtopology euclidean (f ` s)) t" |
|
3671 hence "openin (subtopology euclidean s) {x \<in> s. f x \<in> t}" using `?rhs`[THEN spec[where x="(f ` s) - t"]] |
|
3672 unfolding openin_closedin_eq topspace_euclidean_subtopology *[THEN sym] closedin_subtopology by auto } |
|
3673 thus ?lhs unfolding continuous_on_open by auto |
|
3674 qed |
|
3675 |
|
3676 text{* Half-global and completely global cases. *} |
|
3677 |
|
3678 lemma continuous_open_in_preimage: |
|
3679 assumes "continuous_on s f" "open t" |
|
3680 shows "openin (subtopology euclidean s) {x \<in> s. f x \<in> t}" |
|
3681 proof- |
|
3682 have *:"\<forall>x. x \<in> s \<and> f x \<in> t \<longleftrightarrow> x \<in> s \<and> f x \<in> (t \<inter> f ` s)" by auto |
|
3683 have "openin (subtopology euclidean (f ` s)) (t \<inter> f ` s)" |
|
3684 using openin_open_Int[of t "f ` s", OF assms(2)] unfolding openin_open by auto |
|
3685 thus ?thesis using assms(1)[unfolded continuous_on_open, THEN spec[where x="t \<inter> f ` s"]] using * by auto |
|
3686 qed |
|
3687 |
|
3688 lemma continuous_closed_in_preimage: |
|
3689 assumes "continuous_on s f" "closed t" |
|
3690 shows "closedin (subtopology euclidean s) {x \<in> s. f x \<in> t}" |
|
3691 proof- |
|
3692 have *:"\<forall>x. x \<in> s \<and> f x \<in> t \<longleftrightarrow> x \<in> s \<and> f x \<in> (t \<inter> f ` s)" by auto |
|
3693 have "closedin (subtopology euclidean (f ` s)) (t \<inter> f ` s)" |
|
3694 using closedin_closed_Int[of t "f ` s", OF assms(2)] unfolding Int_commute by auto |
|
3695 thus ?thesis |
|
3696 using assms(1)[unfolded continuous_on_closed, THEN spec[where x="t \<inter> f ` s"]] using * by auto |
|
3697 qed |
|
3698 |
|
3699 lemma continuous_open_preimage: |
|
3700 assumes "continuous_on s f" "open s" "open t" |
|
3701 shows "open {x \<in> s. f x \<in> t}" |
|
3702 proof- |
|
3703 obtain T where T: "open T" "{x \<in> s. f x \<in> t} = s \<inter> T" |
|
3704 using continuous_open_in_preimage[OF assms(1,3)] unfolding openin_open by auto |
|
3705 thus ?thesis using open_Int[of s T, OF assms(2)] by auto |
|
3706 qed |
|
3707 |
|
3708 lemma continuous_closed_preimage: |
|
3709 assumes "continuous_on s f" "closed s" "closed t" |
|
3710 shows "closed {x \<in> s. f x \<in> t}" |
|
3711 proof- |
|
3712 obtain T where T: "closed T" "{x \<in> s. f x \<in> t} = s \<inter> T" |
|
3713 using continuous_closed_in_preimage[OF assms(1,3)] unfolding closedin_closed by auto |
|
3714 thus ?thesis using closed_Int[of s T, OF assms(2)] by auto |
|
3715 qed |
|
3716 |
|
3717 lemma continuous_open_preimage_univ: |
|
3718 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3719 shows "\<forall>x. continuous (at x) f \<Longrightarrow> open s \<Longrightarrow> open {x. f x \<in> s}" |
|
3720 using continuous_open_preimage[of UNIV f s] open_UNIV continuous_at_imp_continuous_on by auto |
|
3721 |
|
3722 lemma continuous_closed_preimage_univ: |
|
3723 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3724 shows "(\<forall>x. continuous (at x) f) \<Longrightarrow> closed s ==> closed {x. f x \<in> s}" |
|
3725 using continuous_closed_preimage[of UNIV f s] closed_UNIV continuous_at_imp_continuous_on by auto |
|
3726 |
|
3727 lemma continuous_open_vimage: |
|
3728 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3729 shows "\<forall>x. continuous (at x) f \<Longrightarrow> open s \<Longrightarrow> open (f -` s)" |
|
3730 unfolding vimage_def by (rule continuous_open_preimage_univ) |
|
3731 |
|
3732 lemma continuous_closed_vimage: |
|
3733 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3734 shows "\<forall>x. continuous (at x) f \<Longrightarrow> closed s \<Longrightarrow> closed (f -` s)" |
|
3735 unfolding vimage_def by (rule continuous_closed_preimage_univ) |
|
3736 |
|
3737 text{* Equality of continuous functions on closure and related results. *} |
|
3738 |
|
3739 lemma continuous_closed_in_preimage_constant: |
|
3740 "continuous_on s f ==> closedin (subtopology euclidean s) {x \<in> s. f x = a}" |
|
3741 using continuous_closed_in_preimage[of s f "{a}"] closed_sing by auto |
|
3742 |
|
3743 lemma continuous_closed_preimage_constant: |
|
3744 "continuous_on s f \<Longrightarrow> closed s ==> closed {x \<in> s. f x = a}" |
|
3745 using continuous_closed_preimage[of s f "{a}"] closed_sing by auto |
|
3746 |
|
3747 lemma continuous_constant_on_closure: |
|
3748 assumes "continuous_on (closure s) f" |
|
3749 "\<forall>x \<in> s. f x = a" |
|
3750 shows "\<forall>x \<in> (closure s). f x = a" |
|
3751 using continuous_closed_preimage_constant[of "closure s" f a] |
|
3752 assms closure_minimal[of s "{x \<in> closure s. f x = a}"] closure_subset unfolding subset_eq by auto |
|
3753 |
|
3754 lemma image_closure_subset: |
|
3755 assumes "continuous_on (closure s) f" "closed t" "(f ` s) \<subseteq> t" |
|
3756 shows "f ` (closure s) \<subseteq> t" |
|
3757 proof- |
|
3758 have "s \<subseteq> {x \<in> closure s. f x \<in> t}" using assms(3) closure_subset by auto |
|
3759 moreover have "closed {x \<in> closure s. f x \<in> t}" |
|
3760 using continuous_closed_preimage[OF assms(1)] and assms(2) by auto |
|
3761 ultimately have "closure s = {x \<in> closure s . f x \<in> t}" |
|
3762 using closure_minimal[of s "{x \<in> closure s. f x \<in> t}"] by auto |
|
3763 thus ?thesis by auto |
|
3764 qed |
|
3765 |
|
3766 lemma continuous_on_closure_norm_le: |
|
3767 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3768 assumes "continuous_on (closure s) f" "\<forall>y \<in> s. norm(f y) \<le> b" "x \<in> (closure s)" |
|
3769 shows "norm(f x) \<le> b" |
|
3770 proof- |
|
3771 have *:"f ` s \<subseteq> cball 0 b" using assms(2)[unfolded mem_cball_0[THEN sym]] by auto |
|
3772 show ?thesis |
|
3773 using image_closure_subset[OF assms(1) closed_cball[of 0 b] *] assms(3) |
|
3774 unfolding subset_eq apply(erule_tac x="f x" in ballE) by (auto simp add: dist_norm) |
|
3775 qed |
|
3776 |
|
3777 text{* Making a continuous function avoid some value in a neighbourhood. *} |
|
3778 |
|
3779 lemma continuous_within_avoid: |
|
3780 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3781 assumes "continuous (at x within s) f" "x \<in> s" "f x \<noteq> a" |
|
3782 shows "\<exists>e>0. \<forall>y \<in> s. dist x y < e --> f y \<noteq> a" |
|
3783 proof- |
|
3784 obtain d where "d>0" and d:"\<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (f x) < dist (f x) a" |
|
3785 using assms(1)[unfolded continuous_within Lim_within, THEN spec[where x="dist (f x) a"]] assms(3)[unfolded dist_nz] by auto |
|
3786 { fix y assume " y\<in>s" "dist x y < d" |
|
3787 hence "f y \<noteq> a" using d[THEN bspec[where x=y]] assms(3)[unfolded dist_nz] |
|
3788 apply auto unfolding dist_nz[THEN sym] by (auto simp add: dist_commute) } |
|
3789 thus ?thesis using `d>0` by auto |
|
3790 qed |
|
3791 |
|
3792 lemma continuous_at_avoid: |
|
3793 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3794 assumes "continuous (at x) f" "f x \<noteq> a" |
|
3795 shows "\<exists>e>0. \<forall>y. dist x y < e \<longrightarrow> f y \<noteq> a" |
|
3796 using assms using continuous_within_avoid[of x UNIV f a, unfolded within_UNIV] by auto |
|
3797 |
|
3798 lemma continuous_on_avoid: |
|
3799 assumes "continuous_on s f" "x \<in> s" "f x \<noteq> a" |
|
3800 shows "\<exists>e>0. \<forall>y \<in> s. dist x y < e \<longrightarrow> f y \<noteq> a" |
|
3801 using assms(1)[unfolded continuous_on_eq_continuous_within, THEN bspec[where x=x], OF assms(2)] continuous_within_avoid[of x s f a] assms(2,3) by auto |
|
3802 |
|
3803 lemma continuous_on_open_avoid: |
|
3804 assumes "continuous_on s f" "open s" "x \<in> s" "f x \<noteq> a" |
|
3805 shows "\<exists>e>0. \<forall>y. dist x y < e \<longrightarrow> f y \<noteq> a" |
|
3806 using assms(1)[unfolded continuous_on_eq_continuous_at[OF assms(2)], THEN bspec[where x=x], OF assms(3)] continuous_at_avoid[of x f a] assms(3,4) by auto |
|
3807 |
|
3808 text{* Proving a function is constant by proving open-ness of level set. *} |
|
3809 |
|
3810 lemma continuous_levelset_open_in_cases: |
|
3811 "connected s \<Longrightarrow> continuous_on s f \<Longrightarrow> |
|
3812 openin (subtopology euclidean s) {x \<in> s. f x = a} |
|
3813 ==> (\<forall>x \<in> s. f x \<noteq> a) \<or> (\<forall>x \<in> s. f x = a)" |
|
3814 unfolding connected_clopen using continuous_closed_in_preimage_constant by auto |
|
3815 |
|
3816 lemma continuous_levelset_open_in: |
|
3817 "connected s \<Longrightarrow> continuous_on s f \<Longrightarrow> |
|
3818 openin (subtopology euclidean s) {x \<in> s. f x = a} \<Longrightarrow> |
|
3819 (\<exists>x \<in> s. f x = a) ==> (\<forall>x \<in> s. f x = a)" |
|
3820 using continuous_levelset_open_in_cases[of s f ] |
|
3821 by meson |
|
3822 |
|
3823 lemma continuous_levelset_open: |
|
3824 assumes "connected s" "continuous_on s f" "open {x \<in> s. f x = a}" "\<exists>x \<in> s. f x = a" |
|
3825 shows "\<forall>x \<in> s. f x = a" |
|
3826 using continuous_levelset_open_in[OF assms(1,2), of a, unfolded openin_open] using assms (3,4) by auto |
|
3827 |
|
3828 text{* Some arithmetical combinations (more to prove). *} |
|
3829 |
|
3830 lemma open_scaling[intro]: |
|
3831 fixes s :: "'a::real_normed_vector set" |
|
3832 assumes "c \<noteq> 0" "open s" |
|
3833 shows "open((\<lambda>x. c *\<^sub>R x) ` s)" |
|
3834 proof- |
|
3835 { fix x assume "x \<in> s" |
|
3836 then obtain e where "e>0" and e:"\<forall>x'. dist x' x < e \<longrightarrow> x' \<in> s" using assms(2)[unfolded open_dist, THEN bspec[where x=x]] by auto |
|
3837 have "e * abs c > 0" using assms(1)[unfolded zero_less_abs_iff[THEN sym]] using real_mult_order[OF `e>0`] by auto |
|
3838 moreover |
|
3839 { fix y assume "dist y (c *\<^sub>R x) < e * \<bar>c\<bar>" |
|
3840 hence "norm ((1 / c) *\<^sub>R y - x) < e" unfolding dist_norm |
|
3841 using norm_scaleR[of c "(1 / c) *\<^sub>R y - x", unfolded scaleR_right_diff_distrib, unfolded scaleR_scaleR] assms(1) |
|
3842 assms(1)[unfolded zero_less_abs_iff[THEN sym]] by (simp del:zero_less_abs_iff) |
|
3843 hence "y \<in> op *\<^sub>R c ` s" using rev_image_eqI[of "(1 / c) *\<^sub>R y" s y "op *\<^sub>R c"] e[THEN spec[where x="(1 / c) *\<^sub>R y"]] assms(1) unfolding dist_norm scaleR_scaleR by auto } |
|
3844 ultimately have "\<exists>e>0. \<forall>x'. dist x' (c *\<^sub>R x) < e \<longrightarrow> x' \<in> op *\<^sub>R c ` s" apply(rule_tac x="e * abs c" in exI) by auto } |
|
3845 thus ?thesis unfolding open_dist by auto |
|
3846 qed |
|
3847 |
|
3848 lemma minus_image_eq_vimage: |
|
3849 fixes A :: "'a::ab_group_add set" |
|
3850 shows "(\<lambda>x. - x) ` A = (\<lambda>x. - x) -` A" |
|
3851 by (auto intro!: image_eqI [where f="\<lambda>x. - x"]) |
|
3852 |
|
3853 lemma open_negations: |
|
3854 fixes s :: "'a::real_normed_vector set" |
|
3855 shows "open s ==> open ((\<lambda> x. -x) ` s)" |
|
3856 unfolding scaleR_minus1_left [symmetric] |
|
3857 by (rule open_scaling, auto) |
|
3858 |
|
3859 lemma open_translation: |
|
3860 fixes s :: "'a::real_normed_vector set" |
|
3861 assumes "open s" shows "open((\<lambda>x. a + x) ` s)" |
|
3862 proof- |
|
3863 { fix x have "continuous (at x) (\<lambda>x. x - a)" using continuous_sub[of "at x" "\<lambda>x. x" "\<lambda>x. a"] continuous_at_id[of x] continuous_const[of "at x" a] by auto } |
|
3864 moreover have "{x. x - a \<in> s} = op + a ` s" apply auto unfolding image_iff apply(rule_tac x="x - a" in bexI) by auto |
|
3865 ultimately show ?thesis using continuous_open_preimage_univ[of "\<lambda>x. x - a" s] using assms by auto |
|
3866 qed |
|
3867 |
|
3868 lemma open_affinity: |
|
3869 fixes s :: "'a::real_normed_vector set" |
|
3870 assumes "open s" "c \<noteq> 0" |
|
3871 shows "open ((\<lambda>x. a + c *\<^sub>R x) ` s)" |
|
3872 proof- |
|
3873 have *:"(\<lambda>x. a + c *\<^sub>R x) = (\<lambda>x. a + x) \<circ> (\<lambda>x. c *\<^sub>R x)" unfolding o_def .. |
|
3874 have "op + a ` op *\<^sub>R c ` s = (op + a \<circ> op *\<^sub>R c) ` s" by auto |
|
3875 thus ?thesis using assms open_translation[of "op *\<^sub>R c ` s" a] unfolding * by auto |
|
3876 qed |
|
3877 |
|
3878 lemma interior_translation: |
|
3879 fixes s :: "'a::real_normed_vector set" |
|
3880 shows "interior ((\<lambda>x. a + x) ` s) = (\<lambda>x. a + x) ` (interior s)" |
|
3881 proof (rule set_ext, rule) |
|
3882 fix x assume "x \<in> interior (op + a ` s)" |
|
3883 then obtain e where "e>0" and e:"ball x e \<subseteq> op + a ` s" unfolding mem_interior by auto |
|
3884 hence "ball (x - a) e \<subseteq> s" unfolding subset_eq Ball_def mem_ball dist_norm apply auto apply(erule_tac x="a + xa" in allE) unfolding ab_group_add_class.diff_diff_eq[THEN sym] by auto |
|
3885 thus "x \<in> op + a ` interior s" unfolding image_iff apply(rule_tac x="x - a" in bexI) unfolding mem_interior using `e > 0` by auto |
|
3886 next |
|
3887 fix x assume "x \<in> op + a ` interior s" |
|
3888 then obtain y e where "e>0" and e:"ball y e \<subseteq> s" and y:"x = a + y" unfolding image_iff Bex_def mem_interior by auto |
|
3889 { fix z have *:"a + y - z = y + a - z" by auto |
|
3890 assume "z\<in>ball x e" |
|
3891 hence "z - a \<in> s" using e[unfolded subset_eq, THEN bspec[where x="z - a"]] unfolding mem_ball dist_norm y ab_group_add_class.diff_diff_eq2 * by auto |
|
3892 hence "z \<in> op + a ` s" unfolding image_iff by(auto intro!: bexI[where x="z - a"]) } |
|
3893 hence "ball x e \<subseteq> op + a ` s" unfolding subset_eq by auto |
|
3894 thus "x \<in> interior (op + a ` s)" unfolding mem_interior using `e>0` by auto |
|
3895 qed |
|
3896 |
|
3897 subsection {* Preservation of compactness and connectedness under continuous function. *} |
|
3898 |
|
3899 lemma compact_continuous_image: |
|
3900 assumes "continuous_on s f" "compact s" |
|
3901 shows "compact(f ` s)" |
|
3902 proof- |
|
3903 { fix x assume x:"\<forall>n::nat. x n \<in> f ` s" |
|
3904 then obtain y where y:"\<forall>n. y n \<in> s \<and> x n = f (y n)" unfolding image_iff Bex_def using choice[of "\<lambda>n xa. xa \<in> s \<and> x n = f xa"] by auto |
|
3905 then obtain l r where "l\<in>s" and r:"subseq r" and lr:"((y \<circ> r) ---> l) sequentially" using assms(2)[unfolded compact_def, THEN spec[where x=y]] by auto |
|
3906 { fix e::real assume "e>0" |
|
3907 then obtain d where "d>0" and d:"\<forall>x'\<in>s. dist x' l < d \<longrightarrow> dist (f x') (f l) < e" using assms(1)[unfolded continuous_on_def, THEN bspec[where x=l], OF `l\<in>s`] by auto |
|
3908 then obtain N::nat where N:"\<forall>n\<ge>N. dist ((y \<circ> r) n) l < d" using lr[unfolded Lim_sequentially, THEN spec[where x=d]] by auto |
|
3909 { fix n::nat assume "n\<ge>N" hence "dist ((x \<circ> r) n) (f l) < e" using N[THEN spec[where x=n]] d[THEN bspec[where x="y (r n)"]] y[THEN spec[where x="r n"]] by auto } |
|
3910 hence "\<exists>N. \<forall>n\<ge>N. dist ((x \<circ> r) n) (f l) < e" by auto } |
|
3911 hence "\<exists>l\<in>f ` s. \<exists>r. subseq r \<and> ((x \<circ> r) ---> l) sequentially" unfolding Lim_sequentially using r lr `l\<in>s` by auto } |
|
3912 thus ?thesis unfolding compact_def by auto |
|
3913 qed |
|
3914 |
|
3915 lemma connected_continuous_image: |
|
3916 assumes "continuous_on s f" "connected s" |
|
3917 shows "connected(f ` s)" |
|
3918 proof- |
|
3919 { fix T assume as: "T \<noteq> {}" "T \<noteq> f ` s" "openin (subtopology euclidean (f ` s)) T" "closedin (subtopology euclidean (f ` s)) T" |
|
3920 have "{x \<in> s. f x \<in> T} = {} \<or> {x \<in> s. f x \<in> T} = s" |
|
3921 using assms(1)[unfolded continuous_on_open, THEN spec[where x=T]] |
|
3922 using assms(1)[unfolded continuous_on_closed, THEN spec[where x=T]] |
|
3923 using assms(2)[unfolded connected_clopen, THEN spec[where x="{x \<in> s. f x \<in> T}"]] as(3,4) by auto |
|
3924 hence False using as(1,2) |
|
3925 using as(4)[unfolded closedin_def topspace_euclidean_subtopology] by auto } |
|
3926 thus ?thesis unfolding connected_clopen by auto |
|
3927 qed |
|
3928 |
|
3929 text{* Continuity implies uniform continuity on a compact domain. *} |
|
3930 |
|
3931 lemma compact_uniformly_continuous: |
|
3932 assumes "continuous_on s f" "compact s" |
|
3933 shows "uniformly_continuous_on s f" |
|
3934 proof- |
|
3935 { fix x assume x:"x\<in>s" |
|
3936 hence "\<forall>xa. \<exists>y. 0 < xa \<longrightarrow> (y > 0 \<and> (\<forall>x'\<in>s. dist x' x < y \<longrightarrow> dist (f x') (f x) < xa))" using assms(1)[unfolded continuous_on_def, THEN bspec[where x=x]] by auto |
|
3937 hence "\<exists>fa. \<forall>xa>0. \<forall>x'\<in>s. fa xa > 0 \<and> (dist x' x < fa xa \<longrightarrow> dist (f x') (f x) < xa)" using choice[of "\<lambda>e d. e>0 \<longrightarrow> d>0 \<and>(\<forall>x'\<in>s. (dist x' x < d \<longrightarrow> dist (f x') (f x) < e))"] by auto } |
|
3938 then have "\<forall>x\<in>s. \<exists>y. \<forall>xa. 0 < xa \<longrightarrow> (\<forall>x'\<in>s. y xa > 0 \<and> (dist x' x < y xa \<longrightarrow> dist (f x') (f x) < xa))" by auto |
|
3939 then obtain d where d:"\<forall>e>0. \<forall>x\<in>s. \<forall>x'\<in>s. d x e > 0 \<and> (dist x' x < d x e \<longrightarrow> dist (f x') (f x) < e)" |
|
3940 using bchoice[of s "\<lambda>x fa. \<forall>xa>0. \<forall>x'\<in>s. fa xa > 0 \<and> (dist x' x < fa xa \<longrightarrow> dist (f x') (f x) < xa)"] by blast |
|
3941 |
|
3942 { fix e::real assume "e>0" |
|
3943 |
|
3944 { fix x assume "x\<in>s" hence "x \<in> ball x (d x (e / 2))" unfolding centre_in_ball using d[THEN spec[where x="e/2"]] using `e>0` by auto } |
|
3945 hence "s \<subseteq> \<Union>{ball x (d x (e / 2)) |x. x \<in> s}" unfolding subset_eq by auto |
|
3946 moreover |
|
3947 { fix b assume "b\<in>{ball x (d x (e / 2)) |x. x \<in> s}" hence "open b" by auto } |
|
3948 ultimately obtain ea where "ea>0" and ea:"\<forall>x\<in>s. \<exists>b\<in>{ball x (d x (e / 2)) |x. x \<in> s}. ball x ea \<subseteq> b" using heine_borel_lemma[OF assms(2), of "{ball x (d x (e / 2)) | x. x\<in>s }"] by auto |
|
3949 |
|
3950 { fix x y assume "x\<in>s" "y\<in>s" and as:"dist y x < ea" |
|
3951 obtain z where "z\<in>s" and z:"ball x ea \<subseteq> ball z (d z (e / 2))" using ea[THEN bspec[where x=x]] and `x\<in>s` by auto |
|
3952 hence "x\<in>ball z (d z (e / 2))" using `ea>0` unfolding subset_eq by auto |
|
3953 hence "dist (f z) (f x) < e / 2" using d[THEN spec[where x="e/2"]] and `e>0` and `x\<in>s` and `z\<in>s` |
|
3954 by (auto simp add: dist_commute) |
|
3955 moreover have "y\<in>ball z (d z (e / 2))" using as and `ea>0` and z[unfolded subset_eq] |
|
3956 by (auto simp add: dist_commute) |
|
3957 hence "dist (f z) (f y) < e / 2" using d[THEN spec[where x="e/2"]] and `e>0` and `y\<in>s` and `z\<in>s` |
|
3958 by (auto simp add: dist_commute) |
|
3959 ultimately have "dist (f y) (f x) < e" using dist_triangle_half_r[of "f z" "f x" e "f y"] |
|
3960 by (auto simp add: dist_commute) } |
|
3961 then have "\<exists>d>0. \<forall>x\<in>s. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (f x') (f x) < e" using `ea>0` by auto } |
|
3962 thus ?thesis unfolding uniformly_continuous_on_def by auto |
|
3963 qed |
|
3964 |
|
3965 text{* Continuity of inverse function on compact domain. *} |
|
3966 |
|
3967 lemma continuous_on_inverse: |
|
3968 fixes f :: "'a::heine_borel \<Rightarrow> 'b::heine_borel" |
|
3969 (* TODO: can this be generalized more? *) |
|
3970 assumes "continuous_on s f" "compact s" "\<forall>x \<in> s. g (f x) = x" |
|
3971 shows "continuous_on (f ` s) g" |
|
3972 proof- |
|
3973 have *:"g ` f ` s = s" using assms(3) by (auto simp add: image_iff) |
|
3974 { fix t assume t:"closedin (subtopology euclidean (g ` f ` s)) t" |
|
3975 then obtain T where T: "closed T" "t = s \<inter> T" unfolding closedin_closed unfolding * by auto |
|
3976 have "continuous_on (s \<inter> T) f" using continuous_on_subset[OF assms(1), of "s \<inter> t"] |
|
3977 unfolding T(2) and Int_left_absorb by auto |
|
3978 moreover have "compact (s \<inter> T)" |
|
3979 using assms(2) unfolding compact_eq_bounded_closed |
|
3980 using bounded_subset[of s "s \<inter> T"] and T(1) by auto |
|
3981 ultimately have "closed (f ` t)" using T(1) unfolding T(2) |
|
3982 using compact_continuous_image [of "s \<inter> T" f] unfolding compact_eq_bounded_closed by auto |
|
3983 moreover have "{x \<in> f ` s. g x \<in> t} = f ` s \<inter> f ` t" using assms(3) unfolding T(2) by auto |
|
3984 ultimately have "closedin (subtopology euclidean (f ` s)) {x \<in> f ` s. g x \<in> t}" |
|
3985 unfolding closedin_closed by auto } |
|
3986 thus ?thesis unfolding continuous_on_closed by auto |
|
3987 qed |
|
3988 |
|
3989 subsection{* A uniformly convergent limit of continuous functions is continuous. *} |
|
3990 |
|
3991 lemma norm_triangle_lt: |
|
3992 fixes x y :: "'a::real_normed_vector" |
|
3993 shows "norm x + norm y < e \<Longrightarrow> norm (x + y) < e" |
|
3994 by (rule le_less_trans [OF norm_triangle_ineq]) |
|
3995 |
|
3996 lemma continuous_uniform_limit: |
|
3997 fixes f :: "'a \<Rightarrow> 'b::metric_space \<Rightarrow> 'c::real_normed_vector" |
|
3998 assumes "\<not> (trivial_limit net)" "eventually (\<lambda>n. continuous_on s (f n)) net" |
|
3999 "\<forall>e>0. eventually (\<lambda>n. \<forall>x \<in> s. norm(f n x - g x) < e) net" |
|
4000 shows "continuous_on s g" |
|
4001 proof- |
|
4002 { fix x and e::real assume "x\<in>s" "e>0" |
|
4003 have "eventually (\<lambda>n. \<forall>x\<in>s. norm (f n x - g x) < e / 3) net" using `e>0` assms(3)[THEN spec[where x="e/3"]] by auto |
|
4004 then obtain n where n:"\<forall>xa\<in>s. norm (f n xa - g xa) < e / 3" "continuous_on s (f n)" |
|
4005 using eventually_and[of "(\<lambda>n. \<forall>x\<in>s. norm (f n x - g x) < e / 3)" "(\<lambda>n. continuous_on s (f n))" net] assms(1,2) eventually_happens by blast |
|
4006 have "e / 3 > 0" using `e>0` by auto |
|
4007 then obtain d where "d>0" and d:"\<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (f n x') (f n x) < e / 3" |
|
4008 using n(2)[unfolded continuous_on_def, THEN bspec[where x=x], OF `x\<in>s`, THEN spec[where x="e/3"]] by blast |
|
4009 { fix y assume "y\<in>s" "dist y x < d" |
|
4010 hence "dist (f n y) (f n x) < e / 3" using d[THEN bspec[where x=y]] by auto |
|
4011 hence "norm (f n y - g x) < 2 * e / 3" using norm_triangle_lt[of "f n y - f n x" "f n x - g x" "2*e/3"] |
|
4012 using n(1)[THEN bspec[where x=x], OF `x\<in>s`] unfolding dist_norm unfolding ab_group_add_class.ab_diff_minus by auto |
|
4013 hence "dist (g y) (g x) < e" unfolding dist_norm using n(1)[THEN bspec[where x=y], OF `y\<in>s`] |
|
4014 unfolding norm_minus_cancel[of "f n y - g y", THEN sym] using norm_triangle_lt[of "f n y - g x" "g y - f n y" e] by (auto simp add: uminus_add_conv_diff) } |
|
4015 hence "\<exists>d>0. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (g x') (g x) < e" using `d>0` by auto } |
|
4016 thus ?thesis unfolding continuous_on_def by auto |
|
4017 qed |
|
4018 |
|
4019 subsection{* Topological properties of linear functions. *} |
|
4020 |
|
4021 lemma linear_lim_0: |
|
4022 assumes "bounded_linear f" shows "(f ---> 0) (at (0))" |
|
4023 proof- |
|
4024 interpret f: bounded_linear f by fact |
|
4025 have "(f ---> f 0) (at 0)" |
|
4026 using tendsto_ident_at by (rule f.tendsto) |
|
4027 thus ?thesis unfolding f.zero . |
|
4028 qed |
|
4029 |
|
4030 lemma linear_continuous_at: |
|
4031 assumes "bounded_linear f" shows "continuous (at a) f" |
|
4032 unfolding continuous_at using assms |
|
4033 apply (rule bounded_linear.tendsto) |
|
4034 apply (rule tendsto_ident_at) |
|
4035 done |
|
4036 |
|
4037 lemma linear_continuous_within: |
|
4038 shows "bounded_linear f ==> continuous (at x within s) f" |
|
4039 using continuous_at_imp_continuous_within[of x f s] using linear_continuous_at[of f] by auto |
|
4040 |
|
4041 lemma linear_continuous_on: |
|
4042 shows "bounded_linear f ==> continuous_on s f" |
|
4043 using continuous_at_imp_continuous_on[of s f] using linear_continuous_at[of f] by auto |
|
4044 |
|
4045 text{* Also bilinear functions, in composition form. *} |
|
4046 |
|
4047 lemma bilinear_continuous_at_compose: |
|
4048 shows "continuous (at x) f \<Longrightarrow> continuous (at x) g \<Longrightarrow> bounded_bilinear h |
|
4049 ==> continuous (at x) (\<lambda>x. h (f x) (g x))" |
|
4050 unfolding continuous_at using Lim_bilinear[of f "f x" "(at x)" g "g x" h] by auto |
|
4051 |
|
4052 lemma bilinear_continuous_within_compose: |
|
4053 shows "continuous (at x within s) f \<Longrightarrow> continuous (at x within s) g \<Longrightarrow> bounded_bilinear h |
|
4054 ==> continuous (at x within s) (\<lambda>x. h (f x) (g x))" |
|
4055 unfolding continuous_within using Lim_bilinear[of f "f x"] by auto |
|
4056 |
|
4057 lemma bilinear_continuous_on_compose: |
|
4058 shows "continuous_on s f \<Longrightarrow> continuous_on s g \<Longrightarrow> bounded_bilinear h |
|
4059 ==> continuous_on s (\<lambda>x. h (f x) (g x))" |
|
4060 unfolding continuous_on_eq_continuous_within apply auto apply(erule_tac x=x in ballE) apply auto apply(erule_tac x=x in ballE) apply auto |
|
4061 using bilinear_continuous_within_compose[of _ s f g h] by auto |
|
4062 |
|
4063 subsection{* Topological stuff lifted from and dropped to R *} |
|
4064 |
|
4065 |
|
4066 lemma open_real: |
|
4067 fixes s :: "real set" shows |
|
4068 "open s \<longleftrightarrow> |
|
4069 (\<forall>x \<in> s. \<exists>e>0. \<forall>x'. abs(x' - x) < e --> x' \<in> s)" (is "?lhs = ?rhs") |
|
4070 unfolding open_dist dist_norm by simp |
|
4071 |
|
4072 lemma islimpt_approachable_real: |
|
4073 fixes s :: "real set" |
|
4074 shows "x islimpt s \<longleftrightarrow> (\<forall>e>0. \<exists>x'\<in> s. x' \<noteq> x \<and> abs(x' - x) < e)" |
|
4075 unfolding islimpt_approachable dist_norm by simp |
|
4076 |
|
4077 lemma closed_real: |
|
4078 fixes s :: "real set" |
|
4079 shows "closed s \<longleftrightarrow> |
|
4080 (\<forall>x. (\<forall>e>0. \<exists>x' \<in> s. x' \<noteq> x \<and> abs(x' - x) < e) |
|
4081 --> x \<in> s)" |
|
4082 unfolding closed_limpt islimpt_approachable dist_norm by simp |
|
4083 |
|
4084 lemma continuous_at_real_range: |
|
4085 fixes f :: "'a::real_normed_vector \<Rightarrow> real" |
|
4086 shows "continuous (at x) f \<longleftrightarrow> (\<forall>e>0. \<exists>d>0. |
|
4087 \<forall>x'. norm(x' - x) < d --> abs(f x' - f x) < e)" |
|
4088 unfolding continuous_at unfolding Lim_at |
|
4089 unfolding dist_nz[THEN sym] unfolding dist_norm apply auto |
|
4090 apply(erule_tac x=e in allE) apply auto apply (rule_tac x=d in exI) apply auto apply (erule_tac x=x' in allE) apply auto |
|
4091 apply(erule_tac x=e in allE) by auto |
|
4092 |
|
4093 lemma continuous_on_real_range: |
|
4094 fixes f :: "'a::real_normed_vector \<Rightarrow> real" |
|
4095 shows "continuous_on s f \<longleftrightarrow> (\<forall>x \<in> s. \<forall>e>0. \<exists>d>0. (\<forall>x' \<in> s. norm(x' - x) < d --> abs(f x' - f x) < e))" |
|
4096 unfolding continuous_on_def dist_norm by simp |
|
4097 |
|
4098 lemma continuous_at_norm: "continuous (at x) norm" |
|
4099 unfolding continuous_at by (intro tendsto_intros) |
|
4100 |
|
4101 lemma continuous_on_norm: "continuous_on s norm" |
|
4102 unfolding continuous_on by (intro ballI tendsto_intros) |
|
4103 |
|
4104 lemma continuous_at_component: "continuous (at a) (\<lambda>x. x $ i)" |
|
4105 unfolding continuous_at by (intro tendsto_intros) |
|
4106 |
|
4107 lemma continuous_on_component: "continuous_on s (\<lambda>x. x $ i)" |
|
4108 unfolding continuous_on by (intro ballI tendsto_intros) |
|
4109 |
|
4110 lemma continuous_at_infnorm: "continuous (at x) infnorm" |
|
4111 unfolding continuous_at Lim_at o_def unfolding dist_norm |
|
4112 apply auto apply (rule_tac x=e in exI) apply auto |
|
4113 using order_trans[OF real_abs_sub_infnorm infnorm_le_norm, of _ x] by (metis xt1(7)) |
|
4114 |
|
4115 text{* Hence some handy theorems on distance, diameter etc. of/from a set. *} |
|
4116 |
|
4117 lemma compact_attains_sup: |
|
4118 fixes s :: "real set" |
|
4119 assumes "compact s" "s \<noteq> {}" |
|
4120 shows "\<exists>x \<in> s. \<forall>y \<in> s. y \<le> x" |
|
4121 proof- |
|
4122 from assms(1) have a:"bounded s" "closed s" unfolding compact_eq_bounded_closed by auto |
|
4123 { fix e::real assume as: "\<forall>x\<in>s. x \<le> rsup s" "rsup s \<notin> s" "0 < e" "\<forall>x'\<in>s. x' = rsup s \<or> \<not> rsup s - x' < e" |
|
4124 have "isLub UNIV s (rsup s)" using rsup[OF assms(2)] unfolding setle_def using as(1) by auto |
|
4125 moreover have "isUb UNIV s (rsup s - e)" unfolding isUb_def unfolding setle_def using as(4,2) by auto |
|
4126 ultimately have False using isLub_le_isUb[of UNIV s "rsup s" "rsup s - e"] using `e>0` by auto } |
|
4127 thus ?thesis using bounded_has_rsup(1)[OF a(1) assms(2)] using a(2)[unfolded closed_real, THEN spec[where x="rsup s"]] |
|
4128 apply(rule_tac x="rsup s" in bexI) by auto |
|
4129 qed |
|
4130 |
|
4131 lemma compact_attains_inf: |
|
4132 fixes s :: "real set" |
|
4133 assumes "compact s" "s \<noteq> {}" shows "\<exists>x \<in> s. \<forall>y \<in> s. x \<le> y" |
|
4134 proof- |
|
4135 from assms(1) have a:"bounded s" "closed s" unfolding compact_eq_bounded_closed by auto |
|
4136 { fix e::real assume as: "\<forall>x\<in>s. x \<ge> rinf s" "rinf s \<notin> s" "0 < e" |
|
4137 "\<forall>x'\<in>s. x' = rinf s \<or> \<not> abs (x' - rinf s) < e" |
|
4138 have "isGlb UNIV s (rinf s)" using rinf[OF assms(2)] unfolding setge_def using as(1) by auto |
|
4139 moreover |
|
4140 { fix x assume "x \<in> s" |
|
4141 hence *:"abs (x - rinf s) = x - rinf s" using as(1)[THEN bspec[where x=x]] by auto |
|
4142 have "rinf s + e \<le> x" using as(4)[THEN bspec[where x=x]] using as(2) `x\<in>s` unfolding * by auto } |
|
4143 hence "isLb UNIV s (rinf s + e)" unfolding isLb_def and setge_def by auto |
|
4144 ultimately have False using isGlb_le_isLb[of UNIV s "rinf s" "rinf s + e"] using `e>0` by auto } |
|
4145 thus ?thesis using bounded_has_rinf(1)[OF a(1) assms(2)] using a(2)[unfolded closed_real, THEN spec[where x="rinf s"]] |
|
4146 apply(rule_tac x="rinf s" in bexI) by auto |
|
4147 qed |
|
4148 |
|
4149 lemma continuous_attains_sup: |
|
4150 fixes f :: "'a::metric_space \<Rightarrow> real" |
|
4151 shows "compact s \<Longrightarrow> s \<noteq> {} \<Longrightarrow> continuous_on s f |
|
4152 ==> (\<exists>x \<in> s. \<forall>y \<in> s. f y \<le> f x)" |
|
4153 using compact_attains_sup[of "f ` s"] |
|
4154 using compact_continuous_image[of s f] by auto |
|
4155 |
|
4156 lemma continuous_attains_inf: |
|
4157 fixes f :: "'a::metric_space \<Rightarrow> real" |
|
4158 shows "compact s \<Longrightarrow> s \<noteq> {} \<Longrightarrow> continuous_on s f |
|
4159 \<Longrightarrow> (\<exists>x \<in> s. \<forall>y \<in> s. f x \<le> f y)" |
|
4160 using compact_attains_inf[of "f ` s"] |
|
4161 using compact_continuous_image[of s f] by auto |
|
4162 |
|
4163 lemma distance_attains_sup: |
|
4164 assumes "compact s" "s \<noteq> {}" |
|
4165 shows "\<exists>x \<in> s. \<forall>y \<in> s. dist a y \<le> dist a x" |
|
4166 proof (rule continuous_attains_sup [OF assms]) |
|
4167 { fix x assume "x\<in>s" |
|
4168 have "(dist a ---> dist a x) (at x within s)" |
|
4169 by (intro tendsto_dist tendsto_const Lim_at_within Lim_ident_at) |
|
4170 } |
|
4171 thus "continuous_on s (dist a)" |
|
4172 unfolding continuous_on .. |
|
4173 qed |
|
4174 |
|
4175 text{* For *minimal* distance, we only need closure, not compactness. *} |
|
4176 |
|
4177 lemma distance_attains_inf: |
|
4178 fixes a :: "'a::heine_borel" |
|
4179 assumes "closed s" "s \<noteq> {}" |
|
4180 shows "\<exists>x \<in> s. \<forall>y \<in> s. dist a x \<le> dist a y" |
|
4181 proof- |
|
4182 from assms(2) obtain b where "b\<in>s" by auto |
|
4183 let ?B = "cball a (dist b a) \<inter> s" |
|
4184 have "b \<in> ?B" using `b\<in>s` by (simp add: dist_commute) |
|
4185 hence "?B \<noteq> {}" by auto |
|
4186 moreover |
|
4187 { fix x assume "x\<in>?B" |
|
4188 fix e::real assume "e>0" |
|
4189 { fix x' assume "x'\<in>?B" and as:"dist x' x < e" |
|
4190 from as have "\<bar>dist a x' - dist a x\<bar> < e" |
|
4191 unfolding abs_less_iff minus_diff_eq |
|
4192 using dist_triangle2 [of a x' x] |
|
4193 using dist_triangle [of a x x'] |
|
4194 by arith |
|
4195 } |
|
4196 hence "\<exists>d>0. \<forall>x'\<in>?B. dist x' x < d \<longrightarrow> \<bar>dist a x' - dist a x\<bar> < e" |
|
4197 using `e>0` by auto |
|
4198 } |
|
4199 hence "continuous_on (cball a (dist b a) \<inter> s) (dist a)" |
|
4200 unfolding continuous_on Lim_within dist_norm real_norm_def |
|
4201 by fast |
|
4202 moreover have "compact ?B" |
|
4203 using compact_cball[of a "dist b a"] |
|
4204 unfolding compact_eq_bounded_closed |
|
4205 using bounded_Int and closed_Int and assms(1) by auto |
|
4206 ultimately obtain x where "x\<in>cball a (dist b a) \<inter> s" "\<forall>y\<in>cball a (dist b a) \<inter> s. dist a x \<le> dist a y" |
|
4207 using continuous_attains_inf[of ?B "dist a"] by fastsimp |
|
4208 thus ?thesis by fastsimp |
|
4209 qed |
|
4210 |
|
4211 subsection{* We can now extend limit compositions to consider the scalar multiplier. *} |
|
4212 |
|
4213 lemma Lim_mul: |
|
4214 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
4215 assumes "(c ---> d) net" "(f ---> l) net" |
|
4216 shows "((\<lambda>x. c(x) *\<^sub>R f x) ---> (d *\<^sub>R l)) net" |
|
4217 using assms by (rule scaleR.tendsto) |
|
4218 |
|
4219 lemma Lim_vmul: |
|
4220 fixes c :: "'a \<Rightarrow> real" and v :: "'b::real_normed_vector" |
|
4221 shows "(c ---> d) net ==> ((\<lambda>x. c(x) *\<^sub>R v) ---> d *\<^sub>R v) net" |
|
4222 by (intro tendsto_intros) |
|
4223 |
|
4224 lemma continuous_vmul: |
|
4225 fixes c :: "'a::metric_space \<Rightarrow> real" and v :: "'b::real_normed_vector" |
|
4226 shows "continuous net c ==> continuous net (\<lambda>x. c(x) *\<^sub>R v)" |
|
4227 unfolding continuous_def using Lim_vmul[of c] by auto |
|
4228 |
|
4229 lemma continuous_mul: |
|
4230 fixes c :: "'a::metric_space \<Rightarrow> real" |
|
4231 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
4232 shows "continuous net c \<Longrightarrow> continuous net f |
|
4233 ==> continuous net (\<lambda>x. c(x) *\<^sub>R f x) " |
|
4234 unfolding continuous_def by (intro tendsto_intros) |
|
4235 |
|
4236 lemma continuous_on_vmul: |
|
4237 fixes c :: "'a::metric_space \<Rightarrow> real" and v :: "'b::real_normed_vector" |
|
4238 shows "continuous_on s c ==> continuous_on s (\<lambda>x. c(x) *\<^sub>R v)" |
|
4239 unfolding continuous_on_eq_continuous_within using continuous_vmul[of _ c] by auto |
|
4240 |
|
4241 lemma continuous_on_mul: |
|
4242 fixes c :: "'a::metric_space \<Rightarrow> real" |
|
4243 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
4244 shows "continuous_on s c \<Longrightarrow> continuous_on s f |
|
4245 ==> continuous_on s (\<lambda>x. c(x) *\<^sub>R f x)" |
|
4246 unfolding continuous_on_eq_continuous_within using continuous_mul[of _ c] by auto |
|
4247 |
|
4248 text{* And so we have continuity of inverse. *} |
|
4249 |
|
4250 lemma Lim_inv: |
|
4251 fixes f :: "'a \<Rightarrow> real" |
|
4252 assumes "(f ---> l) (net::'a net)" "l \<noteq> 0" |
|
4253 shows "((inverse o f) ---> inverse l) net" |
|
4254 unfolding o_def using assms by (rule tendsto_inverse) |
|
4255 |
|
4256 lemma continuous_inv: |
|
4257 fixes f :: "'a::metric_space \<Rightarrow> real" |
|
4258 shows "continuous net f \<Longrightarrow> f(netlimit net) \<noteq> 0 |
|
4259 ==> continuous net (inverse o f)" |
|
4260 unfolding continuous_def using Lim_inv by auto |
|
4261 |
|
4262 lemma continuous_at_within_inv: |
|
4263 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_field" |
|
4264 assumes "continuous (at a within s) f" "f a \<noteq> 0" |
|
4265 shows "continuous (at a within s) (inverse o f)" |
|
4266 using assms unfolding continuous_within o_def |
|
4267 by (intro tendsto_intros) |
|
4268 |
|
4269 lemma continuous_at_inv: |
|
4270 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_field" |
|
4271 shows "continuous (at a) f \<Longrightarrow> f a \<noteq> 0 |
|
4272 ==> continuous (at a) (inverse o f) " |
|
4273 using within_UNIV[THEN sym, of "at a"] using continuous_at_within_inv[of a UNIV] by auto |
|
4274 |
|
4275 subsection{* Preservation properties for pasted sets. *} |
|
4276 |
|
4277 lemma bounded_pastecart: |
|
4278 fixes s :: "('a::real_normed_vector ^ _) set" (* FIXME: generalize to metric_space *) |
|
4279 assumes "bounded s" "bounded t" |
|
4280 shows "bounded { pastecart x y | x y . (x \<in> s \<and> y \<in> t)}" |
|
4281 proof- |
|
4282 obtain a b where ab:"\<forall>x\<in>s. norm x \<le> a" "\<forall>x\<in>t. norm x \<le> b" using assms[unfolded bounded_iff] by auto |
|
4283 { fix x y assume "x\<in>s" "y\<in>t" |
|
4284 hence "norm x \<le> a" "norm y \<le> b" using ab by auto |
|
4285 hence "norm (pastecart x y) \<le> a + b" using norm_pastecart[of x y] by auto } |
|
4286 thus ?thesis unfolding bounded_iff by auto |
|
4287 qed |
|
4288 |
|
4289 lemma bounded_Times: |
|
4290 assumes "bounded s" "bounded t" shows "bounded (s \<times> t)" |
|
4291 proof- |
|
4292 obtain x y a b where "\<forall>z\<in>s. dist x z \<le> a" "\<forall>z\<in>t. dist y z \<le> b" |
|
4293 using assms [unfolded bounded_def] by auto |
|
4294 then have "\<forall>z\<in>s \<times> t. dist (x, y) z \<le> sqrt (a\<twosuperior> + b\<twosuperior>)" |
|
4295 by (auto simp add: dist_Pair_Pair real_sqrt_le_mono add_mono power_mono) |
|
4296 thus ?thesis unfolding bounded_any_center [where a="(x, y)"] by auto |
|
4297 qed |
|
4298 |
|
4299 lemma closed_pastecart: |
|
4300 fixes s :: "(real ^ 'a::finite) set" (* FIXME: generalize *) |
|
4301 assumes "closed s" "closed t" |
|
4302 shows "closed {pastecart x y | x y . x \<in> s \<and> y \<in> t}" |
|
4303 proof- |
|
4304 { fix x l assume as:"\<forall>n::nat. x n \<in> {pastecart x y |x y. x \<in> s \<and> y \<in> t}" "(x ---> l) sequentially" |
|
4305 { fix n::nat have "fstcart (x n) \<in> s" "sndcart (x n) \<in> t" using as(1)[THEN spec[where x=n]] by auto } note * = this |
|
4306 moreover |
|
4307 { fix e::real assume "e>0" |
|
4308 then obtain N::nat where N:"\<forall>n\<ge>N. dist (x n) l < e" using as(2)[unfolded Lim_sequentially, THEN spec[where x=e]] by auto |
|
4309 { fix n::nat assume "n\<ge>N" |
|
4310 hence "dist (fstcart (x n)) (fstcart l) < e" "dist (sndcart (x n)) (sndcart l) < e" |
|
4311 using N[THEN spec[where x=n]] dist_fstcart[of "x n" l] dist_sndcart[of "x n" l] by auto } |
|
4312 hence "\<exists>N. \<forall>n\<ge>N. dist (fstcart (x n)) (fstcart l) < e" "\<exists>N. \<forall>n\<ge>N. dist (sndcart (x n)) (sndcart l) < e" by auto } |
|
4313 ultimately have "fstcart l \<in> s" "sndcart l \<in> t" |
|
4314 using assms(1)[unfolded closed_sequential_limits, THEN spec[where x="\<lambda>n. fstcart (x n)"], THEN spec[where x="fstcart l"]] |
|
4315 using assms(2)[unfolded closed_sequential_limits, THEN spec[where x="\<lambda>n. sndcart (x n)"], THEN spec[where x="sndcart l"]] |
|
4316 unfolding Lim_sequentially by auto |
|
4317 hence "l \<in> {pastecart x y |x y. x \<in> s \<and> y \<in> t}" using pastecart_fst_snd[THEN sym, of l] by auto } |
|
4318 thus ?thesis unfolding closed_sequential_limits by auto |
|
4319 qed |
|
4320 |
|
4321 lemma compact_pastecart: |
|
4322 fixes s t :: "(real ^ _) set" |
|
4323 shows "compact s \<Longrightarrow> compact t ==> compact {pastecart x y | x y . x \<in> s \<and> y \<in> t}" |
|
4324 unfolding compact_eq_bounded_closed using bounded_pastecart[of s t] closed_pastecart[of s t] by auto |
|
4325 |
|
4326 lemma mem_Times_iff: "x \<in> A \<times> B \<longleftrightarrow> fst x \<in> A \<and> snd x \<in> B" |
|
4327 by (induct x) simp |
|
4328 |
|
4329 lemma compact_Times: "compact s \<Longrightarrow> compact t \<Longrightarrow> compact (s \<times> t)" |
|
4330 unfolding compact_def |
|
4331 apply clarify |
|
4332 apply (drule_tac x="fst \<circ> f" in spec) |
|
4333 apply (drule mp, simp add: mem_Times_iff) |
|
4334 apply (clarify, rename_tac l1 r1) |
|
4335 apply (drule_tac x="snd \<circ> f \<circ> r1" in spec) |
|
4336 apply (drule mp, simp add: mem_Times_iff) |
|
4337 apply (clarify, rename_tac l2 r2) |
|
4338 apply (rule_tac x="(l1, l2)" in rev_bexI, simp) |
|
4339 apply (rule_tac x="r1 \<circ> r2" in exI) |
|
4340 apply (rule conjI, simp add: subseq_def) |
|
4341 apply (drule_tac r=r2 in lim_subseq [COMP swap_prems_rl], assumption) |
|
4342 apply (drule (1) tendsto_Pair) back |
|
4343 apply (simp add: o_def) |
|
4344 done |
|
4345 |
|
4346 text{* Hence some useful properties follow quite easily. *} |
|
4347 |
|
4348 lemma compact_scaling: |
|
4349 fixes s :: "'a::real_normed_vector set" |
|
4350 assumes "compact s" shows "compact ((\<lambda>x. c *\<^sub>R x) ` s)" |
|
4351 proof- |
|
4352 let ?f = "\<lambda>x. scaleR c x" |
|
4353 have *:"bounded_linear ?f" by (rule scaleR.bounded_linear_right) |
|
4354 show ?thesis using compact_continuous_image[of s ?f] continuous_at_imp_continuous_on[of s ?f] |
|
4355 using linear_continuous_at[OF *] assms by auto |
|
4356 qed |
|
4357 |
|
4358 lemma compact_negations: |
|
4359 fixes s :: "'a::real_normed_vector set" |
|
4360 assumes "compact s" shows "compact ((\<lambda>x. -x) ` s)" |
|
4361 using compact_scaling [OF assms, of "- 1"] by auto |
|
4362 |
|
4363 lemma compact_sums: |
|
4364 fixes s t :: "'a::real_normed_vector set" |
|
4365 assumes "compact s" "compact t" shows "compact {x + y | x y. x \<in> s \<and> y \<in> t}" |
|
4366 proof- |
|
4367 have *:"{x + y | x y. x \<in> s \<and> y \<in> t} = (\<lambda>z. fst z + snd z) ` (s \<times> t)" |
|
4368 apply auto unfolding image_iff apply(rule_tac x="(xa, y)" in bexI) by auto |
|
4369 have "continuous_on (s \<times> t) (\<lambda>z. fst z + snd z)" |
|
4370 unfolding continuous_on by (rule ballI) (intro tendsto_intros) |
|
4371 thus ?thesis unfolding * using compact_continuous_image compact_Times [OF assms] by auto |
|
4372 qed |
|
4373 |
|
4374 lemma compact_differences: |
|
4375 fixes s t :: "'a::real_normed_vector set" |
|
4376 assumes "compact s" "compact t" shows "compact {x - y | x y. x \<in> s \<and> y \<in> t}" |
|
4377 proof- |
|
4378 have "{x - y | x y. x\<in>s \<and> y \<in> t} = {x + y | x y. x \<in> s \<and> y \<in> (uminus ` t)}" |
|
4379 apply auto apply(rule_tac x= xa in exI) apply auto apply(rule_tac x=xa in exI) by auto |
|
4380 thus ?thesis using compact_sums[OF assms(1) compact_negations[OF assms(2)]] by auto |
|
4381 qed |
|
4382 |
|
4383 lemma compact_translation: |
|
4384 fixes s :: "'a::real_normed_vector set" |
|
4385 assumes "compact s" shows "compact ((\<lambda>x. a + x) ` s)" |
|
4386 proof- |
|
4387 have "{x + y |x y. x \<in> s \<and> y \<in> {a}} = (\<lambda>x. a + x) ` s" by auto |
|
4388 thus ?thesis using compact_sums[OF assms compact_sing[of a]] by auto |
|
4389 qed |
|
4390 |
|
4391 lemma compact_affinity: |
|
4392 fixes s :: "'a::real_normed_vector set" |
|
4393 assumes "compact s" shows "compact ((\<lambda>x. a + c *\<^sub>R x) ` s)" |
|
4394 proof- |
|
4395 have "op + a ` op *\<^sub>R c ` s = (\<lambda>x. a + c *\<^sub>R x) ` s" by auto |
|
4396 thus ?thesis using compact_translation[OF compact_scaling[OF assms], of a c] by auto |
|
4397 qed |
|
4398 |
|
4399 text{* Hence we get the following. *} |
|
4400 |
|
4401 lemma compact_sup_maxdistance: |
|
4402 fixes s :: "'a::real_normed_vector set" |
|
4403 assumes "compact s" "s \<noteq> {}" |
|
4404 shows "\<exists>x\<in>s. \<exists>y\<in>s. \<forall>u\<in>s. \<forall>v\<in>s. norm(u - v) \<le> norm(x - y)" |
|
4405 proof- |
|
4406 have "{x - y | x y . x\<in>s \<and> y\<in>s} \<noteq> {}" using `s \<noteq> {}` by auto |
|
4407 then obtain x where x:"x\<in>{x - y |x y. x \<in> s \<and> y \<in> s}" "\<forall>y\<in>{x - y |x y. x \<in> s \<and> y \<in> s}. norm y \<le> norm x" |
|
4408 using compact_differences[OF assms(1) assms(1)] |
|
4409 using distance_attains_sup[where 'a="'a", unfolded dist_norm, of "{x - y | x y . x\<in>s \<and> y\<in>s}" 0] by(auto simp add: norm_minus_cancel) |
|
4410 from x(1) obtain a b where "a\<in>s" "b\<in>s" "x = a - b" by auto |
|
4411 thus ?thesis using x(2)[unfolded `x = a - b`] by blast |
|
4412 qed |
|
4413 |
|
4414 text{* We can state this in terms of diameter of a set. *} |
|
4415 |
|
4416 definition "diameter s = (if s = {} then 0::real else rsup {norm(x - y) | x y. x \<in> s \<and> y \<in> s})" |
|
4417 (* TODO: generalize to class metric_space *) |
|
4418 |
|
4419 lemma diameter_bounded: |
|
4420 assumes "bounded s" |
|
4421 shows "\<forall>x\<in>s. \<forall>y\<in>s. norm(x - y) \<le> diameter s" |
|
4422 "\<forall>d>0. d < diameter s --> (\<exists>x\<in>s. \<exists>y\<in>s. norm(x - y) > d)" |
|
4423 proof- |
|
4424 let ?D = "{norm (x - y) |x y. x \<in> s \<and> y \<in> s}" |
|
4425 obtain a where a:"\<forall>x\<in>s. norm x \<le> a" using assms[unfolded bounded_iff] by auto |
|
4426 { fix x y assume "x \<in> s" "y \<in> s" |
|
4427 hence "norm (x - y) \<le> 2 * a" using norm_triangle_ineq[of x "-y", unfolded norm_minus_cancel] a[THEN bspec[where x=x]] a[THEN bspec[where x=y]] by (auto simp add: ring_simps) } |
|
4428 note * = this |
|
4429 { fix x y assume "x\<in>s" "y\<in>s" hence "s \<noteq> {}" by auto |
|
4430 have lub:"isLub UNIV ?D (rsup ?D)" using * rsup[of ?D] using `s\<noteq>{}` unfolding setle_def by auto |
|
4431 have "norm(x - y) \<le> diameter s" unfolding diameter_def using `s\<noteq>{}` *[OF `x\<in>s` `y\<in>s`] `x\<in>s` `y\<in>s` isLubD1[OF lub] unfolding setle_def by auto } |
|
4432 moreover |
|
4433 { fix d::real assume "d>0" "d < diameter s" |
|
4434 hence "s\<noteq>{}" unfolding diameter_def by auto |
|
4435 hence lub:"isLub UNIV ?D (rsup ?D)" using * rsup[of ?D] unfolding setle_def by auto |
|
4436 have "\<exists>d' \<in> ?D. d' > d" |
|
4437 proof(rule ccontr) |
|
4438 assume "\<not> (\<exists>d'\<in>{norm (x - y) |x y. x \<in> s \<and> y \<in> s}. d < d')" |
|
4439 hence as:"\<forall>d'\<in>?D. d' \<le> d" apply auto apply(erule_tac x="norm (x - y)" in allE) by auto |
|
4440 hence "isUb UNIV ?D d" unfolding isUb_def unfolding setle_def by auto |
|
4441 thus False using `d < diameter s` `s\<noteq>{}` isLub_le_isUb[OF lub, of d] unfolding diameter_def by auto |
|
4442 qed |
|
4443 hence "\<exists>x\<in>s. \<exists>y\<in>s. norm(x - y) > d" by auto } |
|
4444 ultimately show "\<forall>x\<in>s. \<forall>y\<in>s. norm(x - y) \<le> diameter s" |
|
4445 "\<forall>d>0. d < diameter s --> (\<exists>x\<in>s. \<exists>y\<in>s. norm(x - y) > d)" by auto |
|
4446 qed |
|
4447 |
|
4448 lemma diameter_bounded_bound: |
|
4449 "bounded s \<Longrightarrow> x \<in> s \<Longrightarrow> y \<in> s ==> norm(x - y) \<le> diameter s" |
|
4450 using diameter_bounded by blast |
|
4451 |
|
4452 lemma diameter_compact_attained: |
|
4453 fixes s :: "'a::real_normed_vector set" |
|
4454 assumes "compact s" "s \<noteq> {}" |
|
4455 shows "\<exists>x\<in>s. \<exists>y\<in>s. (norm(x - y) = diameter s)" |
|
4456 proof- |
|
4457 have b:"bounded s" using assms(1) by (rule compact_imp_bounded) |
|
4458 then obtain x y where xys:"x\<in>s" "y\<in>s" and xy:"\<forall>u\<in>s. \<forall>v\<in>s. norm (u - v) \<le> norm (x - y)" using compact_sup_maxdistance[OF assms] by auto |
|
4459 hence "diameter s \<le> norm (x - y)" using rsup_le[of "{norm (x - y) |x y. x \<in> s \<and> y \<in> s}" "norm (x - y)"] |
|
4460 unfolding setle_def and diameter_def by auto |
|
4461 thus ?thesis using diameter_bounded(1)[OF b, THEN bspec[where x=x], THEN bspec[where x=y], OF xys] and xys by auto |
|
4462 qed |
|
4463 |
|
4464 text{* Related results with closure as the conclusion. *} |
|
4465 |
|
4466 lemma closed_scaling: |
|
4467 fixes s :: "'a::real_normed_vector set" |
|
4468 assumes "closed s" shows "closed ((\<lambda>x. c *\<^sub>R x) ` s)" |
|
4469 proof(cases "s={}") |
|
4470 case True thus ?thesis by auto |
|
4471 next |
|
4472 case False |
|
4473 show ?thesis |
|
4474 proof(cases "c=0") |
|
4475 have *:"(\<lambda>x. 0) ` s = {0}" using `s\<noteq>{}` by auto |
|
4476 case True thus ?thesis apply auto unfolding * using closed_sing by auto |
|
4477 next |
|
4478 case False |
|
4479 { fix x l assume as:"\<forall>n::nat. x n \<in> scaleR c ` s" "(x ---> l) sequentially" |
|
4480 { fix n::nat have "scaleR (1 / c) (x n) \<in> s" |
|
4481 using as(1)[THEN spec[where x=n]] |
|
4482 using `c\<noteq>0` by (auto simp add: vector_smult_assoc) |
|
4483 } |
|
4484 moreover |
|
4485 { fix e::real assume "e>0" |
|
4486 hence "0 < e *\<bar>c\<bar>" using `c\<noteq>0` mult_pos_pos[of e "abs c"] by auto |
|
4487 then obtain N where "\<forall>n\<ge>N. dist (x n) l < e * \<bar>c\<bar>" |
|
4488 using as(2)[unfolded Lim_sequentially, THEN spec[where x="e * abs c"]] by auto |
|
4489 hence "\<exists>N. \<forall>n\<ge>N. dist (scaleR (1 / c) (x n)) (scaleR (1 / c) l) < e" |
|
4490 unfolding dist_norm unfolding scaleR_right_diff_distrib[THEN sym] |
|
4491 using mult_imp_div_pos_less[of "abs c" _ e] `c\<noteq>0` by auto } |
|
4492 hence "((\<lambda>n. scaleR (1 / c) (x n)) ---> scaleR (1 / c) l) sequentially" unfolding Lim_sequentially by auto |
|
4493 ultimately have "l \<in> scaleR c ` s" |
|
4494 using assms[unfolded closed_sequential_limits, THEN spec[where x="\<lambda>n. scaleR (1/c) (x n)"], THEN spec[where x="scaleR (1/c) l"]] |
|
4495 unfolding image_iff using `c\<noteq>0` apply(rule_tac x="scaleR (1 / c) l" in bexI) by auto } |
|
4496 thus ?thesis unfolding closed_sequential_limits by fast |
|
4497 qed |
|
4498 qed |
|
4499 |
|
4500 lemma closed_negations: |
|
4501 fixes s :: "'a::real_normed_vector set" |
|
4502 assumes "closed s" shows "closed ((\<lambda>x. -x) ` s)" |
|
4503 using closed_scaling[OF assms, of "- 1"] by simp |
|
4504 |
|
4505 lemma compact_closed_sums: |
|
4506 fixes s :: "'a::real_normed_vector set" |
|
4507 assumes "compact s" "closed t" shows "closed {x + y | x y. x \<in> s \<and> y \<in> t}" |
|
4508 proof- |
|
4509 let ?S = "{x + y |x y. x \<in> s \<and> y \<in> t}" |
|
4510 { fix x l assume as:"\<forall>n. x n \<in> ?S" "(x ---> l) sequentially" |
|
4511 from as(1) obtain f where f:"\<forall>n. x n = fst (f n) + snd (f n)" "\<forall>n. fst (f n) \<in> s" "\<forall>n. snd (f n) \<in> t" |
|
4512 using choice[of "\<lambda>n y. x n = (fst y) + (snd y) \<and> fst y \<in> s \<and> snd y \<in> t"] by auto |
|
4513 obtain l' r where "l'\<in>s" and r:"subseq r" and lr:"(((\<lambda>n. fst (f n)) \<circ> r) ---> l') sequentially" |
|
4514 using assms(1)[unfolded compact_def, THEN spec[where x="\<lambda> n. fst (f n)"]] using f(2) by auto |
|
4515 have "((\<lambda>n. snd (f (r n))) ---> l - l') sequentially" |
|
4516 using Lim_sub[OF lim_subseq[OF r as(2)] lr] and f(1) unfolding o_def by auto |
|
4517 hence "l - l' \<in> t" |
|
4518 using assms(2)[unfolded closed_sequential_limits, THEN spec[where x="\<lambda> n. snd (f (r n))"], THEN spec[where x="l - l'"]] |
|
4519 using f(3) by auto |
|
4520 hence "l \<in> ?S" using `l' \<in> s` apply auto apply(rule_tac x=l' in exI) apply(rule_tac x="l - l'" in exI) by auto |
|
4521 } |
|
4522 thus ?thesis unfolding closed_sequential_limits by fast |
|
4523 qed |
|
4524 |
|
4525 lemma closed_compact_sums: |
|
4526 fixes s t :: "'a::real_normed_vector set" |
|
4527 assumes "closed s" "compact t" |
|
4528 shows "closed {x + y | x y. x \<in> s \<and> y \<in> t}" |
|
4529 proof- |
|
4530 have "{x + y |x y. x \<in> t \<and> y \<in> s} = {x + y |x y. x \<in> s \<and> y \<in> t}" apply auto |
|
4531 apply(rule_tac x=y in exI) apply auto apply(rule_tac x=y in exI) by auto |
|
4532 thus ?thesis using compact_closed_sums[OF assms(2,1)] by simp |
|
4533 qed |
|
4534 |
|
4535 lemma compact_closed_differences: |
|
4536 fixes s t :: "'a::real_normed_vector set" |
|
4537 assumes "compact s" "closed t" |
|
4538 shows "closed {x - y | x y. x \<in> s \<and> y \<in> t}" |
|
4539 proof- |
|
4540 have "{x + y |x y. x \<in> s \<and> y \<in> uminus ` t} = {x - y |x y. x \<in> s \<and> y \<in> t}" |
|
4541 apply auto apply(rule_tac x=xa in exI) apply auto apply(rule_tac x=xa in exI) by auto |
|
4542 thus ?thesis using compact_closed_sums[OF assms(1) closed_negations[OF assms(2)]] by auto |
|
4543 qed |
|
4544 |
|
4545 lemma closed_compact_differences: |
|
4546 fixes s t :: "'a::real_normed_vector set" |
|
4547 assumes "closed s" "compact t" |
|
4548 shows "closed {x - y | x y. x \<in> s \<and> y \<in> t}" |
|
4549 proof- |
|
4550 have "{x + y |x y. x \<in> s \<and> y \<in> uminus ` t} = {x - y |x y. x \<in> s \<and> y \<in> t}" |
|
4551 apply auto apply(rule_tac x=xa in exI) apply auto apply(rule_tac x=xa in exI) by auto |
|
4552 thus ?thesis using closed_compact_sums[OF assms(1) compact_negations[OF assms(2)]] by simp |
|
4553 qed |
|
4554 |
|
4555 lemma closed_translation: |
|
4556 fixes a :: "'a::real_normed_vector" |
|
4557 assumes "closed s" shows "closed ((\<lambda>x. a + x) ` s)" |
|
4558 proof- |
|
4559 have "{a + y |y. y \<in> s} = (op + a ` s)" by auto |
|
4560 thus ?thesis using compact_closed_sums[OF compact_sing[of a] assms] by auto |
|
4561 qed |
|
4562 |
|
4563 lemma translation_UNIV: |
|
4564 fixes a :: "'a::ab_group_add" shows "range (\<lambda>x. a + x) = UNIV" |
|
4565 apply (auto simp add: image_iff) apply(rule_tac x="x - a" in exI) by auto |
|
4566 |
|
4567 lemma translation_diff: |
|
4568 fixes a :: "'a::ab_group_add" |
|
4569 shows "(\<lambda>x. a + x) ` (s - t) = ((\<lambda>x. a + x) ` s) - ((\<lambda>x. a + x) ` t)" |
|
4570 by auto |
|
4571 |
|
4572 lemma closure_translation: |
|
4573 fixes a :: "'a::real_normed_vector" |
|
4574 shows "closure ((\<lambda>x. a + x) ` s) = (\<lambda>x. a + x) ` (closure s)" |
|
4575 proof- |
|
4576 have *:"op + a ` (UNIV - s) = UNIV - op + a ` s" |
|
4577 apply auto unfolding image_iff apply(rule_tac x="x - a" in bexI) by auto |
|
4578 show ?thesis unfolding closure_interior translation_diff translation_UNIV |
|
4579 using interior_translation[of a "UNIV - s"] unfolding * by auto |
|
4580 qed |
|
4581 |
|
4582 lemma frontier_translation: |
|
4583 fixes a :: "'a::real_normed_vector" |
|
4584 shows "frontier((\<lambda>x. a + x) ` s) = (\<lambda>x. a + x) ` (frontier s)" |
|
4585 unfolding frontier_def translation_diff interior_translation closure_translation by auto |
|
4586 |
|
4587 subsection{* Separation between points and sets. *} |
|
4588 |
|
4589 lemma separate_point_closed: |
|
4590 fixes s :: "'a::heine_borel set" |
|
4591 shows "closed s \<Longrightarrow> a \<notin> s ==> (\<exists>d>0. \<forall>x\<in>s. d \<le> dist a x)" |
|
4592 proof(cases "s = {}") |
|
4593 case True |
|
4594 thus ?thesis by(auto intro!: exI[where x=1]) |
|
4595 next |
|
4596 case False |
|
4597 assume "closed s" "a \<notin> s" |
|
4598 then obtain x where "x\<in>s" "\<forall>y\<in>s. dist a x \<le> dist a y" using `s \<noteq> {}` distance_attains_inf [of s a] by blast |
|
4599 with `x\<in>s` show ?thesis using dist_pos_lt[of a x] and`a \<notin> s` by blast |
|
4600 qed |
|
4601 |
|
4602 lemma separate_compact_closed: |
|
4603 fixes s t :: "'a::{heine_borel, real_normed_vector} set" |
|
4604 (* TODO: does this generalize to heine_borel? *) |
|
4605 assumes "compact s" and "closed t" and "s \<inter> t = {}" |
|
4606 shows "\<exists>d>0. \<forall>x\<in>s. \<forall>y\<in>t. d \<le> dist x y" |
|
4607 proof- |
|
4608 have "0 \<notin> {x - y |x y. x \<in> s \<and> y \<in> t}" using assms(3) by auto |
|
4609 then obtain d where "d>0" and d:"\<forall>x\<in>{x - y |x y. x \<in> s \<and> y \<in> t}. d \<le> dist 0 x" |
|
4610 using separate_point_closed[OF compact_closed_differences[OF assms(1,2)], of 0] by auto |
|
4611 { fix x y assume "x\<in>s" "y\<in>t" |
|
4612 hence "x - y \<in> {x - y |x y. x \<in> s \<and> y \<in> t}" by auto |
|
4613 hence "d \<le> dist (x - y) 0" using d[THEN bspec[where x="x - y"]] using dist_commute |
|
4614 by (auto simp add: dist_commute) |
|
4615 hence "d \<le> dist x y" unfolding dist_norm by auto } |
|
4616 thus ?thesis using `d>0` by auto |
|
4617 qed |
|
4618 |
|
4619 lemma separate_closed_compact: |
|
4620 fixes s t :: "'a::{heine_borel, real_normed_vector} set" |
|
4621 assumes "closed s" and "compact t" and "s \<inter> t = {}" |
|
4622 shows "\<exists>d>0. \<forall>x\<in>s. \<forall>y\<in>t. d \<le> dist x y" |
|
4623 proof- |
|
4624 have *:"t \<inter> s = {}" using assms(3) by auto |
|
4625 show ?thesis using separate_compact_closed[OF assms(2,1) *] |
|
4626 apply auto apply(rule_tac x=d in exI) apply auto apply (erule_tac x=y in ballE) |
|
4627 by (auto simp add: dist_commute) |
|
4628 qed |
|
4629 |
|
4630 (* A cute way of denoting open and closed intervals using overloading. *) |
|
4631 |
|
4632 lemma interval: fixes a :: "'a::ord^'n::finite" shows |
|
4633 "{a <..< b} = {x::'a^'n. \<forall>i. a$i < x$i \<and> x$i < b$i}" and |
|
4634 "{a .. b} = {x::'a^'n. \<forall>i. a$i \<le> x$i \<and> x$i \<le> b$i}" |
|
4635 by (auto simp add: expand_set_eq vector_less_def vector_less_eq_def) |
|
4636 |
|
4637 lemma mem_interval: fixes a :: "'a::ord^'n::finite" shows |
|
4638 "x \<in> {a<..<b} \<longleftrightarrow> (\<forall>i. a$i < x$i \<and> x$i < b$i)" |
|
4639 "x \<in> {a .. b} \<longleftrightarrow> (\<forall>i. a$i \<le> x$i \<and> x$i \<le> b$i)" |
|
4640 using interval[of a b] by(auto simp add: expand_set_eq vector_less_def vector_less_eq_def) |
|
4641 |
|
4642 lemma mem_interval_1: fixes x :: "real^1" shows |
|
4643 "(x \<in> {a .. b} \<longleftrightarrow> dest_vec1 a \<le> dest_vec1 x \<and> dest_vec1 x \<le> dest_vec1 b)" |
|
4644 "(x \<in> {a<..<b} \<longleftrightarrow> dest_vec1 a < dest_vec1 x \<and> dest_vec1 x < dest_vec1 b)" |
|
4645 by(simp_all add: Cart_eq vector_less_def vector_less_eq_def dest_vec1_def forall_1) |
|
4646 |
|
4647 lemma interval_eq_empty: fixes a :: "real^'n::finite" shows |
|
4648 "({a <..< b} = {} \<longleftrightarrow> (\<exists>i. b$i \<le> a$i))" (is ?th1) and |
|
4649 "({a .. b} = {} \<longleftrightarrow> (\<exists>i. b$i < a$i))" (is ?th2) |
|
4650 proof- |
|
4651 { fix i x assume as:"b$i \<le> a$i" and x:"x\<in>{a <..< b}" |
|
4652 hence "a $ i < x $ i \<and> x $ i < b $ i" unfolding mem_interval by auto |
|
4653 hence "a$i < b$i" by auto |
|
4654 hence False using as by auto } |
|
4655 moreover |
|
4656 { assume as:"\<forall>i. \<not> (b$i \<le> a$i)" |
|
4657 let ?x = "(1/2) *\<^sub>R (a + b)" |
|
4658 { fix i |
|
4659 have "a$i < b$i" using as[THEN spec[where x=i]] by auto |
|
4660 hence "a$i < ((1/2) *\<^sub>R (a+b)) $ i" "((1/2) *\<^sub>R (a+b)) $ i < b$i" |
|
4661 unfolding vector_smult_component and vector_add_component |
|
4662 by (auto simp add: less_divide_eq_number_of1) } |
|
4663 hence "{a <..< b} \<noteq> {}" using mem_interval(1)[of "?x" a b] by auto } |
|
4664 ultimately show ?th1 by blast |
|
4665 |
|
4666 { fix i x assume as:"b$i < a$i" and x:"x\<in>{a .. b}" |
|
4667 hence "a $ i \<le> x $ i \<and> x $ i \<le> b $ i" unfolding mem_interval by auto |
|
4668 hence "a$i \<le> b$i" by auto |
|
4669 hence False using as by auto } |
|
4670 moreover |
|
4671 { assume as:"\<forall>i. \<not> (b$i < a$i)" |
|
4672 let ?x = "(1/2) *\<^sub>R (a + b)" |
|
4673 { fix i |
|
4674 have "a$i \<le> b$i" using as[THEN spec[where x=i]] by auto |
|
4675 hence "a$i \<le> ((1/2) *\<^sub>R (a+b)) $ i" "((1/2) *\<^sub>R (a+b)) $ i \<le> b$i" |
|
4676 unfolding vector_smult_component and vector_add_component |
|
4677 by (auto simp add: less_divide_eq_number_of1) } |
|
4678 hence "{a .. b} \<noteq> {}" using mem_interval(2)[of "?x" a b] by auto } |
|
4679 ultimately show ?th2 by blast |
|
4680 qed |
|
4681 |
|
4682 lemma interval_ne_empty: fixes a :: "real^'n::finite" shows |
|
4683 "{a .. b} \<noteq> {} \<longleftrightarrow> (\<forall>i. a$i \<le> b$i)" and |
|
4684 "{a <..< b} \<noteq> {} \<longleftrightarrow> (\<forall>i. a$i < b$i)" |
|
4685 unfolding interval_eq_empty[of a b] by (auto simp add: not_less not_le) (* BH: Why doesn't just "auto" work here? *) |
|
4686 |
|
4687 lemma subset_interval_imp: fixes a :: "real^'n::finite" shows |
|
4688 "(\<forall>i. a$i \<le> c$i \<and> d$i \<le> b$i) \<Longrightarrow> {c .. d} \<subseteq> {a .. b}" and |
|
4689 "(\<forall>i. a$i < c$i \<and> d$i < b$i) \<Longrightarrow> {c .. d} \<subseteq> {a<..<b}" and |
|
4690 "(\<forall>i. a$i \<le> c$i \<and> d$i \<le> b$i) \<Longrightarrow> {c<..<d} \<subseteq> {a .. b}" and |
|
4691 "(\<forall>i. a$i \<le> c$i \<and> d$i \<le> b$i) \<Longrightarrow> {c<..<d} \<subseteq> {a<..<b}" |
|
4692 unfolding subset_eq[unfolded Ball_def] unfolding mem_interval |
|
4693 by (auto intro: order_trans less_le_trans le_less_trans less_imp_le) (* BH: Why doesn't just "auto" work here? *) |
|
4694 |
|
4695 lemma interval_sing: fixes a :: "'a::linorder^'n::finite" shows |
|
4696 "{a .. a} = {a} \<and> {a<..<a} = {}" |
|
4697 apply(auto simp add: expand_set_eq vector_less_def vector_less_eq_def Cart_eq) |
|
4698 apply (simp add: order_eq_iff) |
|
4699 apply (auto simp add: not_less less_imp_le) |
|
4700 done |
|
4701 |
|
4702 lemma interval_open_subset_closed: fixes a :: "'a::preorder^'n::finite" shows |
|
4703 "{a<..<b} \<subseteq> {a .. b}" |
|
4704 proof(simp add: subset_eq, rule) |
|
4705 fix x |
|
4706 assume x:"x \<in>{a<..<b}" |
|
4707 { fix i |
|
4708 have "a $ i \<le> x $ i" |
|
4709 using x order_less_imp_le[of "a$i" "x$i"] |
|
4710 by(simp add: expand_set_eq vector_less_def vector_less_eq_def Cart_eq) |
|
4711 } |
|
4712 moreover |
|
4713 { fix i |
|
4714 have "x $ i \<le> b $ i" |
|
4715 using x order_less_imp_le[of "x$i" "b$i"] |
|
4716 by(simp add: expand_set_eq vector_less_def vector_less_eq_def Cart_eq) |
|
4717 } |
|
4718 ultimately |
|
4719 show "a \<le> x \<and> x \<le> b" |
|
4720 by(simp add: expand_set_eq vector_less_def vector_less_eq_def Cart_eq) |
|
4721 qed |
|
4722 |
|
4723 lemma subset_interval: fixes a :: "real^'n::finite" shows |
|
4724 "{c .. d} \<subseteq> {a .. b} \<longleftrightarrow> (\<forall>i. c$i \<le> d$i) --> (\<forall>i. a$i \<le> c$i \<and> d$i \<le> b$i)" (is ?th1) and |
|
4725 "{c .. d} \<subseteq> {a<..<b} \<longleftrightarrow> (\<forall>i. c$i \<le> d$i) --> (\<forall>i. a$i < c$i \<and> d$i < b$i)" (is ?th2) and |
|
4726 "{c<..<d} \<subseteq> {a .. b} \<longleftrightarrow> (\<forall>i. c$i < d$i) --> (\<forall>i. a$i \<le> c$i \<and> d$i \<le> b$i)" (is ?th3) and |
|
4727 "{c<..<d} \<subseteq> {a<..<b} \<longleftrightarrow> (\<forall>i. c$i < d$i) --> (\<forall>i. a$i \<le> c$i \<and> d$i \<le> b$i)" (is ?th4) |
|
4728 proof- |
|
4729 show ?th1 unfolding subset_eq and Ball_def and mem_interval by (auto intro: order_trans) |
|
4730 show ?th2 unfolding subset_eq and Ball_def and mem_interval by (auto intro: le_less_trans less_le_trans order_trans less_imp_le) |
|
4731 { assume as: "{c<..<d} \<subseteq> {a .. b}" "\<forall>i. c$i < d$i" |
|
4732 hence "{c<..<d} \<noteq> {}" unfolding interval_eq_empty by (auto, drule_tac x=i in spec, simp) (* BH: Why doesn't just "auto" work? *) |
|
4733 fix i |
|
4734 (** TODO combine the following two parts as done in the HOL_light version. **) |
|
4735 { let ?x = "(\<chi> j. (if j=i then ((min (a$j) (d$j))+c$j)/2 else (c$j+d$j)/2))::real^'n" |
|
4736 assume as2: "a$i > c$i" |
|
4737 { fix j |
|
4738 have "c $ j < ?x $ j \<and> ?x $ j < d $ j" unfolding Cart_lambda_beta |
|
4739 apply(cases "j=i") using as(2)[THEN spec[where x=j]] |
|
4740 by (auto simp add: less_divide_eq_number_of1 as2) } |
|
4741 hence "?x\<in>{c<..<d}" unfolding mem_interval by auto |
|
4742 moreover |
|
4743 have "?x\<notin>{a .. b}" |
|
4744 unfolding mem_interval apply auto apply(rule_tac x=i in exI) |
|
4745 using as(2)[THEN spec[where x=i]] and as2 |
|
4746 by (auto simp add: less_divide_eq_number_of1) |
|
4747 ultimately have False using as by auto } |
|
4748 hence "a$i \<le> c$i" by(rule ccontr)auto |
|
4749 moreover |
|
4750 { let ?x = "(\<chi> j. (if j=i then ((max (b$j) (c$j))+d$j)/2 else (c$j+d$j)/2))::real^'n" |
|
4751 assume as2: "b$i < d$i" |
|
4752 { fix j |
|
4753 have "d $ j > ?x $ j \<and> ?x $ j > c $ j" unfolding Cart_lambda_beta |
|
4754 apply(cases "j=i") using as(2)[THEN spec[where x=j]] |
|
4755 by (auto simp add: less_divide_eq_number_of1 as2) } |
|
4756 hence "?x\<in>{c<..<d}" unfolding mem_interval by auto |
|
4757 moreover |
|
4758 have "?x\<notin>{a .. b}" |
|
4759 unfolding mem_interval apply auto apply(rule_tac x=i in exI) |
|
4760 using as(2)[THEN spec[where x=i]] and as2 |
|
4761 by (auto simp add: less_divide_eq_number_of1) |
|
4762 ultimately have False using as by auto } |
|
4763 hence "b$i \<ge> d$i" by(rule ccontr)auto |
|
4764 ultimately |
|
4765 have "a$i \<le> c$i \<and> d$i \<le> b$i" by auto |
|
4766 } note part1 = this |
|
4767 thus ?th3 unfolding subset_eq and Ball_def and mem_interval apply auto apply (erule_tac x=ia in allE, simp)+ by (erule_tac x=i in allE, erule_tac x=i in allE, simp)+ |
|
4768 { assume as:"{c<..<d} \<subseteq> {a<..<b}" "\<forall>i. c$i < d$i" |
|
4769 fix i |
|
4770 from as(1) have "{c<..<d} \<subseteq> {a..b}" using interval_open_subset_closed[of a b] by auto |
|
4771 hence "a$i \<le> c$i \<and> d$i \<le> b$i" using part1 and as(2) by auto } note * = this |
|
4772 thus ?th4 unfolding subset_eq and Ball_def and mem_interval apply auto apply (erule_tac x=ia in allE, simp)+ by (erule_tac x=i in allE, erule_tac x=i in allE, simp)+ |
|
4773 qed |
|
4774 |
|
4775 lemma disjoint_interval: fixes a::"real^'n::finite" shows |
|
4776 "{a .. b} \<inter> {c .. d} = {} \<longleftrightarrow> (\<exists>i. (b$i < a$i \<or> d$i < c$i \<or> b$i < c$i \<or> d$i < a$i))" (is ?th1) and |
|
4777 "{a .. b} \<inter> {c<..<d} = {} \<longleftrightarrow> (\<exists>i. (b$i < a$i \<or> d$i \<le> c$i \<or> b$i \<le> c$i \<or> d$i \<le> a$i))" (is ?th2) and |
|
4778 "{a<..<b} \<inter> {c .. d} = {} \<longleftrightarrow> (\<exists>i. (b$i \<le> a$i \<or> d$i < c$i \<or> b$i \<le> c$i \<or> d$i \<le> a$i))" (is ?th3) and |
|
4779 "{a<..<b} \<inter> {c<..<d} = {} \<longleftrightarrow> (\<exists>i. (b$i \<le> a$i \<or> d$i \<le> c$i \<or> b$i \<le> c$i \<or> d$i \<le> a$i))" (is ?th4) |
|
4780 proof- |
|
4781 let ?z = "(\<chi> i. ((max (a$i) (c$i)) + (min (b$i) (d$i))) / 2)::real^'n" |
|
4782 show ?th1 ?th2 ?th3 ?th4 |
|
4783 unfolding expand_set_eq and Int_iff and empty_iff and mem_interval and all_conj_distrib[THEN sym] and eq_False |
|
4784 apply (auto elim!: allE[where x="?z"]) |
|
4785 apply ((rule_tac x=x in exI, force) | (rule_tac x=i in exI, force))+ |
|
4786 done |
|
4787 qed |
|
4788 |
|
4789 lemma inter_interval: fixes a :: "'a::linorder^'n::finite" shows |
|
4790 "{a .. b} \<inter> {c .. d} = {(\<chi> i. max (a$i) (c$i)) .. (\<chi> i. min (b$i) (d$i))}" |
|
4791 unfolding expand_set_eq and Int_iff and mem_interval |
|
4792 by (auto simp add: less_divide_eq_number_of1 intro!: bexI) |
|
4793 |
|
4794 (* Moved interval_open_subset_closed a bit upwards *) |
|
4795 |
|
4796 lemma open_interval_lemma: fixes x :: "real" shows |
|
4797 "a < x \<Longrightarrow> x < b ==> (\<exists>d>0. \<forall>x'. abs(x' - x) < d --> a < x' \<and> x' < b)" |
|
4798 by(rule_tac x="min (x - a) (b - x)" in exI, auto) |
|
4799 |
|
4800 lemma open_interval: fixes a :: "real^'n::finite" shows "open {a<..<b}" |
|
4801 proof- |
|
4802 { fix x assume x:"x\<in>{a<..<b}" |
|
4803 { fix i |
|
4804 have "\<exists>d>0. \<forall>x'. abs (x' - (x$i)) < d \<longrightarrow> a$i < x' \<and> x' < b$i" |
|
4805 using x[unfolded mem_interval, THEN spec[where x=i]] |
|
4806 using open_interval_lemma[of "a$i" "x$i" "b$i"] by auto } |
|
4807 |
|
4808 hence "\<forall>i. \<exists>d>0. \<forall>x'. abs (x' - (x$i)) < d \<longrightarrow> a$i < x' \<and> x' < b$i" by auto |
|
4809 then obtain d where d:"\<forall>i. 0 < d i \<and> (\<forall>x'. \<bar>x' - x $ i\<bar> < d i \<longrightarrow> a $ i < x' \<and> x' < b $ i)" |
|
4810 using bchoice[of "UNIV" "\<lambda>i d. d>0 \<and> (\<forall>x'. \<bar>x' - x $ i\<bar> < d \<longrightarrow> a $ i < x' \<and> x' < b $ i)"] by auto |
|
4811 |
|
4812 let ?d = "Min (range d)" |
|
4813 have **:"finite (range d)" "range d \<noteq> {}" by auto |
|
4814 have "?d>0" unfolding Min_gr_iff[OF **] using d by auto |
|
4815 moreover |
|
4816 { fix x' assume as:"dist x' x < ?d" |
|
4817 { fix i |
|
4818 have "\<bar>x'$i - x $ i\<bar> < d i" |
|
4819 using norm_bound_component_lt[OF as[unfolded dist_norm], of i] |
|
4820 unfolding vector_minus_component and Min_gr_iff[OF **] by auto |
|
4821 hence "a $ i < x' $ i" "x' $ i < b $ i" using d[THEN spec[where x=i]] by auto } |
|
4822 hence "a < x' \<and> x' < b" unfolding vector_less_def by auto } |
|
4823 ultimately have "\<exists>e>0. \<forall>x'. dist x' x < e \<longrightarrow> x' \<in> {a<..<b}" by (auto, rule_tac x="?d" in exI, simp) |
|
4824 } |
|
4825 thus ?thesis unfolding open_dist using open_interval_lemma by auto |
|
4826 qed |
|
4827 |
|
4828 lemma closed_interval: fixes a :: "real^'n::finite" shows "closed {a .. b}" |
|
4829 proof- |
|
4830 { fix x i assume as:"\<forall>e>0. \<exists>x'\<in>{a..b}. x' \<noteq> x \<and> dist x' x < e"(* and xab:"a$i > x$i \<or> b$i < x$i"*) |
|
4831 { assume xa:"a$i > x$i" |
|
4832 with as obtain y where y:"y\<in>{a..b}" "y \<noteq> x" "dist y x < a$i - x$i" by(erule_tac x="a$i - x$i" in allE)auto |
|
4833 hence False unfolding mem_interval and dist_norm |
|
4834 using component_le_norm[of "y-x" i, unfolded vector_minus_component] and xa by(auto elim!: allE[where x=i]) |
|
4835 } hence "a$i \<le> x$i" by(rule ccontr)auto |
|
4836 moreover |
|
4837 { assume xb:"b$i < x$i" |
|
4838 with as obtain y where y:"y\<in>{a..b}" "y \<noteq> x" "dist y x < x$i - b$i" by(erule_tac x="x$i - b$i" in allE)auto |
|
4839 hence False unfolding mem_interval and dist_norm |
|
4840 using component_le_norm[of "y-x" i, unfolded vector_minus_component] and xb by(auto elim!: allE[where x=i]) |
|
4841 } hence "x$i \<le> b$i" by(rule ccontr)auto |
|
4842 ultimately |
|
4843 have "a $ i \<le> x $ i \<and> x $ i \<le> b $ i" by auto } |
|
4844 thus ?thesis unfolding closed_limpt islimpt_approachable mem_interval by auto |
|
4845 qed |
|
4846 |
|
4847 lemma interior_closed_interval: fixes a :: "real^'n::finite" shows |
|
4848 "interior {a .. b} = {a<..<b}" (is "?L = ?R") |
|
4849 proof(rule subset_antisym) |
|
4850 show "?R \<subseteq> ?L" using interior_maximal[OF interval_open_subset_closed open_interval] by auto |
|
4851 next |
|
4852 { fix x assume "\<exists>T. open T \<and> x \<in> T \<and> T \<subseteq> {a..b}" |
|
4853 then obtain s where s:"open s" "x \<in> s" "s \<subseteq> {a..b}" by auto |
|
4854 then obtain e where "e>0" and e:"\<forall>x'. dist x' x < e \<longrightarrow> x' \<in> {a..b}" unfolding open_dist and subset_eq by auto |
|
4855 { fix i |
|
4856 have "dist (x - (e / 2) *\<^sub>R basis i) x < e" |
|
4857 "dist (x + (e / 2) *\<^sub>R basis i) x < e" |
|
4858 unfolding dist_norm apply auto |
|
4859 unfolding norm_minus_cancel using norm_basis[of i] and `e>0` by auto |
|
4860 hence "a $ i \<le> (x - (e / 2) *\<^sub>R basis i) $ i" |
|
4861 "(x + (e / 2) *\<^sub>R basis i) $ i \<le> b $ i" |
|
4862 using e[THEN spec[where x="x - (e/2) *\<^sub>R basis i"]] |
|
4863 and e[THEN spec[where x="x + (e/2) *\<^sub>R basis i"]] |
|
4864 unfolding mem_interval by (auto elim!: allE[where x=i]) |
|
4865 hence "a $ i < x $ i" and "x $ i < b $ i" |
|
4866 unfolding vector_minus_component and vector_add_component |
|
4867 unfolding vector_smult_component and basis_component using `e>0` by auto } |
|
4868 hence "x \<in> {a<..<b}" unfolding mem_interval by auto } |
|
4869 thus "?L \<subseteq> ?R" unfolding interior_def and subset_eq by auto |
|
4870 qed |
|
4871 |
|
4872 lemma bounded_closed_interval: fixes a :: "real^'n::finite" shows |
|
4873 "bounded {a .. b}" |
|
4874 proof- |
|
4875 let ?b = "\<Sum>i\<in>UNIV. \<bar>a$i\<bar> + \<bar>b$i\<bar>" |
|
4876 { fix x::"real^'n" assume x:"\<forall>i. a $ i \<le> x $ i \<and> x $ i \<le> b $ i" |
|
4877 { fix i |
|
4878 have "\<bar>x$i\<bar> \<le> \<bar>a$i\<bar> + \<bar>b$i\<bar>" using x[THEN spec[where x=i]] by auto } |
|
4879 hence "(\<Sum>i\<in>UNIV. \<bar>x $ i\<bar>) \<le> ?b" by(rule setsum_mono) |
|
4880 hence "norm x \<le> ?b" using norm_le_l1[of x] by auto } |
|
4881 thus ?thesis unfolding interval and bounded_iff by auto |
|
4882 qed |
|
4883 |
|
4884 lemma bounded_interval: fixes a :: "real^'n::finite" shows |
|
4885 "bounded {a .. b} \<and> bounded {a<..<b}" |
|
4886 using bounded_closed_interval[of a b] |
|
4887 using interval_open_subset_closed[of a b] |
|
4888 using bounded_subset[of "{a..b}" "{a<..<b}"] |
|
4889 by simp |
|
4890 |
|
4891 lemma not_interval_univ: fixes a :: "real^'n::finite" shows |
|
4892 "({a .. b} \<noteq> UNIV) \<and> ({a<..<b} \<noteq> UNIV)" |
|
4893 using bounded_interval[of a b] |
|
4894 by auto |
|
4895 |
|
4896 lemma compact_interval: fixes a :: "real^'n::finite" shows |
|
4897 "compact {a .. b}" |
|
4898 using bounded_closed_imp_compact using bounded_interval[of a b] using closed_interval[of a b] by auto |
|
4899 |
|
4900 lemma open_interval_midpoint: fixes a :: "real^'n::finite" |
|
4901 assumes "{a<..<b} \<noteq> {}" shows "((1/2) *\<^sub>R (a + b)) \<in> {a<..<b}" |
|
4902 proof- |
|
4903 { fix i |
|
4904 have "a $ i < ((1 / 2) *\<^sub>R (a + b)) $ i \<and> ((1 / 2) *\<^sub>R (a + b)) $ i < b $ i" |
|
4905 using assms[unfolded interval_ne_empty, THEN spec[where x=i]] |
|
4906 unfolding vector_smult_component and vector_add_component |
|
4907 by(auto simp add: less_divide_eq_number_of1) } |
|
4908 thus ?thesis unfolding mem_interval by auto |
|
4909 qed |
|
4910 |
|
4911 lemma open_closed_interval_convex: fixes x :: "real^'n::finite" |
|
4912 assumes x:"x \<in> {a<..<b}" and y:"y \<in> {a .. b}" and e:"0 < e" "e \<le> 1" |
|
4913 shows "(e *\<^sub>R x + (1 - e) *\<^sub>R y) \<in> {a<..<b}" |
|
4914 proof- |
|
4915 { fix i |
|
4916 have "a $ i = e * a$i + (1 - e) * a$i" unfolding left_diff_distrib by simp |
|
4917 also have "\<dots> < e * x $ i + (1 - e) * y $ i" apply(rule add_less_le_mono) |
|
4918 using e unfolding mult_less_cancel_left and mult_le_cancel_left apply simp_all |
|
4919 using x unfolding mem_interval apply simp |
|
4920 using y unfolding mem_interval apply simp |
|
4921 done |
|
4922 finally have "a $ i < (e *\<^sub>R x + (1 - e) *\<^sub>R y) $ i" by auto |
|
4923 moreover { |
|
4924 have "b $ i = e * b$i + (1 - e) * b$i" unfolding left_diff_distrib by simp |
|
4925 also have "\<dots> > e * x $ i + (1 - e) * y $ i" apply(rule add_less_le_mono) |
|
4926 using e unfolding mult_less_cancel_left and mult_le_cancel_left apply simp_all |
|
4927 using x unfolding mem_interval apply simp |
|
4928 using y unfolding mem_interval apply simp |
|
4929 done |
|
4930 finally have "(e *\<^sub>R x + (1 - e) *\<^sub>R y) $ i < b $ i" by auto |
|
4931 } ultimately have "a $ i < (e *\<^sub>R x + (1 - e) *\<^sub>R y) $ i \<and> (e *\<^sub>R x + (1 - e) *\<^sub>R y) $ i < b $ i" by auto } |
|
4932 thus ?thesis unfolding mem_interval by auto |
|
4933 qed |
|
4934 |
|
4935 lemma closure_open_interval: fixes a :: "real^'n::finite" |
|
4936 assumes "{a<..<b} \<noteq> {}" |
|
4937 shows "closure {a<..<b} = {a .. b}" |
|
4938 proof- |
|
4939 have ab:"a < b" using assms[unfolded interval_ne_empty] unfolding vector_less_def by auto |
|
4940 let ?c = "(1 / 2) *\<^sub>R (a + b)" |
|
4941 { fix x assume as:"x \<in> {a .. b}" |
|
4942 def f == "\<lambda>n::nat. x + (inverse (real n + 1)) *\<^sub>R (?c - x)" |
|
4943 { fix n assume fn:"f n < b \<longrightarrow> a < f n \<longrightarrow> f n = x" and xc:"x \<noteq> ?c" |
|
4944 have *:"0 < inverse (real n + 1)" "inverse (real n + 1) \<le> 1" unfolding inverse_le_1_iff by auto |
|
4945 have "(inverse (real n + 1)) *\<^sub>R ((1 / 2) *\<^sub>R (a + b)) + (1 - inverse (real n + 1)) *\<^sub>R x = |
|
4946 x + (inverse (real n + 1)) *\<^sub>R (((1 / 2) *\<^sub>R (a + b)) - x)" |
|
4947 by (auto simp add: algebra_simps) |
|
4948 hence "f n < b" and "a < f n" using open_closed_interval_convex[OF open_interval_midpoint[OF assms] as *] unfolding f_def by auto |
|
4949 hence False using fn unfolding f_def using xc by(auto simp add: vector_mul_lcancel vector_ssub_ldistrib) } |
|
4950 moreover |
|
4951 { assume "\<not> (f ---> x) sequentially" |
|
4952 { fix e::real assume "e>0" |
|
4953 hence "\<exists>N::nat. inverse (real (N + 1)) < e" using real_arch_inv[of e] apply (auto simp add: Suc_pred') apply(rule_tac x="n - 1" in exI) by auto |
|
4954 then obtain N::nat where "inverse (real (N + 1)) < e" by auto |
|
4955 hence "\<forall>n\<ge>N. inverse (real n + 1) < e" by (auto, metis Suc_le_mono le_SucE less_imp_inverse_less nat_le_real_less order_less_trans real_of_nat_Suc real_of_nat_Suc_gt_zero) |
|
4956 hence "\<exists>N::nat. \<forall>n\<ge>N. inverse (real n + 1) < e" by auto } |
|
4957 hence "((\<lambda>n. inverse (real n + 1)) ---> 0) sequentially" |
|
4958 unfolding Lim_sequentially by(auto simp add: dist_norm) |
|
4959 hence "(f ---> x) sequentially" unfolding f_def |
|
4960 using Lim_add[OF Lim_const, of "\<lambda>n::nat. (inverse (real n + 1)) *\<^sub>R ((1 / 2) *\<^sub>R (a + b) - x)" 0 sequentially x] |
|
4961 using Lim_vmul[of "\<lambda>n::nat. inverse (real n + 1)" 0 sequentially "((1 / 2) *\<^sub>R (a + b) - x)"] by auto } |
|
4962 ultimately have "x \<in> closure {a<..<b}" |
|
4963 using as and open_interval_midpoint[OF assms] unfolding closure_def unfolding islimpt_sequential by(cases "x=?c")auto } |
|
4964 thus ?thesis using closure_minimal[OF interval_open_subset_closed closed_interval, of a b] by blast |
|
4965 qed |
|
4966 |
|
4967 lemma bounded_subset_open_interval_symmetric: fixes s::"(real^'n::finite) set" |
|
4968 assumes "bounded s" shows "\<exists>a. s \<subseteq> {-a<..<a}" |
|
4969 proof- |
|
4970 obtain b where "b>0" and b:"\<forall>x\<in>s. norm x \<le> b" using assms[unfolded bounded_pos] by auto |
|
4971 def a \<equiv> "(\<chi> i. b+1)::real^'n" |
|
4972 { fix x assume "x\<in>s" |
|
4973 fix i |
|
4974 have "(-a)$i < x$i" and "x$i < a$i" using b[THEN bspec[where x=x], OF `x\<in>s`] and component_le_norm[of x i] |
|
4975 unfolding vector_uminus_component and a_def and Cart_lambda_beta by auto |
|
4976 } |
|
4977 thus ?thesis by(auto intro: exI[where x=a] simp add: vector_less_def) |
|
4978 qed |
|
4979 |
|
4980 lemma bounded_subset_open_interval: |
|
4981 fixes s :: "(real ^ 'n::finite) set" |
|
4982 shows "bounded s ==> (\<exists>a b. s \<subseteq> {a<..<b})" |
|
4983 by (auto dest!: bounded_subset_open_interval_symmetric) |
|
4984 |
|
4985 lemma bounded_subset_closed_interval_symmetric: |
|
4986 fixes s :: "(real ^ 'n::finite) set" |
|
4987 assumes "bounded s" shows "\<exists>a. s \<subseteq> {-a .. a}" |
|
4988 proof- |
|
4989 obtain a where "s \<subseteq> {- a<..<a}" using bounded_subset_open_interval_symmetric[OF assms] by auto |
|
4990 thus ?thesis using interval_open_subset_closed[of "-a" a] by auto |
|
4991 qed |
|
4992 |
|
4993 lemma bounded_subset_closed_interval: |
|
4994 fixes s :: "(real ^ 'n::finite) set" |
|
4995 shows "bounded s ==> (\<exists>a b. s \<subseteq> {a .. b})" |
|
4996 using bounded_subset_closed_interval_symmetric[of s] by auto |
|
4997 |
|
4998 lemma frontier_closed_interval: |
|
4999 fixes a b :: "real ^ _" |
|
5000 shows "frontier {a .. b} = {a .. b} - {a<..<b}" |
|
5001 unfolding frontier_def unfolding interior_closed_interval and closure_closed[OF closed_interval] .. |
|
5002 |
|
5003 lemma frontier_open_interval: |
|
5004 fixes a b :: "real ^ _" |
|
5005 shows "frontier {a<..<b} = (if {a<..<b} = {} then {} else {a .. b} - {a<..<b})" |
|
5006 proof(cases "{a<..<b} = {}") |
|
5007 case True thus ?thesis using frontier_empty by auto |
|
5008 next |
|
5009 case False thus ?thesis unfolding frontier_def and closure_open_interval[OF False] and interior_open[OF open_interval] by auto |
|
5010 qed |
|
5011 |
|
5012 lemma inter_interval_mixed_eq_empty: fixes a :: "real^'n::finite" |
|
5013 assumes "{c<..<d} \<noteq> {}" shows "{a<..<b} \<inter> {c .. d} = {} \<longleftrightarrow> {a<..<b} \<inter> {c<..<d} = {}" |
|
5014 unfolding closure_open_interval[OF assms, THEN sym] unfolding open_inter_closure_eq_empty[OF open_interval] .. |
|
5015 |
|
5016 |
|
5017 (* Some special cases for intervals in R^1. *) |
|
5018 |
|
5019 lemma all_1: "(\<forall>x::1. P x) \<longleftrightarrow> P 1" |
|
5020 by (metis num1_eq_iff) |
|
5021 |
|
5022 lemma ex_1: "(\<exists>x::1. P x) \<longleftrightarrow> P 1" |
|
5023 by auto (metis num1_eq_iff) |
|
5024 |
|
5025 lemma interval_cases_1: fixes x :: "real^1" shows |
|
5026 "x \<in> {a .. b} ==> x \<in> {a<..<b} \<or> (x = a) \<or> (x = b)" |
|
5027 by(simp add: Cart_eq vector_less_def vector_less_eq_def all_1, auto) |
|
5028 |
|
5029 lemma in_interval_1: fixes x :: "real^1" shows |
|
5030 "(x \<in> {a .. b} \<longleftrightarrow> dest_vec1 a \<le> dest_vec1 x \<and> dest_vec1 x \<le> dest_vec1 b) \<and> |
|
5031 (x \<in> {a<..<b} \<longleftrightarrow> dest_vec1 a < dest_vec1 x \<and> dest_vec1 x < dest_vec1 b)" |
|
5032 by(simp add: Cart_eq vector_less_def vector_less_eq_def all_1 dest_vec1_def) |
|
5033 |
|
5034 lemma interval_eq_empty_1: fixes a :: "real^1" shows |
|
5035 "{a .. b} = {} \<longleftrightarrow> dest_vec1 b < dest_vec1 a" |
|
5036 "{a<..<b} = {} \<longleftrightarrow> dest_vec1 b \<le> dest_vec1 a" |
|
5037 unfolding interval_eq_empty and ex_1 and dest_vec1_def by auto |
|
5038 |
|
5039 lemma subset_interval_1: fixes a :: "real^1" shows |
|
5040 "({a .. b} \<subseteq> {c .. d} \<longleftrightarrow> dest_vec1 b < dest_vec1 a \<or> |
|
5041 dest_vec1 c \<le> dest_vec1 a \<and> dest_vec1 a \<le> dest_vec1 b \<and> dest_vec1 b \<le> dest_vec1 d)" |
|
5042 "({a .. b} \<subseteq> {c<..<d} \<longleftrightarrow> dest_vec1 b < dest_vec1 a \<or> |
|
5043 dest_vec1 c < dest_vec1 a \<and> dest_vec1 a \<le> dest_vec1 b \<and> dest_vec1 b < dest_vec1 d)" |
|
5044 "({a<..<b} \<subseteq> {c .. d} \<longleftrightarrow> dest_vec1 b \<le> dest_vec1 a \<or> |
|
5045 dest_vec1 c \<le> dest_vec1 a \<and> dest_vec1 a < dest_vec1 b \<and> dest_vec1 b \<le> dest_vec1 d)" |
|
5046 "({a<..<b} \<subseteq> {c<..<d} \<longleftrightarrow> dest_vec1 b \<le> dest_vec1 a \<or> |
|
5047 dest_vec1 c \<le> dest_vec1 a \<and> dest_vec1 a < dest_vec1 b \<and> dest_vec1 b \<le> dest_vec1 d)" |
|
5048 unfolding subset_interval[of a b c d] unfolding all_1 and dest_vec1_def by auto |
|
5049 |
|
5050 lemma eq_interval_1: fixes a :: "real^1" shows |
|
5051 "{a .. b} = {c .. d} \<longleftrightarrow> |
|
5052 dest_vec1 b < dest_vec1 a \<and> dest_vec1 d < dest_vec1 c \<or> |
|
5053 dest_vec1 a = dest_vec1 c \<and> dest_vec1 b = dest_vec1 d" |
|
5054 using set_eq_subset[of "{a .. b}" "{c .. d}"] |
|
5055 using subset_interval_1(1)[of a b c d] |
|
5056 using subset_interval_1(1)[of c d a b] |
|
5057 by auto (* FIXME: slow *) |
|
5058 |
|
5059 lemma disjoint_interval_1: fixes a :: "real^1" shows |
|
5060 "{a .. b} \<inter> {c .. d} = {} \<longleftrightarrow> dest_vec1 b < dest_vec1 a \<or> dest_vec1 d < dest_vec1 c \<or> dest_vec1 b < dest_vec1 c \<or> dest_vec1 d < dest_vec1 a" |
|
5061 "{a .. b} \<inter> {c<..<d} = {} \<longleftrightarrow> dest_vec1 b < dest_vec1 a \<or> dest_vec1 d \<le> dest_vec1 c \<or> dest_vec1 b \<le> dest_vec1 c \<or> dest_vec1 d \<le> dest_vec1 a" |
|
5062 "{a<..<b} \<inter> {c .. d} = {} \<longleftrightarrow> dest_vec1 b \<le> dest_vec1 a \<or> dest_vec1 d < dest_vec1 c \<or> dest_vec1 b \<le> dest_vec1 c \<or> dest_vec1 d \<le> dest_vec1 a" |
|
5063 "{a<..<b} \<inter> {c<..<d} = {} \<longleftrightarrow> dest_vec1 b \<le> dest_vec1 a \<or> dest_vec1 d \<le> dest_vec1 c \<or> dest_vec1 b \<le> dest_vec1 c \<or> dest_vec1 d \<le> dest_vec1 a" |
|
5064 unfolding disjoint_interval and dest_vec1_def ex_1 by auto |
|
5065 |
|
5066 lemma open_closed_interval_1: fixes a :: "real^1" shows |
|
5067 "{a<..<b} = {a .. b} - {a, b}" |
|
5068 unfolding expand_set_eq apply simp unfolding vector_less_def and vector_less_eq_def and all_1 and dest_vec1_eq[THEN sym] and dest_vec1_def by auto |
|
5069 |
|
5070 lemma closed_open_interval_1: "dest_vec1 (a::real^1) \<le> dest_vec1 b ==> {a .. b} = {a<..<b} \<union> {a,b}" |
|
5071 unfolding expand_set_eq apply simp unfolding vector_less_def and vector_less_eq_def and all_1 and dest_vec1_eq[THEN sym] and dest_vec1_def by auto |
|
5072 |
|
5073 (* Some stuff for half-infinite intervals too; FIXME: notation? *) |
|
5074 |
|
5075 lemma closed_interval_left: fixes b::"real^'n::finite" |
|
5076 shows "closed {x::real^'n. \<forall>i. x$i \<le> b$i}" |
|
5077 proof- |
|
5078 { fix i |
|
5079 fix x::"real^'n" assume x:"\<forall>e>0. \<exists>x'\<in>{x. \<forall>i. x $ i \<le> b $ i}. x' \<noteq> x \<and> dist x' x < e" |
|
5080 { assume "x$i > b$i" |
|
5081 then obtain y where "y $ i \<le> b $ i" "y \<noteq> x" "dist y x < x$i - b$i" using x[THEN spec[where x="x$i - b$i"]] by auto |
|
5082 hence False using component_le_norm[of "y - x" i] unfolding dist_norm and vector_minus_component by auto } |
|
5083 hence "x$i \<le> b$i" by(rule ccontr)auto } |
|
5084 thus ?thesis unfolding closed_limpt unfolding islimpt_approachable by blast |
|
5085 qed |
|
5086 |
|
5087 lemma closed_interval_right: fixes a::"real^'n::finite" |
|
5088 shows "closed {x::real^'n. \<forall>i. a$i \<le> x$i}" |
|
5089 proof- |
|
5090 { fix i |
|
5091 fix x::"real^'n" assume x:"\<forall>e>0. \<exists>x'\<in>{x. \<forall>i. a $ i \<le> x $ i}. x' \<noteq> x \<and> dist x' x < e" |
|
5092 { assume "a$i > x$i" |
|
5093 then obtain y where "a $ i \<le> y $ i" "y \<noteq> x" "dist y x < a$i - x$i" using x[THEN spec[where x="a$i - x$i"]] by auto |
|
5094 hence False using component_le_norm[of "y - x" i] unfolding dist_norm and vector_minus_component by auto } |
|
5095 hence "a$i \<le> x$i" by(rule ccontr)auto } |
|
5096 thus ?thesis unfolding closed_limpt unfolding islimpt_approachable by blast |
|
5097 qed |
|
5098 |
|
5099 subsection{* Intervals in general, including infinite and mixtures of open and closed. *} |
|
5100 |
|
5101 definition "is_interval s \<longleftrightarrow> (\<forall>a\<in>s. \<forall>b\<in>s. \<forall>x. (\<forall>i. ((a$i \<le> x$i \<and> x$i \<le> b$i) \<or> (b$i \<le> x$i \<and> x$i \<le> a$i))) \<longrightarrow> x \<in> s)" |
|
5102 |
|
5103 lemma is_interval_interval: "is_interval {a .. b::real^'n::finite}" (is ?th1) "is_interval {a<..<b}" (is ?th2) proof - |
|
5104 have *:"\<And>x y z::real. x < y \<Longrightarrow> y < z \<Longrightarrow> x < z" by auto |
|
5105 show ?th1 ?th2 unfolding is_interval_def mem_interval Ball_def atLeastAtMost_iff |
|
5106 by(meson real_le_trans le_less_trans less_le_trans *)+ qed |
|
5107 |
|
5108 lemma is_interval_empty: |
|
5109 "is_interval {}" |
|
5110 unfolding is_interval_def |
|
5111 by simp |
|
5112 |
|
5113 lemma is_interval_univ: |
|
5114 "is_interval UNIV" |
|
5115 unfolding is_interval_def |
|
5116 by simp |
|
5117 |
|
5118 subsection{* Closure of halfspaces and hyperplanes. *} |
|
5119 |
|
5120 lemma Lim_inner: |
|
5121 assumes "(f ---> l) net" shows "((\<lambda>y. inner a (f y)) ---> inner a l) net" |
|
5122 by (intro tendsto_intros assms) |
|
5123 |
|
5124 lemma continuous_at_inner: "continuous (at x) (inner a)" |
|
5125 unfolding continuous_at by (intro tendsto_intros) |
|
5126 |
|
5127 lemma continuous_on_inner: |
|
5128 fixes s :: "'a::real_inner set" |
|
5129 shows "continuous_on s (inner a)" |
|
5130 unfolding continuous_on by (rule ballI) (intro tendsto_intros) |
|
5131 |
|
5132 lemma closed_halfspace_le: "closed {x. inner a x \<le> b}" |
|
5133 proof- |
|
5134 have "\<forall>x. continuous (at x) (inner a)" |
|
5135 unfolding continuous_at by (rule allI) (intro tendsto_intros) |
|
5136 hence "closed (inner a -` {..b})" |
|
5137 using closed_real_atMost by (rule continuous_closed_vimage) |
|
5138 moreover have "{x. inner a x \<le> b} = inner a -` {..b}" by auto |
|
5139 ultimately show ?thesis by simp |
|
5140 qed |
|
5141 |
|
5142 lemma closed_halfspace_ge: "closed {x. inner a x \<ge> b}" |
|
5143 using closed_halfspace_le[of "-a" "-b"] unfolding inner_minus_left by auto |
|
5144 |
|
5145 lemma closed_hyperplane: "closed {x. inner a x = b}" |
|
5146 proof- |
|
5147 have "{x. inner a x = b} = {x. inner a x \<ge> b} \<inter> {x. inner a x \<le> b}" by auto |
|
5148 thus ?thesis using closed_halfspace_le[of a b] and closed_halfspace_ge[of b a] using closed_Int by auto |
|
5149 qed |
|
5150 |
|
5151 lemma closed_halfspace_component_le: |
|
5152 shows "closed {x::real^'n::finite. x$i \<le> a}" |
|
5153 using closed_halfspace_le[of "(basis i)::real^'n" a] unfolding inner_basis[OF assms] by auto |
|
5154 |
|
5155 lemma closed_halfspace_component_ge: |
|
5156 shows "closed {x::real^'n::finite. x$i \<ge> a}" |
|
5157 using closed_halfspace_ge[of a "(basis i)::real^'n"] unfolding inner_basis[OF assms] by auto |
|
5158 |
|
5159 text{* Openness of halfspaces. *} |
|
5160 |
|
5161 lemma open_halfspace_lt: "open {x. inner a x < b}" |
|
5162 proof- |
|
5163 have "UNIV - {x. b \<le> inner a x} = {x. inner a x < b}" by auto |
|
5164 thus ?thesis using closed_halfspace_ge[unfolded closed_def Compl_eq_Diff_UNIV, of b a] by auto |
|
5165 qed |
|
5166 |
|
5167 lemma open_halfspace_gt: "open {x. inner a x > b}" |
|
5168 proof- |
|
5169 have "UNIV - {x. b \<ge> inner a x} = {x. inner a x > b}" by auto |
|
5170 thus ?thesis using closed_halfspace_le[unfolded closed_def Compl_eq_Diff_UNIV, of a b] by auto |
|
5171 qed |
|
5172 |
|
5173 lemma open_halfspace_component_lt: |
|
5174 shows "open {x::real^'n::finite. x$i < a}" |
|
5175 using open_halfspace_lt[of "(basis i)::real^'n" a] unfolding inner_basis[OF assms] by auto |
|
5176 |
|
5177 lemma open_halfspace_component_gt: |
|
5178 shows "open {x::real^'n::finite. x$i > a}" |
|
5179 using open_halfspace_gt[of a "(basis i)::real^'n"] unfolding inner_basis[OF assms] by auto |
|
5180 |
|
5181 text{* This gives a simple derivation of limit component bounds. *} |
|
5182 |
|
5183 lemma Lim_component_le: fixes f :: "'a \<Rightarrow> real^'n::finite" |
|
5184 assumes "(f ---> l) net" "\<not> (trivial_limit net)" "eventually (\<lambda>x. f(x)$i \<le> b) net" |
|
5185 shows "l$i \<le> b" |
|
5186 proof- |
|
5187 { fix x have "x \<in> {x::real^'n. inner (basis i) x \<le> b} \<longleftrightarrow> x$i \<le> b" unfolding inner_basis by auto } note * = this |
|
5188 show ?thesis using Lim_in_closed_set[of "{x. inner (basis i) x \<le> b}" f net l] unfolding * |
|
5189 using closed_halfspace_le[of "(basis i)::real^'n" b] and assms(1,2,3) by auto |
|
5190 qed |
|
5191 |
|
5192 lemma Lim_component_ge: fixes f :: "'a \<Rightarrow> real^'n::finite" |
|
5193 assumes "(f ---> l) net" "\<not> (trivial_limit net)" "eventually (\<lambda>x. b \<le> (f x)$i) net" |
|
5194 shows "b \<le> l$i" |
|
5195 proof- |
|
5196 { fix x have "x \<in> {x::real^'n. inner (basis i) x \<ge> b} \<longleftrightarrow> x$i \<ge> b" unfolding inner_basis by auto } note * = this |
|
5197 show ?thesis using Lim_in_closed_set[of "{x. inner (basis i) x \<ge> b}" f net l] unfolding * |
|
5198 using closed_halfspace_ge[of b "(basis i)::real^'n"] and assms(1,2,3) by auto |
|
5199 qed |
|
5200 |
|
5201 lemma Lim_component_eq: fixes f :: "'a \<Rightarrow> real^'n::finite" |
|
5202 assumes net:"(f ---> l) net" "~(trivial_limit net)" and ev:"eventually (\<lambda>x. f(x)$i = b) net" |
|
5203 shows "l$i = b" |
|
5204 using ev[unfolded order_eq_iff eventually_and] using Lim_component_ge[OF net, of b i] and Lim_component_le[OF net, of i b] by auto |
|
5205 |
|
5206 lemma Lim_drop_le: fixes f :: "'a \<Rightarrow> real^1" shows |
|
5207 "(f ---> l) net \<Longrightarrow> ~(trivial_limit net) \<Longrightarrow> eventually (\<lambda>x. dest_vec1 (f x) \<le> b) net ==> dest_vec1 l \<le> b" |
|
5208 using Lim_component_le[of f l net 1 b] unfolding dest_vec1_def by auto |
|
5209 |
|
5210 lemma Lim_drop_ge: fixes f :: "'a \<Rightarrow> real^1" shows |
|
5211 "(f ---> l) net \<Longrightarrow> ~(trivial_limit net) \<Longrightarrow> eventually (\<lambda>x. b \<le> dest_vec1 (f x)) net ==> b \<le> dest_vec1 l" |
|
5212 using Lim_component_ge[of f l net b 1] unfolding dest_vec1_def by auto |
|
5213 |
|
5214 text{* Limits relative to a union. *} |
|
5215 |
|
5216 lemma eventually_within_Un: |
|
5217 "eventually P (net within (s \<union> t)) \<longleftrightarrow> |
|
5218 eventually P (net within s) \<and> eventually P (net within t)" |
|
5219 unfolding Limits.eventually_within |
|
5220 by (auto elim!: eventually_rev_mp) |
|
5221 |
|
5222 lemma Lim_within_union: |
|
5223 "(f ---> l) (net within (s \<union> t)) \<longleftrightarrow> |
|
5224 (f ---> l) (net within s) \<and> (f ---> l) (net within t)" |
|
5225 unfolding tendsto_def |
|
5226 by (auto simp add: eventually_within_Un) |
|
5227 |
|
5228 lemma continuous_on_union: |
|
5229 assumes "closed s" "closed t" "continuous_on s f" "continuous_on t f" |
|
5230 shows "continuous_on (s \<union> t) f" |
|
5231 using assms unfolding continuous_on unfolding Lim_within_union |
|
5232 unfolding Lim unfolding trivial_limit_within unfolding closed_limpt by auto |
|
5233 |
|
5234 lemma continuous_on_cases: |
|
5235 assumes "closed s" "closed t" "continuous_on s f" "continuous_on t g" |
|
5236 "\<forall>x. (x\<in>s \<and> \<not> P x) \<or> (x \<in> t \<and> P x) \<longrightarrow> f x = g x" |
|
5237 shows "continuous_on (s \<union> t) (\<lambda>x. if P x then f x else g x)" |
|
5238 proof- |
|
5239 let ?h = "(\<lambda>x. if P x then f x else g x)" |
|
5240 have "\<forall>x\<in>s. f x = (if P x then f x else g x)" using assms(5) by auto |
|
5241 hence "continuous_on s ?h" using continuous_on_eq[of s f ?h] using assms(3) by auto |
|
5242 moreover |
|
5243 have "\<forall>x\<in>t. g x = (if P x then f x else g x)" using assms(5) by auto |
|
5244 hence "continuous_on t ?h" using continuous_on_eq[of t g ?h] using assms(4) by auto |
|
5245 ultimately show ?thesis using continuous_on_union[OF assms(1,2), of ?h] by auto |
|
5246 qed |
|
5247 |
|
5248 |
|
5249 text{* Some more convenient intermediate-value theorem formulations. *} |
|
5250 |
|
5251 lemma connected_ivt_hyperplane: |
|
5252 assumes "connected s" "x \<in> s" "y \<in> s" "inner a x \<le> b" "b \<le> inner a y" |
|
5253 shows "\<exists>z \<in> s. inner a z = b" |
|
5254 proof(rule ccontr) |
|
5255 assume as:"\<not> (\<exists>z\<in>s. inner a z = b)" |
|
5256 let ?A = "{x. inner a x < b}" |
|
5257 let ?B = "{x. inner a x > b}" |
|
5258 have "open ?A" "open ?B" using open_halfspace_lt and open_halfspace_gt by auto |
|
5259 moreover have "?A \<inter> ?B = {}" by auto |
|
5260 moreover have "s \<subseteq> ?A \<union> ?B" using as by auto |
|
5261 ultimately show False using assms(1)[unfolded connected_def not_ex, THEN spec[where x="?A"], THEN spec[where x="?B"]] and assms(2-5) by auto |
|
5262 qed |
|
5263 |
|
5264 lemma connected_ivt_component: fixes x::"real^'n::finite" shows |
|
5265 "connected s \<Longrightarrow> x \<in> s \<Longrightarrow> y \<in> s \<Longrightarrow> x$k \<le> a \<Longrightarrow> a \<le> y$k \<Longrightarrow> (\<exists>z\<in>s. z$k = a)" |
|
5266 using connected_ivt_hyperplane[of s x y "(basis k)::real^'n" a] by (auto simp add: inner_basis) |
|
5267 |
|
5268 text{* Also more convenient formulations of monotone convergence. *} |
|
5269 |
|
5270 lemma bounded_increasing_convergent: fixes s::"nat \<Rightarrow> real^1" |
|
5271 assumes "bounded {s n| n::nat. True}" "\<forall>n. dest_vec1(s n) \<le> dest_vec1(s(Suc n))" |
|
5272 shows "\<exists>l. (s ---> l) sequentially" |
|
5273 proof- |
|
5274 obtain a where a:"\<forall>n. \<bar>dest_vec1 (s n)\<bar> \<le> a" using assms(1)[unfolded bounded_iff abs_dest_vec1] by auto |
|
5275 { fix m::nat |
|
5276 have "\<And> n. n\<ge>m \<longrightarrow> dest_vec1 (s m) \<le> dest_vec1 (s n)" |
|
5277 apply(induct_tac n) apply simp using assms(2) apply(erule_tac x="na" in allE) by(auto simp add: not_less_eq_eq) } |
|
5278 hence "\<forall>m n. m \<le> n \<longrightarrow> dest_vec1 (s m) \<le> dest_vec1 (s n)" by auto |
|
5279 then obtain l where "\<forall>e>0. \<exists>N. \<forall>n\<ge>N. \<bar>dest_vec1 (s n) - l\<bar> < e" using convergent_bounded_monotone[OF a] unfolding monoseq_def by auto |
|
5280 thus ?thesis unfolding Lim_sequentially apply(rule_tac x="vec1 l" in exI) |
|
5281 unfolding dist_norm unfolding abs_dest_vec1 and dest_vec1_sub by auto |
|
5282 qed |
|
5283 |
|
5284 subsection{* Basic homeomorphism definitions. *} |
|
5285 |
|
5286 definition "homeomorphism s t f g \<equiv> |
|
5287 (\<forall>x\<in>s. (g(f x) = x)) \<and> (f ` s = t) \<and> continuous_on s f \<and> |
|
5288 (\<forall>y\<in>t. (f(g y) = y)) \<and> (g ` t = s) \<and> continuous_on t g" |
|
5289 |
|
5290 definition |
|
5291 homeomorphic :: "'a::metric_space set \<Rightarrow> 'b::metric_space set \<Rightarrow> bool" |
|
5292 (infixr "homeomorphic" 60) where |
|
5293 homeomorphic_def: "s homeomorphic t \<equiv> (\<exists>f g. homeomorphism s t f g)" |
|
5294 |
|
5295 lemma homeomorphic_refl: "s homeomorphic s" |
|
5296 unfolding homeomorphic_def |
|
5297 unfolding homeomorphism_def |
|
5298 using continuous_on_id |
|
5299 apply(rule_tac x = "(\<lambda>x. x)" in exI) |
|
5300 apply(rule_tac x = "(\<lambda>x. x)" in exI) |
|
5301 by blast |
|
5302 |
|
5303 lemma homeomorphic_sym: |
|
5304 "s homeomorphic t \<longleftrightarrow> t homeomorphic s" |
|
5305 unfolding homeomorphic_def |
|
5306 unfolding homeomorphism_def |
|
5307 by blast (* FIXME: slow *) |
|
5308 |
|
5309 lemma homeomorphic_trans: |
|
5310 assumes "s homeomorphic t" "t homeomorphic u" shows "s homeomorphic u" |
|
5311 proof- |
|
5312 obtain f1 g1 where fg1:"\<forall>x\<in>s. g1 (f1 x) = x" "f1 ` s = t" "continuous_on s f1" "\<forall>y\<in>t. f1 (g1 y) = y" "g1 ` t = s" "continuous_on t g1" |
|
5313 using assms(1) unfolding homeomorphic_def homeomorphism_def by auto |
|
5314 obtain f2 g2 where fg2:"\<forall>x\<in>t. g2 (f2 x) = x" "f2 ` t = u" "continuous_on t f2" "\<forall>y\<in>u. f2 (g2 y) = y" "g2 ` u = t" "continuous_on u g2" |
|
5315 using assms(2) unfolding homeomorphic_def homeomorphism_def by auto |
|
5316 |
|
5317 { fix x assume "x\<in>s" hence "(g1 \<circ> g2) ((f2 \<circ> f1) x) = x" using fg1(1)[THEN bspec[where x=x]] and fg2(1)[THEN bspec[where x="f1 x"]] and fg1(2) by auto } |
|
5318 moreover have "(f2 \<circ> f1) ` s = u" using fg1(2) fg2(2) by auto |
|
5319 moreover have "continuous_on s (f2 \<circ> f1)" using continuous_on_compose[OF fg1(3)] and fg2(3) unfolding fg1(2) by auto |
|
5320 moreover { fix y assume "y\<in>u" hence "(f2 \<circ> f1) ((g1 \<circ> g2) y) = y" using fg2(4)[THEN bspec[where x=y]] and fg1(4)[THEN bspec[where x="g2 y"]] and fg2(5) by auto } |
|
5321 moreover have "(g1 \<circ> g2) ` u = s" using fg1(5) fg2(5) by auto |
|
5322 moreover have "continuous_on u (g1 \<circ> g2)" using continuous_on_compose[OF fg2(6)] and fg1(6) unfolding fg2(5) by auto |
|
5323 ultimately show ?thesis unfolding homeomorphic_def homeomorphism_def apply(rule_tac x="f2 \<circ> f1" in exI) apply(rule_tac x="g1 \<circ> g2" in exI) by auto |
|
5324 qed |
|
5325 |
|
5326 lemma homeomorphic_minimal: |
|
5327 "s homeomorphic t \<longleftrightarrow> |
|
5328 (\<exists>f g. (\<forall>x\<in>s. f(x) \<in> t \<and> (g(f(x)) = x)) \<and> |
|
5329 (\<forall>y\<in>t. g(y) \<in> s \<and> (f(g(y)) = y)) \<and> |
|
5330 continuous_on s f \<and> continuous_on t g)" |
|
5331 unfolding homeomorphic_def homeomorphism_def |
|
5332 apply auto apply (rule_tac x=f in exI) apply (rule_tac x=g in exI) |
|
5333 apply auto apply (rule_tac x=f in exI) apply (rule_tac x=g in exI) apply auto |
|
5334 unfolding image_iff |
|
5335 apply(erule_tac x="g x" in ballE) apply(erule_tac x="x" in ballE) |
|
5336 apply auto apply(rule_tac x="g x" in bexI) apply auto |
|
5337 apply(erule_tac x="f x" in ballE) apply(erule_tac x="x" in ballE) |
|
5338 apply auto apply(rule_tac x="f x" in bexI) by auto |
|
5339 |
|
5340 subsection{* Relatively weak hypotheses if a set is compact. *} |
|
5341 |
|
5342 definition "inv_on f s = (\<lambda>x. SOME y. y\<in>s \<and> f y = x)" |
|
5343 |
|
5344 lemma assumes "inj_on f s" "x\<in>s" |
|
5345 shows "inv_on f s (f x) = x" |
|
5346 using assms unfolding inj_on_def inv_on_def by auto |
|
5347 |
|
5348 lemma homeomorphism_compact: |
|
5349 fixes f :: "'a::heine_borel \<Rightarrow> 'b::heine_borel" |
|
5350 (* class constraint due to continuous_on_inverse *) |
|
5351 assumes "compact s" "continuous_on s f" "f ` s = t" "inj_on f s" |
|
5352 shows "\<exists>g. homeomorphism s t f g" |
|
5353 proof- |
|
5354 def g \<equiv> "\<lambda>x. SOME y. y\<in>s \<and> f y = x" |
|
5355 have g:"\<forall>x\<in>s. g (f x) = x" using assms(3) assms(4)[unfolded inj_on_def] unfolding g_def by auto |
|
5356 { fix y assume "y\<in>t" |
|
5357 then obtain x where x:"f x = y" "x\<in>s" using assms(3) by auto |
|
5358 hence "g (f x) = x" using g by auto |
|
5359 hence "f (g y) = y" unfolding x(1)[THEN sym] by auto } |
|
5360 hence g':"\<forall>x\<in>t. f (g x) = x" by auto |
|
5361 moreover |
|
5362 { fix x |
|
5363 have "x\<in>s \<Longrightarrow> x \<in> g ` t" using g[THEN bspec[where x=x]] unfolding image_iff using assms(3) by(auto intro!: bexI[where x="f x"]) |
|
5364 moreover |
|
5365 { assume "x\<in>g ` t" |
|
5366 then obtain y where y:"y\<in>t" "g y = x" by auto |
|
5367 then obtain x' where x':"x'\<in>s" "f x' = y" using assms(3) by auto |
|
5368 hence "x \<in> s" unfolding g_def using someI2[of "\<lambda>b. b\<in>s \<and> f b = y" x' "\<lambda>x. x\<in>s"] unfolding y(2)[THEN sym] and g_def by auto } |
|
5369 ultimately have "x\<in>s \<longleftrightarrow> x \<in> g ` t" by auto } |
|
5370 hence "g ` t = s" by auto |
|
5371 ultimately |
|
5372 show ?thesis unfolding homeomorphism_def homeomorphic_def |
|
5373 apply(rule_tac x=g in exI) using g and assms(3) and continuous_on_inverse[OF assms(2,1), of g, unfolded assms(3)] and assms(2) by auto |
|
5374 qed |
|
5375 |
|
5376 lemma homeomorphic_compact: |
|
5377 fixes f :: "'a::heine_borel \<Rightarrow> 'b::heine_borel" |
|
5378 (* class constraint due to continuous_on_inverse *) |
|
5379 shows "compact s \<Longrightarrow> continuous_on s f \<Longrightarrow> (f ` s = t) \<Longrightarrow> inj_on f s |
|
5380 \<Longrightarrow> s homeomorphic t" |
|
5381 unfolding homeomorphic_def by(metis homeomorphism_compact) |
|
5382 |
|
5383 text{* Preservation of topological properties. *} |
|
5384 |
|
5385 lemma homeomorphic_compactness: |
|
5386 "s homeomorphic t ==> (compact s \<longleftrightarrow> compact t)" |
|
5387 unfolding homeomorphic_def homeomorphism_def |
|
5388 by (metis compact_continuous_image) |
|
5389 |
|
5390 text{* Results on translation, scaling etc. *} |
|
5391 |
|
5392 lemma homeomorphic_scaling: |
|
5393 fixes s :: "'a::real_normed_vector set" |
|
5394 assumes "c \<noteq> 0" shows "s homeomorphic ((\<lambda>x. c *\<^sub>R x) ` s)" |
|
5395 unfolding homeomorphic_minimal |
|
5396 apply(rule_tac x="\<lambda>x. c *\<^sub>R x" in exI) |
|
5397 apply(rule_tac x="\<lambda>x. (1 / c) *\<^sub>R x" in exI) |
|
5398 using assms apply auto |
|
5399 using continuous_on_cmul[OF continuous_on_id] by auto |
|
5400 |
|
5401 lemma homeomorphic_translation: |
|
5402 fixes s :: "'a::real_normed_vector set" |
|
5403 shows "s homeomorphic ((\<lambda>x. a + x) ` s)" |
|
5404 unfolding homeomorphic_minimal |
|
5405 apply(rule_tac x="\<lambda>x. a + x" in exI) |
|
5406 apply(rule_tac x="\<lambda>x. -a + x" in exI) |
|
5407 using continuous_on_add[OF continuous_on_const continuous_on_id] by auto |
|
5408 |
|
5409 lemma homeomorphic_affinity: |
|
5410 fixes s :: "'a::real_normed_vector set" |
|
5411 assumes "c \<noteq> 0" shows "s homeomorphic ((\<lambda>x. a + c *\<^sub>R x) ` s)" |
|
5412 proof- |
|
5413 have *:"op + a ` op *\<^sub>R c ` s = (\<lambda>x. a + c *\<^sub>R x) ` s" by auto |
|
5414 show ?thesis |
|
5415 using homeomorphic_trans |
|
5416 using homeomorphic_scaling[OF assms, of s] |
|
5417 using homeomorphic_translation[of "(\<lambda>x. c *\<^sub>R x) ` s" a] unfolding * by auto |
|
5418 qed |
|
5419 |
|
5420 lemma homeomorphic_balls: |
|
5421 fixes a b ::"'a::real_normed_vector" (* FIXME: generalize to metric_space *) |
|
5422 assumes "0 < d" "0 < e" |
|
5423 shows "(ball a d) homeomorphic (ball b e)" (is ?th) |
|
5424 "(cball a d) homeomorphic (cball b e)" (is ?cth) |
|
5425 proof- |
|
5426 have *:"\<bar>e / d\<bar> > 0" "\<bar>d / e\<bar> >0" using assms using divide_pos_pos by auto |
|
5427 show ?th unfolding homeomorphic_minimal |
|
5428 apply(rule_tac x="\<lambda>x. b + (e/d) *\<^sub>R (x - a)" in exI) |
|
5429 apply(rule_tac x="\<lambda>x. a + (d/e) *\<^sub>R (x - b)" in exI) |
|
5430 using assms apply (auto simp add: dist_commute) |
|
5431 unfolding dist_norm |
|
5432 apply (auto simp add: pos_divide_less_eq mult_strict_left_mono) |
|
5433 unfolding continuous_on |
|
5434 by (intro ballI tendsto_intros, simp, assumption)+ |
|
5435 next |
|
5436 have *:"\<bar>e / d\<bar> > 0" "\<bar>d / e\<bar> >0" using assms using divide_pos_pos by auto |
|
5437 show ?cth unfolding homeomorphic_minimal |
|
5438 apply(rule_tac x="\<lambda>x. b + (e/d) *\<^sub>R (x - a)" in exI) |
|
5439 apply(rule_tac x="\<lambda>x. a + (d/e) *\<^sub>R (x - b)" in exI) |
|
5440 using assms apply (auto simp add: dist_commute) |
|
5441 unfolding dist_norm |
|
5442 apply (auto simp add: pos_divide_le_eq) |
|
5443 unfolding continuous_on |
|
5444 by (intro ballI tendsto_intros, simp, assumption)+ |
|
5445 qed |
|
5446 |
|
5447 text{* "Isometry" (up to constant bounds) of injective linear map etc. *} |
|
5448 |
|
5449 lemma cauchy_isometric: |
|
5450 fixes x :: "nat \<Rightarrow> real ^ 'n::finite" |
|
5451 assumes e:"0 < e" and s:"subspace s" and f:"bounded_linear f" and normf:"\<forall>x\<in>s. norm(f x) \<ge> e * norm(x)" and xs:"\<forall>n::nat. x n \<in> s" and cf:"Cauchy(f o x)" |
|
5452 shows "Cauchy x" |
|
5453 proof- |
|
5454 interpret f: bounded_linear f by fact |
|
5455 { fix d::real assume "d>0" |
|
5456 then obtain N where N:"\<forall>n\<ge>N. norm (f (x n) - f (x N)) < e * d" |
|
5457 using cf[unfolded cauchy o_def dist_norm, THEN spec[where x="e*d"]] and e and mult_pos_pos[of e d] by auto |
|
5458 { fix n assume "n\<ge>N" |
|
5459 hence "norm (f (x n - x N)) < e * d" using N[THEN spec[where x=n]] unfolding f.diff[THEN sym] by auto |
|
5460 moreover have "e * norm (x n - x N) \<le> norm (f (x n - x N))" |
|
5461 using subspace_sub[OF s, of "x n" "x N"] using xs[THEN spec[where x=N]] and xs[THEN spec[where x=n]] |
|
5462 using normf[THEN bspec[where x="x n - x N"]] by auto |
|
5463 ultimately have "norm (x n - x N) < d" using `e>0` |
|
5464 using mult_left_less_imp_less[of e "norm (x n - x N)" d] by auto } |
|
5465 hence "\<exists>N. \<forall>n\<ge>N. norm (x n - x N) < d" by auto } |
|
5466 thus ?thesis unfolding cauchy and dist_norm by auto |
|
5467 qed |
|
5468 |
|
5469 lemma complete_isometric_image: |
|
5470 fixes f :: "real ^ _ \<Rightarrow> real ^ _" |
|
5471 assumes "0 < e" and s:"subspace s" and f:"bounded_linear f" and normf:"\<forall>x\<in>s. norm(f x) \<ge> e * norm(x)" and cs:"complete s" |
|
5472 shows "complete(f ` s)" |
|
5473 proof- |
|
5474 { fix g assume as:"\<forall>n::nat. g n \<in> f ` s" and cfg:"Cauchy g" |
|
5475 then obtain x where "\<forall>n. x n \<in> s \<and> g n = f (x n)" unfolding image_iff and Bex_def |
|
5476 using choice[of "\<lambda> n xa. xa \<in> s \<and> g n = f xa"] by auto |
|
5477 hence x:"\<forall>n. x n \<in> s" "\<forall>n. g n = f (x n)" by auto |
|
5478 hence "f \<circ> x = g" unfolding expand_fun_eq by auto |
|
5479 then obtain l where "l\<in>s" and l:"(x ---> l) sequentially" |
|
5480 using cs[unfolded complete_def, THEN spec[where x="x"]] |
|
5481 using cauchy_isometric[OF `0<e` s f normf] and cfg and x(1) by auto |
|
5482 hence "\<exists>l\<in>f ` s. (g ---> l) sequentially" |
|
5483 using linear_continuous_at[OF f, unfolded continuous_at_sequentially, THEN spec[where x=x], of l] |
|
5484 unfolding `f \<circ> x = g` by auto } |
|
5485 thus ?thesis unfolding complete_def by auto |
|
5486 qed |
|
5487 |
|
5488 lemma dist_0_norm: |
|
5489 fixes x :: "'a::real_normed_vector" |
|
5490 shows "dist 0 x = norm x" |
|
5491 unfolding dist_norm by simp |
|
5492 |
|
5493 lemma injective_imp_isometric: fixes f::"real^'m::finite \<Rightarrow> real^'n::finite" |
|
5494 assumes s:"closed s" "subspace s" and f:"bounded_linear f" "\<forall>x\<in>s. (f x = 0) \<longrightarrow> (x = 0)" |
|
5495 shows "\<exists>e>0. \<forall>x\<in>s. norm (f x) \<ge> e * norm(x)" |
|
5496 proof(cases "s \<subseteq> {0::real^'m}") |
|
5497 case True |
|
5498 { fix x assume "x \<in> s" |
|
5499 hence "x = 0" using True by auto |
|
5500 hence "norm x \<le> norm (f x)" by auto } |
|
5501 thus ?thesis by(auto intro!: exI[where x=1]) |
|
5502 next |
|
5503 interpret f: bounded_linear f by fact |
|
5504 case False |
|
5505 then obtain a where a:"a\<noteq>0" "a\<in>s" by auto |
|
5506 from False have "s \<noteq> {}" by auto |
|
5507 let ?S = "{f x| x. (x \<in> s \<and> norm x = norm a)}" |
|
5508 let ?S' = "{x::real^'m. x\<in>s \<and> norm x = norm a}" |
|
5509 let ?S'' = "{x::real^'m. norm x = norm a}" |
|
5510 |
|
5511 have "?S'' = frontier(cball 0 (norm a))" unfolding frontier_cball and dist_norm by (auto simp add: norm_minus_cancel) |
|
5512 hence "compact ?S''" using compact_frontier[OF compact_cball, of 0 "norm a"] by auto |
|
5513 moreover have "?S' = s \<inter> ?S''" by auto |
|
5514 ultimately have "compact ?S'" using closed_inter_compact[of s ?S''] using s(1) by auto |
|
5515 moreover have *:"f ` ?S' = ?S" by auto |
|
5516 ultimately have "compact ?S" using compact_continuous_image[OF linear_continuous_on[OF f(1)], of ?S'] by auto |
|
5517 hence "closed ?S" using compact_imp_closed by auto |
|
5518 moreover have "?S \<noteq> {}" using a by auto |
|
5519 ultimately obtain b' where "b'\<in>?S" "\<forall>y\<in>?S. norm b' \<le> norm y" using distance_attains_inf[of ?S 0] unfolding dist_0_norm by auto |
|
5520 then obtain b where "b\<in>s" and ba:"norm b = norm a" and b:"\<forall>x\<in>{x \<in> s. norm x = norm a}. norm (f b) \<le> norm (f x)" unfolding *[THEN sym] unfolding image_iff by auto |
|
5521 |
|
5522 let ?e = "norm (f b) / norm b" |
|
5523 have "norm b > 0" using ba and a and norm_ge_zero by auto |
|
5524 moreover have "norm (f b) > 0" using f(2)[THEN bspec[where x=b], OF `b\<in>s`] using `norm b >0` unfolding zero_less_norm_iff by auto |
|
5525 ultimately have "0 < norm (f b) / norm b" by(simp only: divide_pos_pos) |
|
5526 moreover |
|
5527 { fix x assume "x\<in>s" |
|
5528 hence "norm (f b) / norm b * norm x \<le> norm (f x)" |
|
5529 proof(cases "x=0") |
|
5530 case True thus "norm (f b) / norm b * norm x \<le> norm (f x)" by auto |
|
5531 next |
|
5532 case False |
|
5533 hence *:"0 < norm a / norm x" using `a\<noteq>0` unfolding zero_less_norm_iff[THEN sym] by(simp only: divide_pos_pos) |
|
5534 have "\<forall>c. \<forall>x\<in>s. c *\<^sub>R x \<in> s" using s[unfolded subspace_def smult_conv_scaleR] by auto |
|
5535 hence "(norm a / norm x) *\<^sub>R x \<in> {x \<in> s. norm x = norm a}" using `x\<in>s` and `x\<noteq>0` by auto |
|
5536 thus "norm (f b) / norm b * norm x \<le> norm (f x)" using b[THEN bspec[where x="(norm a / norm x) *\<^sub>R x"]] |
|
5537 unfolding f.scaleR and ba using `x\<noteq>0` `a\<noteq>0` |
|
5538 by (auto simp add: real_mult_commute pos_le_divide_eq pos_divide_le_eq) |
|
5539 qed } |
|
5540 ultimately |
|
5541 show ?thesis by auto |
|
5542 qed |
|
5543 |
|
5544 lemma closed_injective_image_subspace: |
|
5545 fixes f :: "real ^ _ \<Rightarrow> real ^ _" |
|
5546 assumes "subspace s" "bounded_linear f" "\<forall>x\<in>s. f x = 0 --> x = 0" "closed s" |
|
5547 shows "closed(f ` s)" |
|
5548 proof- |
|
5549 obtain e where "e>0" and e:"\<forall>x\<in>s. e * norm x \<le> norm (f x)" using injective_imp_isometric[OF assms(4,1,2,3)] by auto |
|
5550 show ?thesis using complete_isometric_image[OF `e>0` assms(1,2) e] and assms(4) |
|
5551 unfolding complete_eq_closed[THEN sym] by auto |
|
5552 qed |
|
5553 |
|
5554 subsection{* Some properties of a canonical subspace. *} |
|
5555 |
|
5556 lemma subspace_substandard: |
|
5557 "subspace {x::real^'n. (\<forall>i. P i \<longrightarrow> x$i = 0)}" |
|
5558 unfolding subspace_def by(auto simp add: vector_add_component vector_smult_component elim!: ballE) |
|
5559 |
|
5560 lemma closed_substandard: |
|
5561 "closed {x::real^'n::finite. \<forall>i. P i --> x$i = 0}" (is "closed ?A") |
|
5562 proof- |
|
5563 let ?D = "{i. P i}" |
|
5564 let ?Bs = "{{x::real^'n. inner (basis i) x = 0}| i. i \<in> ?D}" |
|
5565 { fix x |
|
5566 { assume "x\<in>?A" |
|
5567 hence x:"\<forall>i\<in>?D. x $ i = 0" by auto |
|
5568 hence "x\<in> \<Inter> ?Bs" by(auto simp add: inner_basis x) } |
|
5569 moreover |
|
5570 { assume x:"x\<in>\<Inter>?Bs" |
|
5571 { fix i assume i:"i \<in> ?D" |
|
5572 then obtain B where BB:"B \<in> ?Bs" and B:"B = {x::real^'n. inner (basis i) x = 0}" by auto |
|
5573 hence "x $ i = 0" unfolding B using x unfolding inner_basis by auto } |
|
5574 hence "x\<in>?A" by auto } |
|
5575 ultimately have "x\<in>?A \<longleftrightarrow> x\<in> \<Inter>?Bs" by auto } |
|
5576 hence "?A = \<Inter> ?Bs" by auto |
|
5577 thus ?thesis by(auto simp add: closed_Inter closed_hyperplane) |
|
5578 qed |
|
5579 |
|
5580 lemma dim_substandard: |
|
5581 shows "dim {x::real^'n::finite. \<forall>i. i \<notin> d \<longrightarrow> x$i = 0} = card d" (is "dim ?A = _") |
|
5582 proof- |
|
5583 let ?D = "UNIV::'n set" |
|
5584 let ?B = "(basis::'n\<Rightarrow>real^'n) ` d" |
|
5585 |
|
5586 let ?bas = "basis::'n \<Rightarrow> real^'n" |
|
5587 |
|
5588 have "?B \<subseteq> ?A" by auto |
|
5589 |
|
5590 moreover |
|
5591 { fix x::"real^'n" assume "x\<in>?A" |
|
5592 with finite[of d] |
|
5593 have "x\<in> span ?B" |
|
5594 proof(induct d arbitrary: x) |
|
5595 case empty hence "x=0" unfolding Cart_eq by auto |
|
5596 thus ?case using subspace_0[OF subspace_span[of "{}"]] by auto |
|
5597 next |
|
5598 case (insert k F) |
|
5599 hence *:"\<forall>i. i \<notin> insert k F \<longrightarrow> x $ i = 0" by auto |
|
5600 have **:"F \<subseteq> insert k F" by auto |
|
5601 def y \<equiv> "x - x$k *\<^sub>R basis k" |
|
5602 have y:"x = y + (x$k) *\<^sub>R basis k" unfolding y_def by auto |
|
5603 { fix i assume i':"i \<notin> F" |
|
5604 hence "y $ i = 0" unfolding y_def unfolding vector_minus_component |
|
5605 and vector_smult_component and basis_component |
|
5606 using *[THEN spec[where x=i]] by auto } |
|
5607 hence "y \<in> span (basis ` (insert k F))" using insert(3) |
|
5608 using span_mono[of "?bas ` F" "?bas ` (insert k F)"] |
|
5609 using image_mono[OF **, of basis] by auto |
|
5610 moreover |
|
5611 have "basis k \<in> span (?bas ` (insert k F))" by(rule span_superset, auto) |
|
5612 hence "x$k *\<^sub>R basis k \<in> span (?bas ` (insert k F))" |
|
5613 using span_mul [where 'a=real, unfolded smult_conv_scaleR] by auto |
|
5614 ultimately |
|
5615 have "y + x$k *\<^sub>R basis k \<in> span (?bas ` (insert k F))" |
|
5616 using span_add by auto |
|
5617 thus ?case using y by auto |
|
5618 qed |
|
5619 } |
|
5620 hence "?A \<subseteq> span ?B" by auto |
|
5621 |
|
5622 moreover |
|
5623 { fix x assume "x \<in> ?B" |
|
5624 hence "x\<in>{(basis i)::real^'n |i. i \<in> ?D}" using assms by auto } |
|
5625 hence "independent ?B" using independent_mono[OF independent_stdbasis, of ?B] and assms by auto |
|
5626 |
|
5627 moreover |
|
5628 have "d \<subseteq> ?D" unfolding subset_eq using assms by auto |
|
5629 hence *:"inj_on (basis::'n\<Rightarrow>real^'n) d" using subset_inj_on[OF basis_inj, of "d"] by auto |
|
5630 have "?B hassize (card d)" unfolding hassize_def and card_image[OF *] by auto |
|
5631 |
|
5632 ultimately show ?thesis using dim_unique[of "basis ` d" ?A] by auto |
|
5633 qed |
|
5634 |
|
5635 text{* Hence closure and completeness of all subspaces. *} |
|
5636 |
|
5637 lemma closed_subspace_lemma: "n \<le> card (UNIV::'n::finite set) \<Longrightarrow> \<exists>A::'n set. card A = n" |
|
5638 apply (induct n) |
|
5639 apply (rule_tac x="{}" in exI, simp) |
|
5640 apply clarsimp |
|
5641 apply (subgoal_tac "\<exists>x. x \<notin> A") |
|
5642 apply (erule exE) |
|
5643 apply (rule_tac x="insert x A" in exI, simp) |
|
5644 apply (subgoal_tac "A \<noteq> UNIV", auto) |
|
5645 done |
|
5646 |
|
5647 lemma closed_subspace: fixes s::"(real^'n::finite) set" |
|
5648 assumes "subspace s" shows "closed s" |
|
5649 proof- |
|
5650 have "dim s \<le> card (UNIV :: 'n set)" using dim_subset_univ by auto |
|
5651 then obtain d::"'n set" where t: "card d = dim s" |
|
5652 using closed_subspace_lemma by auto |
|
5653 let ?t = "{x::real^'n. \<forall>i. i \<notin> d \<longrightarrow> x$i = 0}" |
|
5654 obtain f where f:"bounded_linear f" "f ` ?t = s" "inj_on f ?t" |
|
5655 using subspace_isomorphism[unfolded linear_conv_bounded_linear, OF subspace_substandard[of "\<lambda>i. i \<notin> d"] assms] |
|
5656 using dim_substandard[of d] and t by auto |
|
5657 interpret f: bounded_linear f by fact |
|
5658 have "\<forall>x\<in>?t. f x = 0 \<longrightarrow> x = 0" using f.zero using f(3)[unfolded inj_on_def] |
|
5659 by(erule_tac x=0 in ballE) auto |
|
5660 moreover have "closed ?t" using closed_substandard . |
|
5661 moreover have "subspace ?t" using subspace_substandard . |
|
5662 ultimately show ?thesis using closed_injective_image_subspace[of ?t f] |
|
5663 unfolding f(2) using f(1) by auto |
|
5664 qed |
|
5665 |
|
5666 lemma complete_subspace: |
|
5667 fixes s :: "(real ^ _) set" shows "subspace s ==> complete s" |
|
5668 using complete_eq_closed closed_subspace |
|
5669 by auto |
|
5670 |
|
5671 lemma dim_closure: |
|
5672 fixes s :: "(real ^ _) set" |
|
5673 shows "dim(closure s) = dim s" (is "?dc = ?d") |
|
5674 proof- |
|
5675 have "?dc \<le> ?d" using closure_minimal[OF span_inc, of s] |
|
5676 using closed_subspace[OF subspace_span, of s] |
|
5677 using dim_subset[of "closure s" "span s"] unfolding dim_span by auto |
|
5678 thus ?thesis using dim_subset[OF closure_subset, of s] by auto |
|
5679 qed |
|
5680 |
|
5681 text{* Affine transformations of intervals. *} |
|
5682 |
|
5683 lemma affinity_inverses: |
|
5684 assumes m0: "m \<noteq> (0::'a::field)" |
|
5685 shows "(\<lambda>x. m *s x + c) o (\<lambda>x. inverse(m) *s x + (-(inverse(m) *s c))) = id" |
|
5686 "(\<lambda>x. inverse(m) *s x + (-(inverse(m) *s c))) o (\<lambda>x. m *s x + c) = id" |
|
5687 using m0 |
|
5688 apply (auto simp add: expand_fun_eq vector_add_ldistrib vector_smult_assoc) |
|
5689 by (simp add: vector_smult_lneg[symmetric] vector_smult_assoc vector_sneg_minus1[symmetric]) |
|
5690 |
|
5691 lemma real_affinity_le: |
|
5692 "0 < (m::'a::ordered_field) ==> (m * x + c \<le> y \<longleftrightarrow> x \<le> inverse(m) * y + -(c / m))" |
|
5693 by (simp add: field_simps inverse_eq_divide) |
|
5694 |
|
5695 lemma real_le_affinity: |
|
5696 "0 < (m::'a::ordered_field) ==> (y \<le> m * x + c \<longleftrightarrow> inverse(m) * y + -(c / m) \<le> x)" |
|
5697 by (simp add: field_simps inverse_eq_divide) |
|
5698 |
|
5699 lemma real_affinity_lt: |
|
5700 "0 < (m::'a::ordered_field) ==> (m * x + c < y \<longleftrightarrow> x < inverse(m) * y + -(c / m))" |
|
5701 by (simp add: field_simps inverse_eq_divide) |
|
5702 |
|
5703 lemma real_lt_affinity: |
|
5704 "0 < (m::'a::ordered_field) ==> (y < m * x + c \<longleftrightarrow> inverse(m) * y + -(c / m) < x)" |
|
5705 by (simp add: field_simps inverse_eq_divide) |
|
5706 |
|
5707 lemma real_affinity_eq: |
|
5708 "(m::'a::ordered_field) \<noteq> 0 ==> (m * x + c = y \<longleftrightarrow> x = inverse(m) * y + -(c / m))" |
|
5709 by (simp add: field_simps inverse_eq_divide) |
|
5710 |
|
5711 lemma real_eq_affinity: |
|
5712 "(m::'a::ordered_field) \<noteq> 0 ==> (y = m * x + c \<longleftrightarrow> inverse(m) * y + -(c / m) = x)" |
|
5713 by (simp add: field_simps inverse_eq_divide) |
|
5714 |
|
5715 lemma vector_affinity_eq: |
|
5716 assumes m0: "(m::'a::field) \<noteq> 0" |
|
5717 shows "m *s x + c = y \<longleftrightarrow> x = inverse m *s y + -(inverse m *s c)" |
|
5718 proof |
|
5719 assume h: "m *s x + c = y" |
|
5720 hence "m *s x = y - c" by (simp add: ring_simps) |
|
5721 hence "inverse m *s (m *s x) = inverse m *s (y - c)" by simp |
|
5722 then show "x = inverse m *s y + - (inverse m *s c)" |
|
5723 using m0 by (simp add: vector_smult_assoc vector_ssub_ldistrib) |
|
5724 next |
|
5725 assume h: "x = inverse m *s y + - (inverse m *s c)" |
|
5726 show "m *s x + c = y" unfolding h diff_minus[symmetric] |
|
5727 using m0 by (simp add: vector_smult_assoc vector_ssub_ldistrib) |
|
5728 qed |
|
5729 |
|
5730 lemma vector_eq_affinity: |
|
5731 "(m::'a::field) \<noteq> 0 ==> (y = m *s x + c \<longleftrightarrow> inverse(m) *s y + -(inverse(m) *s c) = x)" |
|
5732 using vector_affinity_eq[where m=m and x=x and y=y and c=c] |
|
5733 by metis |
|
5734 |
|
5735 lemma image_affinity_interval: fixes m::real |
|
5736 fixes a b c :: "real^'n::finite" |
|
5737 shows "(\<lambda>x. m *\<^sub>R x + c) ` {a .. b} = |
|
5738 (if {a .. b} = {} then {} |
|
5739 else (if 0 \<le> m then {m *\<^sub>R a + c .. m *\<^sub>R b + c} |
|
5740 else {m *\<^sub>R b + c .. m *\<^sub>R a + c}))" |
|
5741 proof(cases "m=0") |
|
5742 { fix x assume "x \<le> c" "c \<le> x" |
|
5743 hence "x=c" unfolding vector_less_eq_def and Cart_eq by (auto intro: order_antisym) } |
|
5744 moreover case True |
|
5745 moreover have "c \<in> {m *\<^sub>R a + c..m *\<^sub>R b + c}" unfolding True by(auto simp add: vector_less_eq_def) |
|
5746 ultimately show ?thesis by auto |
|
5747 next |
|
5748 case False |
|
5749 { fix y assume "a \<le> y" "y \<le> b" "m > 0" |
|
5750 hence "m *\<^sub>R a + c \<le> m *\<^sub>R y + c" "m *\<^sub>R y + c \<le> m *\<^sub>R b + c" |
|
5751 unfolding vector_less_eq_def by(auto simp add: vector_smult_component vector_add_component) |
|
5752 } moreover |
|
5753 { fix y assume "a \<le> y" "y \<le> b" "m < 0" |
|
5754 hence "m *\<^sub>R b + c \<le> m *\<^sub>R y + c" "m *\<^sub>R y + c \<le> m *\<^sub>R a + c" |
|
5755 unfolding vector_less_eq_def by(auto simp add: vector_smult_component vector_add_component mult_left_mono_neg elim!:ballE) |
|
5756 } moreover |
|
5757 { fix y assume "m > 0" "m *\<^sub>R a + c \<le> y" "y \<le> m *\<^sub>R b + c" |
|
5758 hence "y \<in> (\<lambda>x. m *\<^sub>R x + c) ` {a..b}" |
|
5759 unfolding image_iff Bex_def mem_interval vector_less_eq_def |
|
5760 apply(auto simp add: vector_smult_component vector_add_component vector_minus_component vector_smult_assoc pth_3[symmetric] |
|
5761 intro!: exI[where x="(1 / m) *\<^sub>R (y - c)"]) |
|
5762 by(auto simp add: pos_le_divide_eq pos_divide_le_eq real_mult_commute diff_le_iff) |
|
5763 } moreover |
|
5764 { fix y assume "m *\<^sub>R b + c \<le> y" "y \<le> m *\<^sub>R a + c" "m < 0" |
|
5765 hence "y \<in> (\<lambda>x. m *\<^sub>R x + c) ` {a..b}" |
|
5766 unfolding image_iff Bex_def mem_interval vector_less_eq_def |
|
5767 apply(auto simp add: vector_smult_component vector_add_component vector_minus_component vector_smult_assoc pth_3[symmetric] |
|
5768 intro!: exI[where x="(1 / m) *\<^sub>R (y - c)"]) |
|
5769 by(auto simp add: neg_le_divide_eq neg_divide_le_eq real_mult_commute diff_le_iff) |
|
5770 } |
|
5771 ultimately show ?thesis using False by auto |
|
5772 qed |
|
5773 |
|
5774 lemma image_smult_interval:"(\<lambda>x. m *\<^sub>R (x::real^'n::finite)) ` {a..b} = |
|
5775 (if {a..b} = {} then {} else if 0 \<le> m then {m *\<^sub>R a..m *\<^sub>R b} else {m *\<^sub>R b..m *\<^sub>R a})" |
|
5776 using image_affinity_interval[of m 0 a b] by auto |
|
5777 |
|
5778 subsection{* Banach fixed point theorem (not really topological...) *} |
|
5779 |
|
5780 lemma banach_fix: |
|
5781 assumes s:"complete s" "s \<noteq> {}" and c:"0 \<le> c" "c < 1" and f:"(f ` s) \<subseteq> s" and |
|
5782 lipschitz:"\<forall>x\<in>s. \<forall>y\<in>s. dist (f x) (f y) \<le> c * dist x y" |
|
5783 shows "\<exists>! x\<in>s. (f x = x)" |
|
5784 proof- |
|
5785 have "1 - c > 0" using c by auto |
|
5786 |
|
5787 from s(2) obtain z0 where "z0 \<in> s" by auto |
|
5788 def z \<equiv> "\<lambda>n. (f ^^ n) z0" |
|
5789 { fix n::nat |
|
5790 have "z n \<in> s" unfolding z_def |
|
5791 proof(induct n) case 0 thus ?case using `z0 \<in>s` by auto |
|
5792 next case Suc thus ?case using f by auto qed } |
|
5793 note z_in_s = this |
|
5794 |
|
5795 def d \<equiv> "dist (z 0) (z 1)" |
|
5796 |
|
5797 have fzn:"\<And>n. f (z n) = z (Suc n)" unfolding z_def by auto |
|
5798 { fix n::nat |
|
5799 have "dist (z n) (z (Suc n)) \<le> (c ^ n) * d" |
|
5800 proof(induct n) |
|
5801 case 0 thus ?case unfolding d_def by auto |
|
5802 next |
|
5803 case (Suc m) |
|
5804 hence "c * dist (z m) (z (Suc m)) \<le> c ^ Suc m * d" |
|
5805 using `0 \<le> c` using mult_mono1_class.mult_mono1[of "dist (z m) (z (Suc m))" "c ^ m * d" c] by auto |
|
5806 thus ?case using lipschitz[THEN bspec[where x="z m"], OF z_in_s, THEN bspec[where x="z (Suc m)"], OF z_in_s] |
|
5807 unfolding fzn and mult_le_cancel_left by auto |
|
5808 qed |
|
5809 } note cf_z = this |
|
5810 |
|
5811 { fix n m::nat |
|
5812 have "(1 - c) * dist (z m) (z (m+n)) \<le> (c ^ m) * d * (1 - c ^ n)" |
|
5813 proof(induct n) |
|
5814 case 0 show ?case by auto |
|
5815 next |
|
5816 case (Suc k) |
|
5817 have "(1 - c) * dist (z m) (z (m + Suc k)) \<le> (1 - c) * (dist (z m) (z (m + k)) + dist (z (m + k)) (z (Suc (m + k))))" |
|
5818 using dist_triangle and c by(auto simp add: dist_triangle) |
|
5819 also have "\<dots> \<le> (1 - c) * (dist (z m) (z (m + k)) + c ^ (m + k) * d)" |
|
5820 using cf_z[of "m + k"] and c by auto |
|
5821 also have "\<dots> \<le> c ^ m * d * (1 - c ^ k) + (1 - c) * c ^ (m + k) * d" |
|
5822 using Suc by (auto simp add: ring_simps) |
|
5823 also have "\<dots> = (c ^ m) * (d * (1 - c ^ k) + (1 - c) * c ^ k * d)" |
|
5824 unfolding power_add by (auto simp add: ring_simps) |
|
5825 also have "\<dots> \<le> (c ^ m) * d * (1 - c ^ Suc k)" |
|
5826 using c by (auto simp add: ring_simps) |
|
5827 finally show ?case by auto |
|
5828 qed |
|
5829 } note cf_z2 = this |
|
5830 { fix e::real assume "e>0" |
|
5831 hence "\<exists>N. \<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist (z m) (z n) < e" |
|
5832 proof(cases "d = 0") |
|
5833 case True |
|
5834 hence "\<And>n. z n = z0" using cf_z2[of 0] and c unfolding z_def by (auto simp add: pos_prod_le[OF `1 - c > 0`]) |
|
5835 thus ?thesis using `e>0` by auto |
|
5836 next |
|
5837 case False hence "d>0" unfolding d_def using zero_le_dist[of "z 0" "z 1"] |
|
5838 by (metis False d_def real_less_def) |
|
5839 hence "0 < e * (1 - c) / d" using `e>0` and `1-c>0` |
|
5840 using divide_pos_pos[of "e * (1 - c)" d] and mult_pos_pos[of e "1 - c"] by auto |
|
5841 then obtain N where N:"c ^ N < e * (1 - c) / d" using real_arch_pow_inv[of "e * (1 - c) / d" c] and c by auto |
|
5842 { fix m n::nat assume "m>n" and as:"m\<ge>N" "n\<ge>N" |
|
5843 have *:"c ^ n \<le> c ^ N" using `n\<ge>N` and c using power_decreasing[OF `n\<ge>N`, of c] by auto |
|
5844 have "1 - c ^ (m - n) > 0" using c and power_strict_mono[of c 1 "m - n"] using `m>n` by auto |
|
5845 hence **:"d * (1 - c ^ (m - n)) / (1 - c) > 0" |
|
5846 using real_mult_order[OF `d>0`, of "1 - c ^ (m - n)"] |
|
5847 using divide_pos_pos[of "d * (1 - c ^ (m - n))" "1 - c"] |
|
5848 using `0 < 1 - c` by auto |
|
5849 |
|
5850 have "dist (z m) (z n) \<le> c ^ n * d * (1 - c ^ (m - n)) / (1 - c)" |
|
5851 using cf_z2[of n "m - n"] and `m>n` unfolding pos_le_divide_eq[OF `1-c>0`] |
|
5852 by (auto simp add: real_mult_commute dist_commute) |
|
5853 also have "\<dots> \<le> c ^ N * d * (1 - c ^ (m - n)) / (1 - c)" |
|
5854 using mult_right_mono[OF * order_less_imp_le[OF **]] |
|
5855 unfolding real_mult_assoc by auto |
|
5856 also have "\<dots> < (e * (1 - c) / d) * d * (1 - c ^ (m - n)) / (1 - c)" |
|
5857 using mult_strict_right_mono[OF N **] unfolding real_mult_assoc by auto |
|
5858 also have "\<dots> = e * (1 - c ^ (m - n))" using c and `d>0` and `1 - c > 0` by auto |
|
5859 also have "\<dots> \<le> e" using c and `1 - c ^ (m - n) > 0` and `e>0` using mult_right_le_one_le[of e "1 - c ^ (m - n)"] by auto |
|
5860 finally have "dist (z m) (z n) < e" by auto |
|
5861 } note * = this |
|
5862 { fix m n::nat assume as:"N\<le>m" "N\<le>n" |
|
5863 hence "dist (z n) (z m) < e" |
|
5864 proof(cases "n = m") |
|
5865 case True thus ?thesis using `e>0` by auto |
|
5866 next |
|
5867 case False thus ?thesis using as and *[of n m] *[of m n] unfolding nat_neq_iff by (auto simp add: dist_commute) |
|
5868 qed } |
|
5869 thus ?thesis by auto |
|
5870 qed |
|
5871 } |
|
5872 hence "Cauchy z" unfolding cauchy_def by auto |
|
5873 then obtain x where "x\<in>s" and x:"(z ---> x) sequentially" using s(1)[unfolded compact_def complete_def, THEN spec[where x=z]] and z_in_s by auto |
|
5874 |
|
5875 def e \<equiv> "dist (f x) x" |
|
5876 have "e = 0" proof(rule ccontr) |
|
5877 assume "e \<noteq> 0" hence "e>0" unfolding e_def using zero_le_dist[of "f x" x] |
|
5878 by (metis dist_eq_0_iff dist_nz e_def) |
|
5879 then obtain N where N:"\<forall>n\<ge>N. dist (z n) x < e / 2" |
|
5880 using x[unfolded Lim_sequentially, THEN spec[where x="e/2"]] by auto |
|
5881 hence N':"dist (z N) x < e / 2" by auto |
|
5882 |
|
5883 have *:"c * dist (z N) x \<le> dist (z N) x" unfolding mult_le_cancel_right2 |
|
5884 using zero_le_dist[of "z N" x] and c |
|
5885 by (metis dist_eq_0_iff dist_nz order_less_asym real_less_def) |
|
5886 have "dist (f (z N)) (f x) \<le> c * dist (z N) x" using lipschitz[THEN bspec[where x="z N"], THEN bspec[where x=x]] |
|
5887 using z_in_s[of N] `x\<in>s` using c by auto |
|
5888 also have "\<dots> < e / 2" using N' and c using * by auto |
|
5889 finally show False unfolding fzn |
|
5890 using N[THEN spec[where x="Suc N"]] and dist_triangle_half_r[of "z (Suc N)" "f x" e x] |
|
5891 unfolding e_def by auto |
|
5892 qed |
|
5893 hence "f x = x" unfolding e_def by auto |
|
5894 moreover |
|
5895 { fix y assume "f y = y" "y\<in>s" |
|
5896 hence "dist x y \<le> c * dist x y" using lipschitz[THEN bspec[where x=x], THEN bspec[where x=y]] |
|
5897 using `x\<in>s` and `f x = x` by auto |
|
5898 hence "dist x y = 0" unfolding mult_le_cancel_right1 |
|
5899 using c and zero_le_dist[of x y] by auto |
|
5900 hence "y = x" by auto |
|
5901 } |
|
5902 ultimately show ?thesis unfolding Bex1_def using `x\<in>s` by blast+ |
|
5903 qed |
|
5904 |
|
5905 subsection{* Edelstein fixed point theorem. *} |
|
5906 |
|
5907 lemma edelstein_fix: |
|
5908 fixes s :: "'a::real_normed_vector set" |
|
5909 assumes s:"compact s" "s \<noteq> {}" and gs:"(g ` s) \<subseteq> s" |
|
5910 and dist:"\<forall>x\<in>s. \<forall>y\<in>s. x \<noteq> y \<longrightarrow> dist (g x) (g y) < dist x y" |
|
5911 shows "\<exists>! x\<in>s. g x = x" |
|
5912 proof(cases "\<exists>x\<in>s. g x \<noteq> x") |
|
5913 obtain x where "x\<in>s" using s(2) by auto |
|
5914 case False hence g:"\<forall>x\<in>s. g x = x" by auto |
|
5915 { fix y assume "y\<in>s" |
|
5916 hence "x = y" using `x\<in>s` and dist[THEN bspec[where x=x], THEN bspec[where x=y]] |
|
5917 unfolding g[THEN bspec[where x=x], OF `x\<in>s`] |
|
5918 unfolding g[THEN bspec[where x=y], OF `y\<in>s`] by auto } |
|
5919 thus ?thesis unfolding Bex1_def using `x\<in>s` and g by blast+ |
|
5920 next |
|
5921 case True |
|
5922 then obtain x where [simp]:"x\<in>s" and "g x \<noteq> x" by auto |
|
5923 { fix x y assume "x \<in> s" "y \<in> s" |
|
5924 hence "dist (g x) (g y) \<le> dist x y" |
|
5925 using dist[THEN bspec[where x=x], THEN bspec[where x=y]] by auto } note dist' = this |
|
5926 def y \<equiv> "g x" |
|
5927 have [simp]:"y\<in>s" unfolding y_def using gs[unfolded image_subset_iff] and `x\<in>s` by blast |
|
5928 def f \<equiv> "\<lambda>n. g ^^ n" |
|
5929 have [simp]:"\<And>n z. g (f n z) = f (Suc n) z" unfolding f_def by auto |
|
5930 have [simp]:"\<And>z. f 0 z = z" unfolding f_def by auto |
|
5931 { fix n::nat and z assume "z\<in>s" |
|
5932 have "f n z \<in> s" unfolding f_def |
|
5933 proof(induct n) |
|
5934 case 0 thus ?case using `z\<in>s` by simp |
|
5935 next |
|
5936 case (Suc n) thus ?case using gs[unfolded image_subset_iff] by auto |
|
5937 qed } note fs = this |
|
5938 { fix m n ::nat assume "m\<le>n" |
|
5939 fix w z assume "w\<in>s" "z\<in>s" |
|
5940 have "dist (f n w) (f n z) \<le> dist (f m w) (f m z)" using `m\<le>n` |
|
5941 proof(induct n) |
|
5942 case 0 thus ?case by auto |
|
5943 next |
|
5944 case (Suc n) |
|
5945 thus ?case proof(cases "m\<le>n") |
|
5946 case True thus ?thesis using Suc(1) |
|
5947 using dist'[OF fs fs, OF `w\<in>s` `z\<in>s`, of n n] by auto |
|
5948 next |
|
5949 case False hence mn:"m = Suc n" using Suc(2) by simp |
|
5950 show ?thesis unfolding mn by auto |
|
5951 qed |
|
5952 qed } note distf = this |
|
5953 |
|
5954 def h \<equiv> "\<lambda>n. (f n x, f n y)" |
|
5955 let ?s2 = "s \<times> s" |
|
5956 obtain l r where "l\<in>?s2" and r:"subseq r" and lr:"((h \<circ> r) ---> l) sequentially" |
|
5957 using compact_Times [OF s(1) s(1), unfolded compact_def, THEN spec[where x=h]] unfolding h_def |
|
5958 using fs[OF `x\<in>s`] and fs[OF `y\<in>s`] by blast |
|
5959 def a \<equiv> "fst l" def b \<equiv> "snd l" |
|
5960 have lab:"l = (a, b)" unfolding a_def b_def by simp |
|
5961 have [simp]:"a\<in>s" "b\<in>s" unfolding a_def b_def using `l\<in>?s2` by auto |
|
5962 |
|
5963 have lima:"((fst \<circ> (h \<circ> r)) ---> a) sequentially" |
|
5964 and limb:"((snd \<circ> (h \<circ> r)) ---> b) sequentially" |
|
5965 using lr |
|
5966 unfolding o_def a_def b_def by (simp_all add: tendsto_intros) |
|
5967 |
|
5968 { fix n::nat |
|
5969 have *:"\<And>fx fy (x::'a) y. dist fx fy \<le> dist x y \<Longrightarrow> \<not> (dist (fx - fy) (a - b) < dist a b - dist x y)" unfolding dist_norm by norm |
|
5970 { fix x y :: 'a |
|
5971 have "dist (-x) (-y) = dist x y" unfolding dist_norm |
|
5972 using norm_minus_cancel[of "x - y"] by (auto simp add: uminus_add_conv_diff) } note ** = this |
|
5973 |
|
5974 { assume as:"dist a b > dist (f n x) (f n y)" |
|
5975 then obtain Na Nb where "\<forall>m\<ge>Na. dist (f (r m) x) a < (dist a b - dist (f n x) (f n y)) / 2" |
|
5976 and "\<forall>m\<ge>Nb. dist (f (r m) y) b < (dist a b - dist (f n x) (f n y)) / 2" |
|
5977 using lima limb unfolding h_def Lim_sequentially by (fastsimp simp del: less_divide_eq_number_of1) |
|
5978 hence "dist (f (r (Na + Nb + n)) x - f (r (Na + Nb + n)) y) (a - b) < dist a b - dist (f n x) (f n y)" |
|
5979 apply(erule_tac x="Na+Nb+n" in allE) |
|
5980 apply(erule_tac x="Na+Nb+n" in allE) apply simp |
|
5981 using dist_triangle_add_half[of a "f (r (Na + Nb + n)) x" "dist a b - dist (f n x) (f n y)" |
|
5982 "-b" "- f (r (Na + Nb + n)) y"] |
|
5983 unfolding ** unfolding group_simps(12) by (auto simp add: dist_commute) |
|
5984 moreover |
|
5985 have "dist (f (r (Na + Nb + n)) x - f (r (Na + Nb + n)) y) (a - b) \<ge> dist a b - dist (f n x) (f n y)" |
|
5986 using distf[of n "r (Na+Nb+n)", OF _ `x\<in>s` `y\<in>s`] |
|
5987 using subseq_bigger[OF r, of "Na+Nb+n"] |
|
5988 using *[of "f (r (Na + Nb + n)) x" "f (r (Na + Nb + n)) y" "f n x" "f n y"] by auto |
|
5989 ultimately have False by simp |
|
5990 } |
|
5991 hence "dist a b \<le> dist (f n x) (f n y)" by(rule ccontr)auto } |
|
5992 note ab_fn = this |
|
5993 |
|
5994 have [simp]:"a = b" proof(rule ccontr) |
|
5995 def e \<equiv> "dist a b - dist (g a) (g b)" |
|
5996 assume "a\<noteq>b" hence "e > 0" unfolding e_def using dist by fastsimp |
|
5997 hence "\<exists>n. dist (f n x) a < e/2 \<and> dist (f n y) b < e/2" |
|
5998 using lima limb unfolding Lim_sequentially |
|
5999 apply (auto elim!: allE[where x="e/2"]) apply(rule_tac x="r (max N Na)" in exI) unfolding h_def by fastsimp |
|
6000 then obtain n where n:"dist (f n x) a < e/2 \<and> dist (f n y) b < e/2" by auto |
|
6001 have "dist (f (Suc n) x) (g a) \<le> dist (f n x) a" |
|
6002 using dist[THEN bspec[where x="f n x"], THEN bspec[where x="a"]] and fs by auto |
|
6003 moreover have "dist (f (Suc n) y) (g b) \<le> dist (f n y) b" |
|
6004 using dist[THEN bspec[where x="f n y"], THEN bspec[where x="b"]] and fs by auto |
|
6005 ultimately have "dist (f (Suc n) x) (g a) + dist (f (Suc n) y) (g b) < e" using n by auto |
|
6006 thus False unfolding e_def using ab_fn[of "Suc n"] by norm |
|
6007 qed |
|
6008 |
|
6009 have [simp]:"\<And>n. f (Suc n) x = f n y" unfolding f_def y_def by(induct_tac n)auto |
|
6010 { fix x y assume "x\<in>s" "y\<in>s" moreover |
|
6011 fix e::real assume "e>0" ultimately |
|
6012 have "dist y x < e \<longrightarrow> dist (g y) (g x) < e" using dist by fastsimp } |
|
6013 hence "continuous_on s g" unfolding continuous_on_def by auto |
|
6014 |
|
6015 hence "((snd \<circ> h \<circ> r) ---> g a) sequentially" unfolding continuous_on_sequentially |
|
6016 apply (rule allE[where x="\<lambda>n. (fst \<circ> h \<circ> r) n"]) apply (erule ballE[where x=a]) |
|
6017 using lima unfolding h_def o_def using fs[OF `x\<in>s`] by (auto simp add: y_def) |
|
6018 hence "g a = a" using Lim_unique[OF trivial_limit_sequentially limb, of "g a"] |
|
6019 unfolding `a=b` and o_assoc by auto |
|
6020 moreover |
|
6021 { fix x assume "x\<in>s" "g x = x" "x\<noteq>a" |
|
6022 hence "False" using dist[THEN bspec[where x=a], THEN bspec[where x=x]] |
|
6023 using `g a = a` and `a\<in>s` by auto } |
|
6024 ultimately show "\<exists>!x\<in>s. g x = x" unfolding Bex1_def using `a\<in>s` by blast |
|
6025 qed |
|
6026 |
|
6027 end |
|