1 (* Title: Topology |
|
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) |
|
103 apply (metis openin_subset subset_eq) |
|
104 apply (auto simp add: Diff_Diff_Int) |
|
105 apply (subgoal_tac "topspace U \<inter> S = S") |
|
106 by auto |
|
107 |
|
108 lemma openin_closedin: "S \<subseteq> topspace U \<Longrightarrow> (openin U S \<longleftrightarrow> closedin U (topspace U - S))" |
|
109 by (simp add: openin_closedin_eq) |
|
110 |
|
111 lemma openin_diff[intro]: assumes oS: "openin U S" and cT: "closedin U T" shows "openin U (S - T)" |
|
112 proof- |
|
113 have "S - T = S \<inter> (topspace U - T)" using openin_subset[of U S] oS cT |
|
114 by (auto simp add: topspace_def openin_subset) |
|
115 then show ?thesis using oS cT by (auto simp add: closedin_def) |
|
116 qed |
|
117 |
|
118 lemma closedin_diff[intro]: assumes oS: "closedin U S" and cT: "openin U T" shows "closedin U (S - T)" |
|
119 proof- |
|
120 have "S - T = S \<inter> (topspace U - T)" using closedin_subset[of U S] oS cT |
|
121 by (auto simp add: topspace_def ) |
|
122 then show ?thesis using oS cT by (auto simp add: openin_closedin_eq) |
|
123 qed |
|
124 |
|
125 subsection{* Subspace topology. *} |
|
126 |
|
127 definition "subtopology U V = topology {S \<inter> V |S. openin U S}" |
|
128 |
|
129 lemma istopology_subtopology: "istopology {S \<inter> V |S. openin U S}" (is "istopology ?L") |
|
130 proof- |
|
131 have "{} \<in> ?L" by blast |
|
132 {fix A B assume A: "A \<in> ?L" and B: "B \<in> ?L" |
|
133 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 |
|
134 have "A\<inter>B = (Sa \<inter> Sb) \<inter> V" "openin U (Sa \<inter> Sb)" using Sa Sb by blast+ |
|
135 then have "A \<inter> B \<in> ?L" by blast} |
|
136 moreover |
|
137 {fix K assume K: "K \<subseteq> ?L" |
|
138 have th0: "?L = (\<lambda>S. S \<inter> V) ` openin U " |
|
139 apply (rule set_ext) |
|
140 apply (simp add: Ball_def image_iff) |
|
141 by (metis mem_def) |
|
142 from K[unfolded th0 subset_image_iff] |
|
143 obtain Sk where Sk: "Sk \<subseteq> openin U" "K = (\<lambda>S. S \<inter> V) ` Sk" by blast |
|
144 have "\<Union>K = (\<Union>Sk) \<inter> V" using Sk by auto |
|
145 moreover have "openin U (\<Union> Sk)" using Sk by (auto simp add: subset_eq mem_def) |
|
146 ultimately have "\<Union>K \<in> ?L" by blast} |
|
147 ultimately show ?thesis unfolding istopology_def by blast |
|
148 qed |
|
149 |
|
150 lemma openin_subtopology: |
|
151 "openin (subtopology U V) S \<longleftrightarrow> (\<exists> T. (openin U T) \<and> (S = T \<inter> V))" |
|
152 unfolding subtopology_def topology_inverse'[OF istopology_subtopology] |
|
153 by (auto simp add: Collect_def) |
|
154 |
|
155 lemma topspace_subtopology: "topspace(subtopology U V) = topspace U \<inter> V" |
|
156 by (auto simp add: topspace_def openin_subtopology) |
|
157 |
|
158 lemma closedin_subtopology: |
|
159 "closedin (subtopology U V) S \<longleftrightarrow> (\<exists>T. closedin U T \<and> S = T \<inter> V)" |
|
160 unfolding closedin_def topspace_subtopology |
|
161 apply (simp add: openin_subtopology) |
|
162 apply (rule iffI) |
|
163 apply clarify |
|
164 apply (rule_tac x="topspace U - T" in exI) |
|
165 by auto |
|
166 |
|
167 lemma openin_subtopology_refl: "openin (subtopology U V) V \<longleftrightarrow> V \<subseteq> topspace U" |
|
168 unfolding openin_subtopology |
|
169 apply (rule iffI, clarify) |
|
170 apply (frule openin_subset[of U]) apply blast |
|
171 apply (rule exI[where x="topspace U"]) |
|
172 by auto |
|
173 |
|
174 lemma subtopology_superset: assumes UV: "topspace U \<subseteq> V" |
|
175 shows "subtopology U V = U" |
|
176 proof- |
|
177 {fix S |
|
178 {fix T assume T: "openin U T" "S = T \<inter> V" |
|
179 from T openin_subset[OF T(1)] UV have eq: "S = T" by blast |
|
180 have "openin U S" unfolding eq using T by blast} |
|
181 moreover |
|
182 {assume S: "openin U S" |
|
183 hence "\<exists>T. openin U T \<and> S = T \<inter> V" |
|
184 using openin_subset[OF S] UV by auto} |
|
185 ultimately have "(\<exists>T. openin U T \<and> S = T \<inter> V) \<longleftrightarrow> openin U S" by blast} |
|
186 then show ?thesis unfolding topology_eq openin_subtopology by blast |
|
187 qed |
|
188 |
|
189 |
|
190 lemma subtopology_topspace[simp]: "subtopology U (topspace U) = U" |
|
191 by (simp add: subtopology_superset) |
|
192 |
|
193 lemma subtopology_UNIV[simp]: "subtopology U UNIV = U" |
|
194 by (simp add: subtopology_superset) |
|
195 |
|
196 subsection{* The universal Euclidean versions are what we use most of the time *} |
|
197 |
|
198 definition |
|
199 euclidean :: "'a::topological_space topology" where |
|
200 "euclidean = topology open" |
|
201 |
|
202 lemma open_openin: "open S \<longleftrightarrow> openin euclidean S" |
|
203 unfolding euclidean_def |
|
204 apply (rule cong[where x=S and y=S]) |
|
205 apply (rule topology_inverse[symmetric]) |
|
206 apply (auto simp add: istopology_def) |
|
207 by (auto simp add: mem_def subset_eq) |
|
208 |
|
209 lemma topspace_euclidean: "topspace euclidean = UNIV" |
|
210 apply (simp add: topspace_def) |
|
211 apply (rule set_ext) |
|
212 by (auto simp add: open_openin[symmetric]) |
|
213 |
|
214 lemma topspace_euclidean_subtopology[simp]: "topspace (subtopology euclidean S) = S" |
|
215 by (simp add: topspace_euclidean topspace_subtopology) |
|
216 |
|
217 lemma closed_closedin: "closed S \<longleftrightarrow> closedin euclidean S" |
|
218 by (simp add: closed_def closedin_def topspace_euclidean open_openin Compl_eq_Diff_UNIV) |
|
219 |
|
220 lemma open_subopen: "open S \<longleftrightarrow> (\<forall>x\<in>S. \<exists>T. open T \<and> x \<in> T \<and> T \<subseteq> S)" |
|
221 by (simp add: open_openin openin_subopen[symmetric]) |
|
222 |
|
223 subsection{* Open and closed balls. *} |
|
224 |
|
225 definition |
|
226 ball :: "'a::metric_space \<Rightarrow> real \<Rightarrow> 'a set" where |
|
227 "ball x e = {y. dist x y < e}" |
|
228 |
|
229 definition |
|
230 cball :: "'a::metric_space \<Rightarrow> real \<Rightarrow> 'a set" where |
|
231 "cball x e = {y. dist x y \<le> e}" |
|
232 |
|
233 lemma mem_ball[simp]: "y \<in> ball x e \<longleftrightarrow> dist x y < e" by (simp add: ball_def) |
|
234 lemma mem_cball[simp]: "y \<in> cball x e \<longleftrightarrow> dist x y \<le> e" by (simp add: cball_def) |
|
235 |
|
236 lemma mem_ball_0 [simp]: |
|
237 fixes x :: "'a::real_normed_vecto" |
|
238 shows "x \<in> ball 0 e \<longleftrightarrow> norm x < e" |
|
239 by (simp add: dist_norm) |
|
240 |
|
241 lemma mem_cball_0 [simp]: |
|
242 fixes x :: "'a::real_normed_vector" |
|
243 shows "x \<in> cball 0 e \<longleftrightarrow> norm x \<le> e" |
|
244 by (simp add: dist_norm) |
|
245 |
|
246 lemma centre_in_cball[simp]: "x \<in> cball x e \<longleftrightarrow> 0\<le> e" by simp |
|
247 lemma ball_subset_cball[simp,intro]: "ball x e \<subseteq> cball x e" by (simp add: subset_eq) |
|
248 lemma subset_ball[intro]: "d <= e ==> ball x d \<subseteq> ball x e" by (simp add: subset_eq) |
|
249 lemma subset_cball[intro]: "d <= e ==> cball x d \<subseteq> cball x e" by (simp add: subset_eq) |
|
250 lemma ball_max_Un: "ball a (max r s) = ball a r \<union> ball a s" |
|
251 by (simp add: expand_set_eq) arith |
|
252 |
|
253 lemma ball_min_Int: "ball a (min r s) = ball a r \<inter> ball a s" |
|
254 by (simp add: expand_set_eq) |
|
255 |
|
256 subsection{* Topological properties of open balls *} |
|
257 |
|
258 lemma diff_less_iff: "(a::real) - b > 0 \<longleftrightarrow> a > b" |
|
259 "(a::real) - b < 0 \<longleftrightarrow> a < b" |
|
260 "a - b < c \<longleftrightarrow> a < c +b" "a - b > c \<longleftrightarrow> a > c +b" by arith+ |
|
261 lemma diff_le_iff: "(a::real) - b \<ge> 0 \<longleftrightarrow> a \<ge> b" "(a::real) - b \<le> 0 \<longleftrightarrow> a \<le> b" |
|
262 "a - b \<le> c \<longleftrightarrow> a \<le> c +b" "a - b \<ge> c \<longleftrightarrow> a \<ge> c +b" by arith+ |
|
263 |
|
264 lemma open_ball[intro, simp]: "open (ball x e)" |
|
265 unfolding open_dist ball_def Collect_def Ball_def mem_def |
|
266 unfolding dist_commute |
|
267 apply clarify |
|
268 apply (rule_tac x="e - dist xa x" in exI) |
|
269 using dist_triangle_alt[where z=x] |
|
270 apply (clarsimp simp add: diff_less_iff) |
|
271 apply atomize |
|
272 apply (erule_tac x="y" in allE) |
|
273 apply (erule_tac x="xa" in allE) |
|
274 by arith |
|
275 |
|
276 lemma centre_in_ball[simp]: "x \<in> ball x e \<longleftrightarrow> e > 0" by (metis mem_ball dist_self) |
|
277 lemma open_contains_ball: "open S \<longleftrightarrow> (\<forall>x\<in>S. \<exists>e>0. ball x e \<subseteq> S)" |
|
278 unfolding open_dist subset_eq mem_ball Ball_def dist_commute .. |
|
279 |
|
280 lemma open_contains_ball_eq: "open S \<Longrightarrow> \<forall>x. x\<in>S \<longleftrightarrow> (\<exists>e>0. ball x e \<subseteq> S)" |
|
281 by (metis open_contains_ball subset_eq centre_in_ball) |
|
282 |
|
283 lemma ball_eq_empty[simp]: "ball x e = {} \<longleftrightarrow> e \<le> 0" |
|
284 unfolding mem_ball expand_set_eq |
|
285 apply (simp add: not_less) |
|
286 by (metis zero_le_dist order_trans dist_self) |
|
287 |
|
288 lemma ball_empty[intro]: "e \<le> 0 ==> ball x e = {}" by simp |
|
289 |
|
290 subsection{* Basic "localization" results are handy for connectedness. *} |
|
291 |
|
292 lemma openin_open: "openin (subtopology euclidean U) S \<longleftrightarrow> (\<exists>T. open T \<and> (S = U \<inter> T))" |
|
293 by (auto simp add: openin_subtopology open_openin[symmetric]) |
|
294 |
|
295 lemma openin_open_Int[intro]: "open S \<Longrightarrow> openin (subtopology euclidean U) (U \<inter> S)" |
|
296 by (auto simp add: openin_open) |
|
297 |
|
298 lemma open_openin_trans[trans]: |
|
299 "open S \<Longrightarrow> open T \<Longrightarrow> T \<subseteq> S \<Longrightarrow> openin (subtopology euclidean S) T" |
|
300 by (metis Int_absorb1 openin_open_Int) |
|
301 |
|
302 lemma open_subset: "S \<subseteq> T \<Longrightarrow> open S \<Longrightarrow> openin (subtopology euclidean T) S" |
|
303 by (auto simp add: openin_open) |
|
304 |
|
305 lemma closedin_closed: "closedin (subtopology euclidean U) S \<longleftrightarrow> (\<exists>T. closed T \<and> S = U \<inter> T)" |
|
306 by (simp add: closedin_subtopology closed_closedin Int_ac) |
|
307 |
|
308 lemma closedin_closed_Int: "closed S ==> closedin (subtopology euclidean U) (U \<inter> S)" |
|
309 by (metis closedin_closed) |
|
310 |
|
311 lemma closed_closedin_trans: "closed S \<Longrightarrow> closed T \<Longrightarrow> T \<subseteq> S \<Longrightarrow> closedin (subtopology euclidean S) T" |
|
312 apply (subgoal_tac "S \<inter> T = T" ) |
|
313 apply auto |
|
314 apply (frule closedin_closed_Int[of T S]) |
|
315 by simp |
|
316 |
|
317 lemma closed_subset: "S \<subseteq> T \<Longrightarrow> closed S \<Longrightarrow> closedin (subtopology euclidean T) S" |
|
318 by (auto simp add: closedin_closed) |
|
319 |
|
320 lemma openin_euclidean_subtopology_iff: |
|
321 fixes S U :: "'a::metric_space set" |
|
322 shows "openin (subtopology euclidean U) S |
|
323 \<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") |
|
324 proof- |
|
325 {assume ?lhs hence ?rhs unfolding openin_subtopology open_openin[symmetric] |
|
326 by (simp add: open_dist) blast} |
|
327 moreover |
|
328 {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" |
|
329 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)" |
|
330 by metis |
|
331 let ?T = "\<Union>{B. \<exists>x\<in>S. B = ball x (d x)}" |
|
332 have oT: "open ?T" by auto |
|
333 { fix x assume "x\<in>S" |
|
334 hence "x \<in> \<Union>{B. \<exists>x\<in>S. B = ball x (d x)}" |
|
335 apply simp apply(rule_tac x="ball x(d x)" in exI) apply auto |
|
336 by (rule d [THEN conjunct1]) |
|
337 hence "x\<in> ?T \<inter> U" using SU and `x\<in>S` by auto } |
|
338 moreover |
|
339 { fix y assume "y\<in>?T" |
|
340 then obtain B where "y\<in>B" "B\<in>{B. \<exists>x\<in>S. B = ball x (d x)}" by auto |
|
341 then obtain x where "x\<in>S" and x:"y \<in> ball x (d x)" by auto |
|
342 assume "y\<in>U" |
|
343 hence "y\<in>S" using d[OF `x\<in>S`] and x by(auto simp add: dist_commute) } |
|
344 ultimately have "S = ?T \<inter> U" by blast |
|
345 with oT have ?lhs unfolding openin_subtopology open_openin[symmetric] by blast} |
|
346 ultimately show ?thesis by blast |
|
347 qed |
|
348 |
|
349 text{* These "transitivity" results are handy too. *} |
|
350 |
|
351 lemma openin_trans[trans]: "openin (subtopology euclidean T) S \<Longrightarrow> openin (subtopology euclidean U) T |
|
352 \<Longrightarrow> openin (subtopology euclidean U) S" |
|
353 unfolding open_openin openin_open by blast |
|
354 |
|
355 lemma openin_open_trans: "openin (subtopology euclidean T) S \<Longrightarrow> open T \<Longrightarrow> open S" |
|
356 by (auto simp add: openin_open intro: openin_trans) |
|
357 |
|
358 lemma closedin_trans[trans]: |
|
359 "closedin (subtopology euclidean T) S \<Longrightarrow> |
|
360 closedin (subtopology euclidean U) T |
|
361 ==> closedin (subtopology euclidean U) S" |
|
362 by (auto simp add: closedin_closed closed_closedin closed_Inter Int_assoc) |
|
363 |
|
364 lemma closedin_closed_trans: "closedin (subtopology euclidean T) S \<Longrightarrow> closed T \<Longrightarrow> closed S" |
|
365 by (auto simp add: closedin_closed intro: closedin_trans) |
|
366 |
|
367 subsection{* Connectedness *} |
|
368 |
|
369 definition "connected S \<longleftrightarrow> |
|
370 ~(\<exists>e1 e2. open e1 \<and> open e2 \<and> S \<subseteq> (e1 \<union> e2) \<and> (e1 \<inter> e2 \<inter> S = {}) |
|
371 \<and> ~(e1 \<inter> S = {}) \<and> ~(e2 \<inter> S = {}))" |
|
372 |
|
373 lemma connected_local: |
|
374 "connected S \<longleftrightarrow> ~(\<exists>e1 e2. |
|
375 openin (subtopology euclidean S) e1 \<and> |
|
376 openin (subtopology euclidean S) e2 \<and> |
|
377 S \<subseteq> e1 \<union> e2 \<and> |
|
378 e1 \<inter> e2 = {} \<and> |
|
379 ~(e1 = {}) \<and> |
|
380 ~(e2 = {}))" |
|
381 unfolding connected_def openin_open by (safe, blast+) |
|
382 |
|
383 lemma exists_diff: "(\<exists>S. P(UNIV - S)) \<longleftrightarrow> (\<exists>S. P S)" (is "?lhs \<longleftrightarrow> ?rhs") |
|
384 proof- |
|
385 |
|
386 {assume "?lhs" hence ?rhs by blast } |
|
387 moreover |
|
388 {fix S assume H: "P S" |
|
389 have "S = UNIV - (UNIV - S)" by auto |
|
390 with H have "P (UNIV - (UNIV - S))" by metis } |
|
391 ultimately show ?thesis by metis |
|
392 qed |
|
393 |
|
394 lemma connected_clopen: "connected S \<longleftrightarrow> |
|
395 (\<forall>T. openin (subtopology euclidean S) T \<and> |
|
396 closedin (subtopology euclidean S) T \<longrightarrow> T = {} \<or> T = S)" (is "?lhs \<longleftrightarrow> ?rhs") |
|
397 proof- |
|
398 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> {})" |
|
399 unfolding connected_def openin_open closedin_closed |
|
400 apply (subst exists_diff) by blast |
|
401 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> {})" |
|
402 (is " _ \<longleftrightarrow> \<not> (\<exists>e2 e1. ?P e2 e1)") apply (simp add: closed_def Compl_eq_Diff_UNIV) by metis |
|
403 |
|
404 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'))" |
|
405 (is "_ \<longleftrightarrow> \<not> (\<exists>t' t. ?Q t' t)") |
|
406 unfolding connected_def openin_open closedin_closed by auto |
|
407 {fix e2 |
|
408 {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)" |
|
409 by auto} |
|
410 then have "(\<exists>e1. ?P e2 e1) \<longleftrightarrow> (\<exists>t. ?Q e2 t)" by metis} |
|
411 then have "\<forall>e2. (\<exists>e1. ?P e2 e1) \<longleftrightarrow> (\<exists>t. ?Q e2 t)" by blast |
|
412 then show ?thesis unfolding th0 th1 by simp |
|
413 qed |
|
414 |
|
415 lemma connected_empty[simp, intro]: "connected {}" |
|
416 by (simp add: connected_def) |
|
417 |
|
418 subsection{* Hausdorff and other separation properties *} |
|
419 |
|
420 class t0_space = |
|
421 assumes t0_space: "x \<noteq> y \<Longrightarrow> \<exists>U. open U \<and> \<not> (x \<in> U \<longleftrightarrow> y \<in> U)" |
|
422 |
|
423 class t1_space = |
|
424 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" |
|
425 begin |
|
426 |
|
427 subclass t0_space |
|
428 proof |
|
429 qed (fast dest: t1_space) |
|
430 |
|
431 end |
|
432 |
|
433 text {* T2 spaces are also known as Hausdorff spaces. *} |
|
434 |
|
435 class t2_space = |
|
436 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 = {}" |
|
437 begin |
|
438 |
|
439 subclass t1_space |
|
440 proof |
|
441 qed (fast dest: hausdorff) |
|
442 |
|
443 end |
|
444 |
|
445 instance metric_space \<subseteq> t2_space |
|
446 proof |
|
447 fix x y :: "'a::metric_space" |
|
448 assume xy: "x \<noteq> y" |
|
449 let ?U = "ball x (dist x y / 2)" |
|
450 let ?V = "ball y (dist x y / 2)" |
|
451 have th0: "\<And>d x y z. (d x z :: real) <= d x y + d y z \<Longrightarrow> d y z = d z y |
|
452 ==> ~(d x y * 2 < d x z \<and> d z y * 2 < d x z)" by arith |
|
453 have "open ?U \<and> open ?V \<and> x \<in> ?U \<and> y \<in> ?V \<and> ?U \<inter> ?V = {}" |
|
454 using dist_pos_lt[OF xy] th0[of dist,OF dist_triangle dist_commute] |
|
455 by (auto simp add: expand_set_eq) |
|
456 then show "\<exists>U V. open U \<and> open V \<and> x \<in> U \<and> y \<in> V \<and> U \<inter> V = {}" |
|
457 by blast |
|
458 qed |
|
459 |
|
460 lemma separation_t2: |
|
461 fixes x y :: "'a::t2_space" |
|
462 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 = {})" |
|
463 using hausdorff[of x y] by blast |
|
464 |
|
465 lemma separation_t1: |
|
466 fixes x y :: "'a::t1_space" |
|
467 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)" |
|
468 using t1_space[of x y] by blast |
|
469 |
|
470 lemma separation_t0: |
|
471 fixes x y :: "'a::t0_space" |
|
472 shows "x \<noteq> y \<longleftrightarrow> (\<exists>U. open U \<and> ~(x\<in>U \<longleftrightarrow> y\<in>U))" |
|
473 using t0_space[of x y] by blast |
|
474 |
|
475 subsection{* Limit points *} |
|
476 |
|
477 definition |
|
478 islimpt:: "'a::topological_space \<Rightarrow> 'a set \<Rightarrow> bool" |
|
479 (infixr "islimpt" 60) where |
|
480 "x islimpt S \<longleftrightarrow> (\<forall>T. x\<in>T \<longrightarrow> open T \<longrightarrow> (\<exists>y\<in>S. y\<in>T \<and> y\<noteq>x))" |
|
481 |
|
482 lemma islimptI: |
|
483 assumes "\<And>T. x \<in> T \<Longrightarrow> open T \<Longrightarrow> \<exists>y\<in>S. y \<in> T \<and> y \<noteq> x" |
|
484 shows "x islimpt S" |
|
485 using assms unfolding islimpt_def by auto |
|
486 |
|
487 lemma islimptE: |
|
488 assumes "x islimpt S" and "x \<in> T" and "open T" |
|
489 obtains y where "y \<in> S" and "y \<in> T" and "y \<noteq> x" |
|
490 using assms unfolding islimpt_def by auto |
|
491 |
|
492 lemma islimpt_subset: "x islimpt S \<Longrightarrow> S \<subseteq> T ==> x islimpt T" by (auto simp add: islimpt_def) |
|
493 |
|
494 lemma islimpt_approachable: |
|
495 fixes x :: "'a::metric_space" |
|
496 shows "x islimpt S \<longleftrightarrow> (\<forall>e>0. \<exists>x'\<in>S. x' \<noteq> x \<and> dist x' x < e)" |
|
497 unfolding islimpt_def |
|
498 apply auto |
|
499 apply(erule_tac x="ball x e" in allE) |
|
500 apply auto |
|
501 apply(rule_tac x=y in bexI) |
|
502 apply (auto simp add: dist_commute) |
|
503 apply (simp add: open_dist, drule (1) bspec) |
|
504 apply (clarify, drule spec, drule (1) mp, auto) |
|
505 done |
|
506 |
|
507 lemma islimpt_approachable_le: |
|
508 fixes x :: "'a::metric_space" |
|
509 shows "x islimpt S \<longleftrightarrow> (\<forall>e>0. \<exists>x'\<in> S. x' \<noteq> x \<and> dist x' x <= e)" |
|
510 unfolding islimpt_approachable |
|
511 using approachable_lt_le[where f="\<lambda>x'. dist x' x" and P="\<lambda>x'. \<not> (x'\<in>S \<and> x'\<noteq>x)"] |
|
512 by metis (* FIXME: VERY slow! *) |
|
513 |
|
514 class perfect_space = |
|
515 (* FIXME: perfect_space should inherit from topological_space *) |
|
516 assumes islimpt_UNIV [simp, intro]: "(x::'a::metric_space) islimpt UNIV" |
|
517 |
|
518 lemma perfect_choose_dist: |
|
519 fixes x :: "'a::perfect_space" |
|
520 shows "0 < r \<Longrightarrow> \<exists>a. a \<noteq> x \<and> dist a x < r" |
|
521 using islimpt_UNIV [of x] |
|
522 by (simp add: islimpt_approachable) |
|
523 |
|
524 instance real :: perfect_space |
|
525 apply default |
|
526 apply (rule islimpt_approachable [THEN iffD2]) |
|
527 apply (clarify, rule_tac x="x + e/2" in bexI) |
|
528 apply (auto simp add: dist_norm) |
|
529 done |
|
530 |
|
531 instance "^" :: (perfect_space, finite) perfect_space |
|
532 proof |
|
533 fix x :: "'a ^ 'b" |
|
534 { |
|
535 fix e :: real assume "0 < e" |
|
536 def a \<equiv> "x $ arbitrary" |
|
537 have "a islimpt UNIV" by (rule islimpt_UNIV) |
|
538 with `0 < e` obtain b where "b \<noteq> a" and "dist b a < e" |
|
539 unfolding islimpt_approachable by auto |
|
540 def y \<equiv> "Cart_lambda ((Cart_nth x)(arbitrary := b))" |
|
541 from `b \<noteq> a` have "y \<noteq> x" |
|
542 unfolding a_def y_def by (simp add: Cart_eq) |
|
543 from `dist b a < e` have "dist y x < e" |
|
544 unfolding dist_vector_def a_def y_def |
|
545 apply simp |
|
546 apply (rule le_less_trans [OF setL2_le_setsum [OF zero_le_dist]]) |
|
547 apply (subst setsum_diff1' [where a=arbitrary], simp, simp, simp) |
|
548 done |
|
549 from `y \<noteq> x` and `dist y x < e` |
|
550 have "\<exists>y\<in>UNIV. y \<noteq> x \<and> dist y x < e" by auto |
|
551 } |
|
552 then show "x islimpt UNIV" unfolding islimpt_approachable by blast |
|
553 qed |
|
554 |
|
555 lemma closed_limpt: "closed S \<longleftrightarrow> (\<forall>x. x islimpt S \<longrightarrow> x \<in> S)" |
|
556 unfolding closed_def |
|
557 apply (subst open_subopen) |
|
558 apply (simp add: islimpt_def subset_eq Compl_eq_Diff_UNIV) |
|
559 by (metis DiffE DiffI UNIV_I insertCI insert_absorb mem_def) |
|
560 |
|
561 lemma islimpt_EMPTY[simp]: "\<not> x islimpt {}" |
|
562 unfolding islimpt_def by auto |
|
563 |
|
564 lemma closed_positive_orthant: "closed {x::real^'n::finite. \<forall>i. 0 \<le>x$i}" |
|
565 proof- |
|
566 let ?U = "UNIV :: 'n set" |
|
567 let ?O = "{x::real^'n. \<forall>i. x$i\<ge>0}" |
|
568 {fix x:: "real^'n" and i::'n assume H: "\<forall>e>0. \<exists>x'\<in>?O. x' \<noteq> x \<and> dist x' x < e" |
|
569 and xi: "x$i < 0" |
|
570 from xi have th0: "-x$i > 0" by arith |
|
571 from H[rule_format, OF th0] obtain x' where x': "x' \<in>?O" "x' \<noteq> x" "dist x' x < -x $ i" by blast |
|
572 have th:" \<And>b a (x::real). abs x <= b \<Longrightarrow> b <= a ==> ~(a + x < 0)" by arith |
|
573 have th': "\<And>x (y::real). x < 0 \<Longrightarrow> 0 <= y ==> abs x <= abs (y - x)" by arith |
|
574 have th1: "\<bar>x$i\<bar> \<le> \<bar>(x' - x)$i\<bar>" using x'(1) xi |
|
575 apply (simp only: vector_component) |
|
576 by (rule th') auto |
|
577 have th2: "\<bar>dist x x'\<bar> \<ge> \<bar>(x' - x)$i\<bar>" using component_le_norm[of "x'-x" i] |
|
578 apply (simp add: dist_norm) by norm |
|
579 from th[OF th1 th2] x'(3) have False by (simp add: dist_commute) } |
|
580 then show ?thesis unfolding closed_limpt islimpt_approachable |
|
581 unfolding not_le[symmetric] by blast |
|
582 qed |
|
583 |
|
584 lemma finite_set_avoid: |
|
585 fixes a :: "'a::metric_space" |
|
586 assumes fS: "finite S" shows "\<exists>d>0. \<forall>x\<in>S. x \<noteq> a \<longrightarrow> d <= dist a x" |
|
587 proof(induct rule: finite_induct[OF fS]) |
|
588 case 1 thus ?case apply auto by ferrack |
|
589 next |
|
590 case (2 x F) |
|
591 from 2 obtain d where d: "d >0" "\<forall>x\<in>F. x\<noteq>a \<longrightarrow> d \<le> dist a x" by blast |
|
592 {assume "x = a" hence ?case using d by auto } |
|
593 moreover |
|
594 {assume xa: "x\<noteq>a" |
|
595 let ?d = "min d (dist a x)" |
|
596 have dp: "?d > 0" using xa d(1) using dist_nz by auto |
|
597 from d have d': "\<forall>x\<in>F. x\<noteq>a \<longrightarrow> ?d \<le> dist a x" by auto |
|
598 with dp xa have ?case by(auto intro!: exI[where x="?d"]) } |
|
599 ultimately show ?case by blast |
|
600 qed |
|
601 |
|
602 lemma islimpt_finite: |
|
603 fixes S :: "'a::metric_space set" |
|
604 assumes fS: "finite S" shows "\<not> a islimpt S" |
|
605 unfolding islimpt_approachable |
|
606 using finite_set_avoid[OF fS, of a] by (metis dist_commute not_le) |
|
607 |
|
608 lemma islimpt_Un: "x islimpt (S \<union> T) \<longleftrightarrow> x islimpt S \<or> x islimpt T" |
|
609 apply (rule iffI) |
|
610 defer |
|
611 apply (metis Un_upper1 Un_upper2 islimpt_subset) |
|
612 unfolding islimpt_def |
|
613 apply (rule ccontr, clarsimp, rename_tac A B) |
|
614 apply (drule_tac x="A \<inter> B" in spec) |
|
615 apply (auto simp add: open_Int) |
|
616 done |
|
617 |
|
618 lemma discrete_imp_closed: |
|
619 fixes S :: "'a::metric_space set" |
|
620 assumes e: "0 < e" and d: "\<forall>x \<in> S. \<forall>y \<in> S. dist y x < e \<longrightarrow> y = x" |
|
621 shows "closed S" |
|
622 proof- |
|
623 {fix x assume C: "\<forall>e>0. \<exists>x'\<in>S. x' \<noteq> x \<and> dist x' x < e" |
|
624 from e have e2: "e/2 > 0" by arith |
|
625 from C[rule_format, OF e2] obtain y where y: "y \<in> S" "y\<noteq>x" "dist y x < e/2" by blast |
|
626 let ?m = "min (e/2) (dist x y) " |
|
627 from e2 y(2) have mp: "?m > 0" by (simp add: dist_nz[THEN sym]) |
|
628 from C[rule_format, OF mp] obtain z where z: "z \<in> S" "z\<noteq>x" "dist z x < ?m" by blast |
|
629 have th: "dist z y < e" using z y |
|
630 by (intro dist_triangle_lt [where z=x], simp) |
|
631 from d[rule_format, OF y(1) z(1) th] y z |
|
632 have False by (auto simp add: dist_commute)} |
|
633 then show ?thesis by (metis islimpt_approachable closed_limpt [where 'a='a]) |
|
634 qed |
|
635 |
|
636 subsection{* Interior of a Set *} |
|
637 definition "interior S = {x. \<exists>T. open T \<and> x \<in> T \<and> T \<subseteq> S}" |
|
638 |
|
639 lemma interior_eq: "interior S = S \<longleftrightarrow> open S" |
|
640 apply (simp add: expand_set_eq interior_def) |
|
641 apply (subst (2) open_subopen) by (safe, blast+) |
|
642 |
|
643 lemma interior_open: "open S ==> (interior S = S)" by (metis interior_eq) |
|
644 |
|
645 lemma interior_empty[simp]: "interior {} = {}" by (simp add: interior_def) |
|
646 |
|
647 lemma open_interior[simp, intro]: "open(interior S)" |
|
648 apply (simp add: interior_def) |
|
649 apply (subst open_subopen) by blast |
|
650 |
|
651 lemma interior_interior[simp]: "interior(interior S) = interior S" by (metis interior_eq open_interior) |
|
652 lemma interior_subset: "interior S \<subseteq> S" by (auto simp add: interior_def) |
|
653 lemma subset_interior: "S \<subseteq> T ==> (interior S) \<subseteq> (interior T)" by (auto simp add: interior_def) |
|
654 lemma interior_maximal: "T \<subseteq> S \<Longrightarrow> open T ==> T \<subseteq> (interior S)" by (auto simp add: interior_def) |
|
655 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" |
|
656 by (metis equalityI interior_maximal interior_subset open_interior) |
|
657 lemma mem_interior: "x \<in> interior S \<longleftrightarrow> (\<exists>e. 0 < e \<and> ball x e \<subseteq> S)" |
|
658 apply (simp add: interior_def) |
|
659 by (metis open_contains_ball centre_in_ball open_ball subset_trans) |
|
660 |
|
661 lemma open_subset_interior: "open S ==> S \<subseteq> interior T \<longleftrightarrow> S \<subseteq> T" |
|
662 by (metis interior_maximal interior_subset subset_trans) |
|
663 |
|
664 lemma interior_inter[simp]: "interior(S \<inter> T) = interior S \<inter> interior T" |
|
665 apply (rule equalityI, simp) |
|
666 apply (metis Int_lower1 Int_lower2 subset_interior) |
|
667 by (metis Int_mono interior_subset open_Int open_interior open_subset_interior) |
|
668 |
|
669 lemma interior_limit_point [intro]: |
|
670 fixes x :: "'a::perfect_space" |
|
671 assumes x: "x \<in> interior S" shows "x islimpt S" |
|
672 proof- |
|
673 from x obtain e where e: "e>0" "\<forall>x'. dist x x' < e \<longrightarrow> x' \<in> S" |
|
674 unfolding mem_interior subset_eq Ball_def mem_ball by blast |
|
675 { |
|
676 fix d::real assume d: "d>0" |
|
677 let ?m = "min d e" |
|
678 have mde2: "0 < ?m" using e(1) d(1) by simp |
|
679 from perfect_choose_dist [OF mde2, of x] |
|
680 obtain y where "y \<noteq> x" and "dist y x < ?m" by blast |
|
681 then have "dist y x < e" "dist y x < d" by simp_all |
|
682 from `dist y x < e` e(2) have "y \<in> S" by (simp add: dist_commute) |
|
683 have "\<exists>x'\<in>S. x'\<noteq> x \<and> dist x' x < d" |
|
684 using `y \<in> S` `y \<noteq> x` `dist y x < d` by fast |
|
685 } |
|
686 then show ?thesis unfolding islimpt_approachable by blast |
|
687 qed |
|
688 |
|
689 lemma interior_closed_Un_empty_interior: |
|
690 assumes cS: "closed S" and iT: "interior T = {}" |
|
691 shows "interior(S \<union> T) = interior S" |
|
692 proof |
|
693 show "interior S \<subseteq> interior (S\<union>T)" |
|
694 by (rule subset_interior, blast) |
|
695 next |
|
696 show "interior (S \<union> T) \<subseteq> interior S" |
|
697 proof |
|
698 fix x assume "x \<in> interior (S \<union> T)" |
|
699 then obtain R where "open R" "x \<in> R" "R \<subseteq> S \<union> T" |
|
700 unfolding interior_def by fast |
|
701 show "x \<in> interior S" |
|
702 proof (rule ccontr) |
|
703 assume "x \<notin> interior S" |
|
704 with `x \<in> R` `open R` obtain y where "y \<in> R - S" |
|
705 unfolding interior_def expand_set_eq by fast |
|
706 from `open R` `closed S` have "open (R - S)" by (rule open_Diff) |
|
707 from `R \<subseteq> S \<union> T` have "R - S \<subseteq> T" by fast |
|
708 from `y \<in> R - S` `open (R - S)` `R - S \<subseteq> T` `interior T = {}` |
|
709 show "False" unfolding interior_def by fast |
|
710 qed |
|
711 qed |
|
712 qed |
|
713 |
|
714 |
|
715 subsection{* Closure of a Set *} |
|
716 |
|
717 definition "closure S = S \<union> {x | x. x islimpt S}" |
|
718 |
|
719 lemma closure_interior: "closure S = UNIV - interior (UNIV - S)" |
|
720 proof- |
|
721 { fix x |
|
722 have "x\<in>UNIV - interior (UNIV - S) \<longleftrightarrow> x \<in> closure S" (is "?lhs = ?rhs") |
|
723 proof |
|
724 let ?exT = "\<lambda> y. (\<exists>T. open T \<and> y \<in> T \<and> T \<subseteq> UNIV - S)" |
|
725 assume "?lhs" |
|
726 hence *:"\<not> ?exT x" |
|
727 unfolding interior_def |
|
728 by simp |
|
729 { assume "\<not> ?rhs" |
|
730 hence False using * |
|
731 unfolding closure_def islimpt_def |
|
732 by blast |
|
733 } |
|
734 thus "?rhs" |
|
735 by blast |
|
736 next |
|
737 assume "?rhs" thus "?lhs" |
|
738 unfolding closure_def interior_def islimpt_def |
|
739 by blast |
|
740 qed |
|
741 } |
|
742 thus ?thesis |
|
743 by blast |
|
744 qed |
|
745 |
|
746 lemma interior_closure: "interior S = UNIV - (closure (UNIV - S))" |
|
747 proof- |
|
748 { fix x |
|
749 have "x \<in> interior S \<longleftrightarrow> x \<in> UNIV - (closure (UNIV - S))" |
|
750 unfolding interior_def closure_def islimpt_def |
|
751 by blast (* FIXME: VERY slow! *) |
|
752 } |
|
753 thus ?thesis |
|
754 by blast |
|
755 qed |
|
756 |
|
757 lemma closed_closure[simp, intro]: "closed (closure S)" |
|
758 proof- |
|
759 have "closed (UNIV - interior (UNIV -S))" by blast |
|
760 thus ?thesis using closure_interior[of S] by simp |
|
761 qed |
|
762 |
|
763 lemma closure_hull: "closure S = closed hull S" |
|
764 proof- |
|
765 have "S \<subseteq> closure S" |
|
766 unfolding closure_def |
|
767 by blast |
|
768 moreover |
|
769 have "closed (closure S)" |
|
770 using closed_closure[of S] |
|
771 by assumption |
|
772 moreover |
|
773 { fix t |
|
774 assume *:"S \<subseteq> t" "closed t" |
|
775 { fix x |
|
776 assume "x islimpt S" |
|
777 hence "x islimpt t" using *(1) |
|
778 using islimpt_subset[of x, of S, of t] |
|
779 by blast |
|
780 } |
|
781 with * have "closure S \<subseteq> t" |
|
782 unfolding closure_def |
|
783 using closed_limpt[of t] |
|
784 by auto |
|
785 } |
|
786 ultimately show ?thesis |
|
787 using hull_unique[of S, of "closure S", of closed] |
|
788 unfolding mem_def |
|
789 by simp |
|
790 qed |
|
791 |
|
792 lemma closure_eq: "closure S = S \<longleftrightarrow> closed S" |
|
793 unfolding closure_hull |
|
794 using hull_eq[of closed, unfolded mem_def, OF closed_Inter, of S] |
|
795 by (metis mem_def subset_eq) |
|
796 |
|
797 lemma closure_closed[simp]: "closed S \<Longrightarrow> closure S = S" |
|
798 using closure_eq[of S] |
|
799 by simp |
|
800 |
|
801 lemma closure_closure[simp]: "closure (closure S) = closure S" |
|
802 unfolding closure_hull |
|
803 using hull_hull[of closed S] |
|
804 by assumption |
|
805 |
|
806 lemma closure_subset: "S \<subseteq> closure S" |
|
807 unfolding closure_hull |
|
808 using hull_subset[of S closed] |
|
809 by assumption |
|
810 |
|
811 lemma subset_closure: "S \<subseteq> T \<Longrightarrow> closure S \<subseteq> closure T" |
|
812 unfolding closure_hull |
|
813 using hull_mono[of S T closed] |
|
814 by assumption |
|
815 |
|
816 lemma closure_minimal: "S \<subseteq> T \<Longrightarrow> closed T \<Longrightarrow> closure S \<subseteq> T" |
|
817 using hull_minimal[of S T closed] |
|
818 unfolding closure_hull mem_def |
|
819 by simp |
|
820 |
|
821 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" |
|
822 using hull_unique[of S T closed] |
|
823 unfolding closure_hull mem_def |
|
824 by simp |
|
825 |
|
826 lemma closure_empty[simp]: "closure {} = {}" |
|
827 using closed_empty closure_closed[of "{}"] |
|
828 by simp |
|
829 |
|
830 lemma closure_univ[simp]: "closure UNIV = UNIV" |
|
831 using closure_closed[of UNIV] |
|
832 by simp |
|
833 |
|
834 lemma closure_eq_empty: "closure S = {} \<longleftrightarrow> S = {}" |
|
835 using closure_empty closure_subset[of S] |
|
836 by blast |
|
837 |
|
838 lemma closure_subset_eq: "closure S \<subseteq> S \<longleftrightarrow> closed S" |
|
839 using closure_eq[of S] closure_subset[of S] |
|
840 by simp |
|
841 |
|
842 lemma open_inter_closure_eq_empty: |
|
843 "open S \<Longrightarrow> (S \<inter> closure T) = {} \<longleftrightarrow> S \<inter> T = {}" |
|
844 using open_subset_interior[of S "UNIV - T"] |
|
845 using interior_subset[of "UNIV - T"] |
|
846 unfolding closure_interior |
|
847 by auto |
|
848 |
|
849 lemma open_inter_closure_subset: |
|
850 "open S \<Longrightarrow> (S \<inter> (closure T)) \<subseteq> closure(S \<inter> T)" |
|
851 proof |
|
852 fix x |
|
853 assume as: "open S" "x \<in> S \<inter> closure T" |
|
854 { assume *:"x islimpt T" |
|
855 have "x islimpt (S \<inter> T)" |
|
856 proof (rule islimptI) |
|
857 fix A |
|
858 assume "x \<in> A" "open A" |
|
859 with as have "x \<in> A \<inter> S" "open (A \<inter> S)" |
|
860 by (simp_all add: open_Int) |
|
861 with * obtain y where "y \<in> T" "y \<in> A \<inter> S" "y \<noteq> x" |
|
862 by (rule islimptE) |
|
863 hence "y \<in> S \<inter> T" "y \<in> A \<and> y \<noteq> x" |
|
864 by simp_all |
|
865 thus "\<exists>y\<in>(S \<inter> T). y \<in> A \<and> y \<noteq> x" .. |
|
866 qed |
|
867 } |
|
868 then show "x \<in> closure (S \<inter> T)" using as |
|
869 unfolding closure_def |
|
870 by blast |
|
871 qed |
|
872 |
|
873 lemma closure_complement: "closure(UNIV - S) = UNIV - interior(S)" |
|
874 proof- |
|
875 have "S = UNIV - (UNIV - S)" |
|
876 by auto |
|
877 thus ?thesis |
|
878 unfolding closure_interior |
|
879 by auto |
|
880 qed |
|
881 |
|
882 lemma interior_complement: "interior(UNIV - S) = UNIV - closure(S)" |
|
883 unfolding closure_interior |
|
884 by blast |
|
885 |
|
886 subsection{* Frontier (aka boundary) *} |
|
887 |
|
888 definition "frontier S = closure S - interior S" |
|
889 |
|
890 lemma frontier_closed: "closed(frontier S)" |
|
891 by (simp add: frontier_def closed_Diff) |
|
892 |
|
893 lemma frontier_closures: "frontier S = (closure S) \<inter> (closure(UNIV - S))" |
|
894 by (auto simp add: frontier_def interior_closure) |
|
895 |
|
896 lemma frontier_straddle: |
|
897 fixes a :: "'a::metric_space" |
|
898 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") |
|
899 proof |
|
900 assume "?lhs" |
|
901 { fix e::real |
|
902 assume "e > 0" |
|
903 let ?rhse = "(\<exists>x\<in>S. dist a x < e) \<and> (\<exists>x. x \<notin> S \<and> dist a x < e)" |
|
904 { assume "a\<in>S" |
|
905 have "\<exists>x\<in>S. dist a x < e" using `e>0` `a\<in>S` by(rule_tac x=a in bexI) auto |
|
906 moreover have "\<exists>x. x \<notin> S \<and> dist a x < e" using `?lhs` `a\<in>S` |
|
907 unfolding frontier_closures closure_def islimpt_def using `e>0` |
|
908 by (auto, erule_tac x="ball a e" in allE, auto) |
|
909 ultimately have ?rhse by auto |
|
910 } |
|
911 moreover |
|
912 { assume "a\<notin>S" |
|
913 hence ?rhse using `?lhs` |
|
914 unfolding frontier_closures closure_def islimpt_def |
|
915 using open_ball[of a e] `e > 0` |
|
916 by (auto, erule_tac x = "ball a e" in allE, auto) (* FIXME: VERY slow! *) |
|
917 } |
|
918 ultimately have ?rhse by auto |
|
919 } |
|
920 thus ?rhs by auto |
|
921 next |
|
922 assume ?rhs |
|
923 moreover |
|
924 { fix T assume "a\<notin>S" and |
|
925 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" |
|
926 from `open T` `a \<in> T` have "\<exists>e>0. ball a e \<subseteq> T" unfolding open_contains_ball[of T] by auto |
|
927 then obtain e where "e>0" "ball a e \<subseteq> T" by auto |
|
928 then obtain y where y:"y\<in>S" "dist a y < e" using as(1) by auto |
|
929 have "\<exists>y\<in>S. y \<in> T \<and> y \<noteq> a" |
|
930 using `dist a y < e` `ball a e \<subseteq> T` unfolding ball_def using `y\<in>S` `a\<notin>S` by auto |
|
931 } |
|
932 hence "a \<in> closure S" unfolding closure_def islimpt_def using `?rhs` by auto |
|
933 moreover |
|
934 { fix T assume "a \<in> T" "open T" "a\<in>S" |
|
935 then obtain e where "e>0" and balle: "ball a e \<subseteq> T" unfolding open_contains_ball using `?rhs` by auto |
|
936 obtain x where "x \<notin> S" "dist a x < e" using `?rhs` using `e>0` by auto |
|
937 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 |
|
938 } |
|
939 hence "a islimpt (UNIV - S) \<or> a\<notin>S" unfolding islimpt_def by auto |
|
940 ultimately show ?lhs unfolding frontier_closures using closure_def[of "UNIV - S"] by auto |
|
941 qed |
|
942 |
|
943 lemma frontier_subset_closed: "closed S \<Longrightarrow> frontier S \<subseteq> S" |
|
944 by (metis frontier_def closure_closed Diff_subset) |
|
945 |
|
946 lemma frontier_empty: "frontier {} = {}" |
|
947 by (simp add: frontier_def closure_empty) |
|
948 |
|
949 lemma frontier_subset_eq: "frontier S \<subseteq> S \<longleftrightarrow> closed S" |
|
950 proof- |
|
951 { assume "frontier S \<subseteq> S" |
|
952 hence "closure S \<subseteq> S" using interior_subset unfolding frontier_def by auto |
|
953 hence "closed S" using closure_subset_eq by auto |
|
954 } |
|
955 thus ?thesis using frontier_subset_closed[of S] by auto |
|
956 qed |
|
957 |
|
958 lemma frontier_complement: "frontier(UNIV - S) = frontier S" |
|
959 by (auto simp add: frontier_def closure_complement interior_complement) |
|
960 |
|
961 lemma frontier_disjoint_eq: "frontier S \<inter> S = {} \<longleftrightarrow> open S" |
|
962 using frontier_complement frontier_subset_eq[of "UNIV - S"] |
|
963 unfolding open_closed Compl_eq_Diff_UNIV by auto |
|
964 |
|
965 subsection{* Common nets and The "within" modifier for nets. *} |
|
966 |
|
967 definition |
|
968 at_infinity :: "'a::real_normed_vector net" where |
|
969 "at_infinity = Abs_net (range (\<lambda>r. {x. r \<le> norm x}))" |
|
970 |
|
971 definition |
|
972 indirection :: "'a::real_normed_vector \<Rightarrow> 'a \<Rightarrow> 'a net" (infixr "indirection" 70) where |
|
973 "a indirection v = (at a) within {b. \<exists>c\<ge>0. b - a = scaleR c v}" |
|
974 |
|
975 text{* Prove That They are all nets. *} |
|
976 |
|
977 lemma Rep_net_at_infinity: |
|
978 "Rep_net at_infinity = range (\<lambda>r. {x. r \<le> norm x})" |
|
979 unfolding at_infinity_def |
|
980 apply (rule Abs_net_inverse') |
|
981 apply (rule image_nonempty, simp) |
|
982 apply (clarsimp, rename_tac r s) |
|
983 apply (rule_tac x="max r s" in exI, auto) |
|
984 done |
|
985 |
|
986 lemma within_UNIV: "net within UNIV = net" |
|
987 by (simp add: Rep_net_inject [symmetric] Rep_net_within) |
|
988 |
|
989 subsection{* Identify Trivial limits, where we can't approach arbitrarily closely. *} |
|
990 |
|
991 definition |
|
992 trivial_limit :: "'a net \<Rightarrow> bool" where |
|
993 "trivial_limit net \<longleftrightarrow> {} \<in> Rep_net net" |
|
994 |
|
995 lemma trivial_limit_within: |
|
996 shows "trivial_limit (at a within S) \<longleftrightarrow> \<not> a islimpt S" |
|
997 proof |
|
998 assume "trivial_limit (at a within S)" |
|
999 thus "\<not> a islimpt S" |
|
1000 unfolding trivial_limit_def |
|
1001 unfolding Rep_net_within Rep_net_at |
|
1002 unfolding islimpt_def |
|
1003 apply (clarsimp simp add: expand_set_eq) |
|
1004 apply (rename_tac T, rule_tac x=T in exI) |
|
1005 apply (clarsimp, drule_tac x=y in spec, simp) |
|
1006 done |
|
1007 next |
|
1008 assume "\<not> a islimpt S" |
|
1009 thus "trivial_limit (at a within S)" |
|
1010 unfolding trivial_limit_def |
|
1011 unfolding Rep_net_within Rep_net_at |
|
1012 unfolding islimpt_def |
|
1013 apply (clarsimp simp add: image_image) |
|
1014 apply (rule_tac x=T in image_eqI) |
|
1015 apply (auto simp add: expand_set_eq) |
|
1016 done |
|
1017 qed |
|
1018 |
|
1019 lemma trivial_limit_at_iff: "trivial_limit (at a) \<longleftrightarrow> \<not> a islimpt UNIV" |
|
1020 using trivial_limit_within [of a UNIV] |
|
1021 by (simp add: within_UNIV) |
|
1022 |
|
1023 lemma trivial_limit_at: |
|
1024 fixes a :: "'a::perfect_space" |
|
1025 shows "\<not> trivial_limit (at a)" |
|
1026 by (simp add: trivial_limit_at_iff) |
|
1027 |
|
1028 lemma trivial_limit_at_infinity: |
|
1029 "\<not> trivial_limit (at_infinity :: ('a::{real_normed_vector,zero_neq_one}) net)" |
|
1030 (* FIXME: find a more appropriate type class *) |
|
1031 unfolding trivial_limit_def Rep_net_at_infinity |
|
1032 apply (clarsimp simp add: expand_set_eq) |
|
1033 apply (drule_tac x="scaleR r (sgn 1)" in spec) |
|
1034 apply (simp add: norm_sgn) |
|
1035 done |
|
1036 |
|
1037 lemma trivial_limit_sequentially: "\<not> trivial_limit sequentially" |
|
1038 by (auto simp add: trivial_limit_def Rep_net_sequentially) |
|
1039 |
|
1040 subsection{* Some property holds "sufficiently close" to the limit point. *} |
|
1041 |
|
1042 lemma eventually_at: (* FIXME: this replaces Limits.eventually_at *) |
|
1043 "eventually P (at a) \<longleftrightarrow> (\<exists>d>0. \<forall>x. 0 < dist x a \<and> dist x a < d \<longrightarrow> P x)" |
|
1044 unfolding eventually_at dist_nz by auto |
|
1045 |
|
1046 lemma eventually_at_infinity: |
|
1047 "eventually P at_infinity \<longleftrightarrow> (\<exists>b. \<forall>x. norm x >= b \<longrightarrow> P x)" |
|
1048 unfolding eventually_def Rep_net_at_infinity by auto |
|
1049 |
|
1050 lemma eventually_within: "eventually P (at a within S) \<longleftrightarrow> |
|
1051 (\<exists>d>0. \<forall>x\<in>S. 0 < dist x a \<and> dist x a < d \<longrightarrow> P x)" |
|
1052 unfolding eventually_within eventually_at dist_nz by auto |
|
1053 |
|
1054 lemma eventually_within_le: "eventually P (at a within S) \<longleftrightarrow> |
|
1055 (\<exists>d>0. \<forall>x\<in>S. 0 < dist x a \<and> dist x a <= d \<longrightarrow> P x)" (is "?lhs = ?rhs") |
|
1056 unfolding eventually_within |
|
1057 apply safe |
|
1058 apply (rule_tac x="d/2" in exI, simp) |
|
1059 apply (rule_tac x="d" in exI, simp) |
|
1060 done |
|
1061 |
|
1062 lemma eventually_happens: "eventually P net ==> trivial_limit net \<or> (\<exists>x. P x)" |
|
1063 unfolding eventually_def trivial_limit_def |
|
1064 using Rep_net_nonempty [of net] by auto |
|
1065 |
|
1066 lemma always_eventually: "(\<forall>x. P x) ==> eventually P net" |
|
1067 unfolding eventually_def trivial_limit_def |
|
1068 using Rep_net_nonempty [of net] by auto |
|
1069 |
|
1070 lemma trivial_limit_eventually: "trivial_limit net \<Longrightarrow> eventually P net" |
|
1071 unfolding trivial_limit_def eventually_def by auto |
|
1072 |
|
1073 lemma eventually_False: "eventually (\<lambda>x. False) net \<longleftrightarrow> trivial_limit net" |
|
1074 unfolding trivial_limit_def eventually_def by auto |
|
1075 |
|
1076 lemma trivial_limit_eq: "trivial_limit net \<longleftrightarrow> (\<forall>P. eventually P net)" |
|
1077 apply (safe elim!: trivial_limit_eventually) |
|
1078 apply (simp add: eventually_False [symmetric]) |
|
1079 done |
|
1080 |
|
1081 text{* Combining theorems for "eventually" *} |
|
1082 |
|
1083 lemma eventually_conjI: |
|
1084 "\<lbrakk>eventually (\<lambda>x. P x) net; eventually (\<lambda>x. Q x) net\<rbrakk> |
|
1085 \<Longrightarrow> eventually (\<lambda>x. P x \<and> Q x) net" |
|
1086 by (rule eventually_conj) |
|
1087 |
|
1088 lemma eventually_rev_mono: |
|
1089 "eventually P net \<Longrightarrow> (\<forall>x. P x \<longrightarrow> Q x) \<Longrightarrow> eventually Q net" |
|
1090 using eventually_mono [of P Q] by fast |
|
1091 |
|
1092 lemma eventually_and: " eventually (\<lambda>x. P x \<and> Q x) net \<longleftrightarrow> eventually P net \<and> eventually Q net" |
|
1093 by (auto intro!: eventually_conjI elim: eventually_rev_mono) |
|
1094 |
|
1095 lemma eventually_false: "eventually (\<lambda>x. False) net \<longleftrightarrow> trivial_limit net" |
|
1096 by (auto simp add: eventually_False) |
|
1097 |
|
1098 lemma not_eventually: "(\<forall>x. \<not> P x ) \<Longrightarrow> ~(trivial_limit net) ==> ~(eventually (\<lambda>x. P x) net)" |
|
1099 by (simp add: eventually_False) |
|
1100 |
|
1101 subsection{* Limits, defined as vacuously true when the limit is trivial. *} |
|
1102 |
|
1103 text{* Notation Lim to avoid collition with lim defined in analysis *} |
|
1104 definition |
|
1105 Lim :: "'a net \<Rightarrow> ('a \<Rightarrow> 'b::t2_space) \<Rightarrow> 'b" where |
|
1106 "Lim net f = (THE l. (f ---> l) net)" |
|
1107 |
|
1108 lemma Lim: |
|
1109 "(f ---> l) net \<longleftrightarrow> |
|
1110 trivial_limit net \<or> |
|
1111 (\<forall>e>0. eventually (\<lambda>x. dist (f x) l < e) net)" |
|
1112 unfolding tendsto_iff trivial_limit_eq by auto |
|
1113 |
|
1114 |
|
1115 text{* Show that they yield usual definitions in the various cases. *} |
|
1116 |
|
1117 lemma Lim_within_le: "(f ---> l)(at a within S) \<longleftrightarrow> |
|
1118 (\<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)" |
|
1119 by (auto simp add: tendsto_iff eventually_within_le) |
|
1120 |
|
1121 lemma Lim_within: "(f ---> l) (at a within S) \<longleftrightarrow> |
|
1122 (\<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)" |
|
1123 by (auto simp add: tendsto_iff eventually_within) |
|
1124 |
|
1125 lemma Lim_at: "(f ---> l) (at a) \<longleftrightarrow> |
|
1126 (\<forall>e >0. \<exists>d>0. \<forall>x. 0 < dist x a \<and> dist x a < d \<longrightarrow> dist (f x) l < e)" |
|
1127 by (auto simp add: tendsto_iff eventually_at) |
|
1128 |
|
1129 lemma Lim_at_iff_LIM: "(f ---> l) (at a) \<longleftrightarrow> f -- a --> l" |
|
1130 unfolding Lim_at LIM_def by (simp only: zero_less_dist_iff) |
|
1131 |
|
1132 lemma Lim_at_infinity: |
|
1133 "(f ---> l) at_infinity \<longleftrightarrow> (\<forall>e>0. \<exists>b. \<forall>x. norm x >= b \<longrightarrow> dist (f x) l < e)" |
|
1134 by (auto simp add: tendsto_iff eventually_at_infinity) |
|
1135 |
|
1136 lemma Lim_sequentially: |
|
1137 "(S ---> l) sequentially \<longleftrightarrow> |
|
1138 (\<forall>e>0. \<exists>N. \<forall>n\<ge>N. dist (S n) l < e)" |
|
1139 by (auto simp add: tendsto_iff eventually_sequentially) |
|
1140 |
|
1141 lemma Lim_sequentially_iff_LIMSEQ: "(S ---> l) sequentially \<longleftrightarrow> S ----> l" |
|
1142 unfolding Lim_sequentially LIMSEQ_def .. |
|
1143 |
|
1144 lemma Lim_eventually: "eventually (\<lambda>x. f x = l) net \<Longrightarrow> (f ---> l) net" |
|
1145 by (rule topological_tendstoI, auto elim: eventually_rev_mono) |
|
1146 |
|
1147 text{* The expected monotonicity property. *} |
|
1148 |
|
1149 lemma Lim_within_empty: "(f ---> l) (net within {})" |
|
1150 unfolding tendsto_def Limits.eventually_within by simp |
|
1151 |
|
1152 lemma Lim_within_subset: "(f ---> l) (net within S) \<Longrightarrow> T \<subseteq> S \<Longrightarrow> (f ---> l) (net within T)" |
|
1153 unfolding tendsto_def Limits.eventually_within |
|
1154 by (auto elim!: eventually_elim1) |
|
1155 |
|
1156 lemma Lim_Un: assumes "(f ---> l) (net within S)" "(f ---> l) (net within T)" |
|
1157 shows "(f ---> l) (net within (S \<union> T))" |
|
1158 using assms unfolding tendsto_def Limits.eventually_within |
|
1159 apply clarify |
|
1160 apply (drule spec, drule (1) mp, drule (1) mp) |
|
1161 apply (drule spec, drule (1) mp, drule (1) mp) |
|
1162 apply (auto elim: eventually_elim2) |
|
1163 done |
|
1164 |
|
1165 lemma Lim_Un_univ: |
|
1166 "(f ---> l) (net within S) \<Longrightarrow> (f ---> l) (net within T) \<Longrightarrow> S \<union> T = UNIV |
|
1167 ==> (f ---> l) net" |
|
1168 by (metis Lim_Un within_UNIV) |
|
1169 |
|
1170 text{* Interrelations between restricted and unrestricted limits. *} |
|
1171 |
|
1172 lemma Lim_at_within: "(f ---> l) net ==> (f ---> l)(net within S)" |
|
1173 (* FIXME: rename *) |
|
1174 unfolding tendsto_def Limits.eventually_within |
|
1175 apply (clarify, drule spec, drule (1) mp, drule (1) mp) |
|
1176 by (auto elim!: eventually_elim1) |
|
1177 |
|
1178 lemma Lim_within_open: |
|
1179 fixes f :: "'a::topological_space \<Rightarrow> 'b::topological_space" |
|
1180 assumes"a \<in> S" "open S" |
|
1181 shows "(f ---> l)(at a within S) \<longleftrightarrow> (f ---> l)(at a)" (is "?lhs \<longleftrightarrow> ?rhs") |
|
1182 proof |
|
1183 assume ?lhs |
|
1184 { fix A assume "open A" "l \<in> A" |
|
1185 with `?lhs` have "eventually (\<lambda>x. f x \<in> A) (at a within S)" |
|
1186 by (rule topological_tendstoD) |
|
1187 hence "eventually (\<lambda>x. x \<in> S \<longrightarrow> f x \<in> A) (at a)" |
|
1188 unfolding Limits.eventually_within . |
|
1189 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" |
|
1190 unfolding eventually_at_topological by fast |
|
1191 hence "open (T \<inter> S)" "a \<in> T \<inter> S" "\<forall>x\<in>(T \<inter> S). x \<noteq> a \<longrightarrow> f x \<in> A" |
|
1192 using assms by auto |
|
1193 hence "\<exists>T. open T \<and> a \<in> T \<and> (\<forall>x\<in>T. x \<noteq> a \<longrightarrow> f x \<in> A)" |
|
1194 by fast |
|
1195 hence "eventually (\<lambda>x. f x \<in> A) (at a)" |
|
1196 unfolding eventually_at_topological . |
|
1197 } |
|
1198 thus ?rhs by (rule topological_tendstoI) |
|
1199 next |
|
1200 assume ?rhs |
|
1201 thus ?lhs by (rule Lim_at_within) |
|
1202 qed |
|
1203 |
|
1204 text{* Another limit point characterization. *} |
|
1205 |
|
1206 lemma islimpt_sequential: |
|
1207 fixes x :: "'a::metric_space" (* FIXME: generalize to topological_space *) |
|
1208 shows "x islimpt S \<longleftrightarrow> (\<exists>f. (\<forall>n::nat. f n \<in> S -{x}) \<and> (f ---> x) sequentially)" |
|
1209 (is "?lhs = ?rhs") |
|
1210 proof |
|
1211 assume ?lhs |
|
1212 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" |
|
1213 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 |
|
1214 { fix n::nat |
|
1215 have "f (inverse (real n + 1)) \<in> S - {x}" using f by auto |
|
1216 } |
|
1217 moreover |
|
1218 { fix e::real assume "e>0" |
|
1219 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 |
|
1220 then obtain N::nat where "inverse (real (N + 1)) < e" by auto |
|
1221 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) |
|
1222 moreover have "\<forall>n\<ge>N. dist (f (inverse (real n + 1))) x < (inverse (real n + 1))" using f `e>0` by auto |
|
1223 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 |
|
1224 } |
|
1225 hence " ((\<lambda>n. f (inverse (real n + 1))) ---> x) sequentially" |
|
1226 unfolding Lim_sequentially using f by auto |
|
1227 ultimately show ?rhs apply (rule_tac x="(\<lambda>n::nat. f (inverse (real n + 1)))" in exI) by auto |
|
1228 next |
|
1229 assume ?rhs |
|
1230 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 |
|
1231 { fix e::real assume "e>0" |
|
1232 then obtain N where "dist (f N) x < e" using f(2) by auto |
|
1233 moreover have "f N\<in>S" "f N \<noteq> x" using f(1) by auto |
|
1234 ultimately have "\<exists>x'\<in>S. x' \<noteq> x \<and> dist x' x < e" by auto |
|
1235 } |
|
1236 thus ?lhs unfolding islimpt_approachable by auto |
|
1237 qed |
|
1238 |
|
1239 text{* Basic arithmetical combining theorems for limits. *} |
|
1240 |
|
1241 lemma Lim_linear: |
|
1242 assumes "(f ---> l) net" "bounded_linear h" |
|
1243 shows "((\<lambda>x. h (f x)) ---> h l) net" |
|
1244 using `bounded_linear h` `(f ---> l) net` |
|
1245 by (rule bounded_linear.tendsto) |
|
1246 |
|
1247 lemma Lim_ident_at: "((\<lambda>x. x) ---> a) (at a)" |
|
1248 unfolding tendsto_def Limits.eventually_at_topological by fast |
|
1249 |
|
1250 lemma Lim_const: "((\<lambda>x. a) ---> a) net" |
|
1251 by (rule tendsto_const) |
|
1252 |
|
1253 lemma Lim_cmul: |
|
1254 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1255 shows "(f ---> l) net ==> ((\<lambda>x. c *\<^sub>R f x) ---> c *\<^sub>R l) net" |
|
1256 by (intro tendsto_intros) |
|
1257 |
|
1258 lemma Lim_neg: |
|
1259 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1260 shows "(f ---> l) net ==> ((\<lambda>x. -(f x)) ---> -l) net" |
|
1261 by (rule tendsto_minus) |
|
1262 |
|
1263 lemma Lim_add: fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" shows |
|
1264 "(f ---> l) net \<Longrightarrow> (g ---> m) net \<Longrightarrow> ((\<lambda>x. f(x) + g(x)) ---> l + m) net" |
|
1265 by (rule tendsto_add) |
|
1266 |
|
1267 lemma Lim_sub: |
|
1268 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1269 shows "(f ---> l) net \<Longrightarrow> (g ---> m) net \<Longrightarrow> ((\<lambda>x. f(x) - g(x)) ---> l - m) net" |
|
1270 by (rule tendsto_diff) |
|
1271 |
|
1272 lemma Lim_null: |
|
1273 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1274 shows "(f ---> l) net \<longleftrightarrow> ((\<lambda>x. f(x) - l) ---> 0) net" by (simp add: Lim dist_norm) |
|
1275 |
|
1276 lemma Lim_null_norm: |
|
1277 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1278 shows "(f ---> 0) net \<longleftrightarrow> ((\<lambda>x. norm(f x)) ---> 0) net" |
|
1279 by (simp add: Lim dist_norm) |
|
1280 |
|
1281 lemma Lim_null_comparison: |
|
1282 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1283 assumes "eventually (\<lambda>x. norm (f x) \<le> g x) net" "(g ---> 0) net" |
|
1284 shows "(f ---> 0) net" |
|
1285 proof(simp add: tendsto_iff, rule+) |
|
1286 fix e::real assume "0<e" |
|
1287 { fix x |
|
1288 assume "norm (f x) \<le> g x" "dist (g x) 0 < e" |
|
1289 hence "dist (f x) 0 < e" by (simp add: dist_norm) |
|
1290 } |
|
1291 thus "eventually (\<lambda>x. dist (f x) 0 < e) net" |
|
1292 using eventually_and[of "\<lambda>x. norm(f x) <= g x" "\<lambda>x. dist (g x) 0 < e" net] |
|
1293 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] |
|
1294 using assms `e>0` unfolding tendsto_iff by auto |
|
1295 qed |
|
1296 |
|
1297 lemma Lim_component: |
|
1298 fixes f :: "'a \<Rightarrow> 'b::metric_space ^ 'n::finite" |
|
1299 shows "(f ---> l) net \<Longrightarrow> ((\<lambda>a. f a $i) ---> l$i) net" |
|
1300 unfolding tendsto_iff |
|
1301 apply (clarify) |
|
1302 apply (drule spec, drule (1) mp) |
|
1303 apply (erule eventually_elim1) |
|
1304 apply (erule le_less_trans [OF dist_nth_le]) |
|
1305 done |
|
1306 |
|
1307 lemma Lim_transform_bound: |
|
1308 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1309 fixes g :: "'a \<Rightarrow> 'c::real_normed_vector" |
|
1310 assumes "eventually (\<lambda>n. norm(f n) <= norm(g n)) net" "(g ---> 0) net" |
|
1311 shows "(f ---> 0) net" |
|
1312 proof (rule tendstoI) |
|
1313 fix e::real assume "e>0" |
|
1314 { fix x |
|
1315 assume "norm (f x) \<le> norm (g x)" "dist (g x) 0 < e" |
|
1316 hence "dist (f x) 0 < e" by (simp add: dist_norm)} |
|
1317 thus "eventually (\<lambda>x. dist (f x) 0 < e) net" |
|
1318 using eventually_and[of "\<lambda>x. norm (f x) \<le> norm (g x)" "\<lambda>x. dist (g x) 0 < e" net] |
|
1319 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] |
|
1320 using assms `e>0` unfolding tendsto_iff by blast |
|
1321 qed |
|
1322 |
|
1323 text{* Deducing things about the limit from the elements. *} |
|
1324 |
|
1325 lemma Lim_in_closed_set: |
|
1326 assumes "closed S" "eventually (\<lambda>x. f(x) \<in> S) net" "\<not>(trivial_limit net)" "(f ---> l) net" |
|
1327 shows "l \<in> S" |
|
1328 proof (rule ccontr) |
|
1329 assume "l \<notin> S" |
|
1330 with `closed S` have "open (- S)" "l \<in> - S" |
|
1331 by (simp_all add: open_Compl) |
|
1332 with assms(4) have "eventually (\<lambda>x. f x \<in> - S) net" |
|
1333 by (rule topological_tendstoD) |
|
1334 with assms(2) have "eventually (\<lambda>x. False) net" |
|
1335 by (rule eventually_elim2) simp |
|
1336 with assms(3) show "False" |
|
1337 by (simp add: eventually_False) |
|
1338 qed |
|
1339 |
|
1340 text{* Need to prove closed(cball(x,e)) before deducing this as a corollary. *} |
|
1341 |
|
1342 lemma Lim_dist_ubound: |
|
1343 assumes "\<not>(trivial_limit net)" "(f ---> l) net" "eventually (\<lambda>x. dist a (f x) <= e) net" |
|
1344 shows "dist a l <= e" |
|
1345 proof (rule ccontr) |
|
1346 assume "\<not> dist a l \<le> e" |
|
1347 then have "0 < dist a l - e" by simp |
|
1348 with assms(2) have "eventually (\<lambda>x. dist (f x) l < dist a l - e) net" |
|
1349 by (rule tendstoD) |
|
1350 with assms(3) have "eventually (\<lambda>x. dist a (f x) \<le> e \<and> dist (f x) l < dist a l - e) net" |
|
1351 by (rule eventually_conjI) |
|
1352 then obtain w where "dist a (f w) \<le> e" "dist (f w) l < dist a l - e" |
|
1353 using assms(1) eventually_happens by auto |
|
1354 hence "dist a (f w) + dist (f w) l < e + (dist a l - e)" |
|
1355 by (rule add_le_less_mono) |
|
1356 hence "dist a (f w) + dist (f w) l < dist a l" |
|
1357 by simp |
|
1358 also have "\<dots> \<le> dist a (f w) + dist (f w) l" |
|
1359 by (rule dist_triangle) |
|
1360 finally show False by simp |
|
1361 qed |
|
1362 |
|
1363 lemma Lim_norm_ubound: |
|
1364 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1365 assumes "\<not>(trivial_limit net)" "(f ---> l) net" "eventually (\<lambda>x. norm(f x) <= e) net" |
|
1366 shows "norm(l) <= e" |
|
1367 proof (rule ccontr) |
|
1368 assume "\<not> norm l \<le> e" |
|
1369 then have "0 < norm l - e" by simp |
|
1370 with assms(2) have "eventually (\<lambda>x. dist (f x) l < norm l - e) net" |
|
1371 by (rule tendstoD) |
|
1372 with assms(3) have "eventually (\<lambda>x. norm (f x) \<le> e \<and> dist (f x) l < norm l - e) net" |
|
1373 by (rule eventually_conjI) |
|
1374 then obtain w where "norm (f w) \<le> e" "dist (f w) l < norm l - e" |
|
1375 using assms(1) eventually_happens by auto |
|
1376 hence "norm (f w - l) < norm l - e" "norm (f w) \<le> e" by (simp_all add: dist_norm) |
|
1377 hence "norm (f w - l) + norm (f w) < norm l" by simp |
|
1378 hence "norm (f w - l - f w) < norm l" by (rule le_less_trans [OF norm_triangle_ineq4]) |
|
1379 thus False using `\<not> norm l \<le> e` by simp |
|
1380 qed |
|
1381 |
|
1382 lemma Lim_norm_lbound: |
|
1383 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
1384 assumes "\<not> (trivial_limit net)" "(f ---> l) net" "eventually (\<lambda>x. e <= norm(f x)) net" |
|
1385 shows "e \<le> norm l" |
|
1386 proof (rule ccontr) |
|
1387 assume "\<not> e \<le> norm l" |
|
1388 then have "0 < e - norm l" by simp |
|
1389 with assms(2) have "eventually (\<lambda>x. dist (f x) l < e - norm l) net" |
|
1390 by (rule tendstoD) |
|
1391 with assms(3) have "eventually (\<lambda>x. e \<le> norm (f x) \<and> dist (f x) l < e - norm l) net" |
|
1392 by (rule eventually_conjI) |
|
1393 then obtain w where "e \<le> norm (f w)" "dist (f w) l < e - norm l" |
|
1394 using assms(1) eventually_happens by auto |
|
1395 hence "norm (f w - l) + norm l < e" "e \<le> norm (f w)" by (simp_all add: dist_norm) |
|
1396 hence "norm (f w - l) + norm l < norm (f w)" by (rule less_le_trans) |
|
1397 hence "norm (f w - l + l) < norm (f w)" by (rule le_less_trans [OF norm_triangle_ineq]) |
|
1398 thus False by simp |
|
1399 qed |
|
1400 |
|
1401 text{* Uniqueness of the limit, when nontrivial. *} |
|
1402 |
|
1403 lemma Lim_unique: |
|
1404 fixes f :: "'a \<Rightarrow> 'b::t2_space" |
|
1405 assumes "\<not> trivial_limit net" "(f ---> l) net" "(f ---> l') net" |
|
1406 shows "l = l'" |
|
1407 proof (rule ccontr) |
|
1408 assume "l \<noteq> l'" |
|
1409 obtain U V where "open U" "open V" "l \<in> U" "l' \<in> V" "U \<inter> V = {}" |
|
1410 using hausdorff [OF `l \<noteq> l'`] by fast |
|
1411 have "eventually (\<lambda>x. f x \<in> U) net" |
|
1412 using `(f ---> l) net` `open U` `l \<in> U` by (rule topological_tendstoD) |
|
1413 moreover |
|
1414 have "eventually (\<lambda>x. f x \<in> V) net" |
|
1415 using `(f ---> l') net` `open V` `l' \<in> V` by (rule topological_tendstoD) |
|
1416 ultimately |
|
1417 have "eventually (\<lambda>x. False) net" |
|
1418 proof (rule eventually_elim2) |
|
1419 fix x |
|
1420 assume "f x \<in> U" "f x \<in> V" |
|
1421 hence "f x \<in> U \<inter> V" by simp |
|
1422 with `U \<inter> V = {}` show "False" by simp |
|
1423 qed |
|
1424 with `\<not> trivial_limit net` show "False" |
|
1425 by (simp add: eventually_False) |
|
1426 qed |
|
1427 |
|
1428 lemma tendsto_Lim: |
|
1429 fixes f :: "'a \<Rightarrow> 'b::t2_space" |
|
1430 shows "~(trivial_limit net) \<Longrightarrow> (f ---> l) net ==> Lim net f = l" |
|
1431 unfolding Lim_def using Lim_unique[of net f] by auto |
|
1432 |
|
1433 text{* Limit under bilinear function *} |
|
1434 |
|
1435 lemma Lim_bilinear: |
|
1436 assumes "(f ---> l) net" and "(g ---> m) net" and "bounded_bilinear h" |
|
1437 shows "((\<lambda>x. h (f x) (g x)) ---> (h l m)) net" |
|
1438 using `bounded_bilinear h` `(f ---> l) net` `(g ---> m) net` |
|
1439 by (rule bounded_bilinear.tendsto) |
|
1440 |
|
1441 text{* These are special for limits out of the same vector space. *} |
|
1442 |
|
1443 lemma Lim_within_id: "(id ---> a) (at a within s)" |
|
1444 unfolding tendsto_def Limits.eventually_within eventually_at_topological |
|
1445 by auto |
|
1446 |
|
1447 lemma Lim_at_id: "(id ---> a) (at a)" |
|
1448 apply (subst within_UNIV[symmetric]) by (simp add: Lim_within_id) |
|
1449 |
|
1450 lemma Lim_at_zero: |
|
1451 fixes a :: "'a::real_normed_vector" |
|
1452 fixes l :: "'b::topological_space" |
|
1453 shows "(f ---> l) (at a) \<longleftrightarrow> ((\<lambda>x. f(a + x)) ---> l) (at 0)" (is "?lhs = ?rhs") |
|
1454 proof |
|
1455 assume "?lhs" |
|
1456 { fix S assume "open S" "l \<in> S" |
|
1457 with `?lhs` have "eventually (\<lambda>x. f x \<in> S) (at a)" |
|
1458 by (rule topological_tendstoD) |
|
1459 then obtain d where d: "d>0" "\<forall>x. x \<noteq> a \<and> dist x a < d \<longrightarrow> f x \<in> S" |
|
1460 unfolding Limits.eventually_at by fast |
|
1461 { fix x::"'a" assume "x \<noteq> 0 \<and> dist x 0 < d" |
|
1462 hence "f (a + x) \<in> S" using d |
|
1463 apply(erule_tac x="x+a" in allE) |
|
1464 by(auto simp add: comm_monoid_add.mult_commute dist_norm dist_commute) |
|
1465 } |
|
1466 hence "\<exists>d>0. \<forall>x. x \<noteq> 0 \<and> dist x 0 < d \<longrightarrow> f (a + x) \<in> S" |
|
1467 using d(1) by auto |
|
1468 hence "eventually (\<lambda>x. f (a + x) \<in> S) (at 0)" |
|
1469 unfolding Limits.eventually_at . |
|
1470 } |
|
1471 thus "?rhs" by (rule topological_tendstoI) |
|
1472 next |
|
1473 assume "?rhs" |
|
1474 { fix S assume "open S" "l \<in> S" |
|
1475 with `?rhs` have "eventually (\<lambda>x. f (a + x) \<in> S) (at 0)" |
|
1476 by (rule topological_tendstoD) |
|
1477 then obtain d where d: "d>0" "\<forall>x. x \<noteq> 0 \<and> dist x 0 < d \<longrightarrow> f (a + x) \<in> S" |
|
1478 unfolding Limits.eventually_at by fast |
|
1479 { fix x::"'a" assume "x \<noteq> a \<and> dist x a < d" |
|
1480 hence "f x \<in> S" using d apply(erule_tac x="x-a" in allE) |
|
1481 by(auto simp add: comm_monoid_add.mult_commute dist_norm dist_commute) |
|
1482 } |
|
1483 hence "\<exists>d>0. \<forall>x. x \<noteq> a \<and> dist x a < d \<longrightarrow> f x \<in> S" using d(1) by auto |
|
1484 hence "eventually (\<lambda>x. f x \<in> S) (at a)" unfolding Limits.eventually_at . |
|
1485 } |
|
1486 thus "?lhs" by (rule topological_tendstoI) |
|
1487 qed |
|
1488 |
|
1489 text{* It's also sometimes useful to extract the limit point from the net. *} |
|
1490 |
|
1491 definition |
|
1492 netlimit :: "'a::t2_space net \<Rightarrow> 'a" where |
|
1493 "netlimit net = (SOME a. ((\<lambda>x. x) ---> a) net)" |
|
1494 |
|
1495 lemma netlimit_within: |
|
1496 assumes "\<not> trivial_limit (at a within S)" |
|
1497 shows "netlimit (at a within S) = a" |
|
1498 unfolding netlimit_def |
|
1499 apply (rule some_equality) |
|
1500 apply (rule Lim_at_within) |
|
1501 apply (rule Lim_ident_at) |
|
1502 apply (erule Lim_unique [OF assms]) |
|
1503 apply (rule Lim_at_within) |
|
1504 apply (rule Lim_ident_at) |
|
1505 done |
|
1506 |
|
1507 lemma netlimit_at: |
|
1508 fixes a :: "'a::perfect_space" |
|
1509 shows "netlimit (at a) = a" |
|
1510 apply (subst within_UNIV[symmetric]) |
|
1511 using netlimit_within[of a UNIV] |
|
1512 by (simp add: trivial_limit_at within_UNIV) |
|
1513 |
|
1514 text{* Transformation of limit. *} |
|
1515 |
|
1516 lemma Lim_transform: |
|
1517 fixes f g :: "'a::type \<Rightarrow> 'b::real_normed_vector" |
|
1518 assumes "((\<lambda>x. f x - g x) ---> 0) net" "(f ---> l) net" |
|
1519 shows "(g ---> l) net" |
|
1520 proof- |
|
1521 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 |
|
1522 thus "?thesis" using Lim_neg [of "\<lambda> x. - g x" "-l" net] by auto |
|
1523 qed |
|
1524 |
|
1525 lemma Lim_transform_eventually: |
|
1526 "eventually (\<lambda>x. f x = g x) net \<Longrightarrow> (f ---> l) net ==> (g ---> l) net" |
|
1527 apply (rule topological_tendstoI) |
|
1528 apply (drule (2) topological_tendstoD) |
|
1529 apply (erule (1) eventually_elim2, simp) |
|
1530 done |
|
1531 |
|
1532 lemma Lim_transform_within: |
|
1533 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1534 assumes "0 < d" "(\<forall>x'\<in>S. 0 < dist x' x \<and> dist x' x < d \<longrightarrow> f x' = g x')" |
|
1535 "(f ---> l) (at x within S)" |
|
1536 shows "(g ---> l) (at x within S)" |
|
1537 using assms(1,3) unfolding Lim_within |
|
1538 apply - |
|
1539 apply (clarify, rename_tac e) |
|
1540 apply (drule_tac x=e in spec, clarsimp, rename_tac r) |
|
1541 apply (rule_tac x="min d r" in exI, clarsimp, rename_tac y) |
|
1542 apply (drule_tac x=y in bspec, assumption, clarsimp) |
|
1543 apply (simp add: assms(2)) |
|
1544 done |
|
1545 |
|
1546 lemma Lim_transform_at: |
|
1547 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1548 shows "0 < d \<Longrightarrow> (\<forall>x'. 0 < dist x' x \<and> dist x' x < d \<longrightarrow> f x' = g x') \<Longrightarrow> |
|
1549 (f ---> l) (at x) ==> (g ---> l) (at x)" |
|
1550 apply (subst within_UNIV[symmetric]) |
|
1551 using Lim_transform_within[of d UNIV x f g l] |
|
1552 by (auto simp add: within_UNIV) |
|
1553 |
|
1554 text{* Common case assuming being away from some crucial point like 0. *} |
|
1555 |
|
1556 lemma Lim_transform_away_within: |
|
1557 fixes a b :: "'a::metric_space" |
|
1558 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1559 assumes "a\<noteq>b" "\<forall>x\<in> S. x \<noteq> a \<and> x \<noteq> b \<longrightarrow> f x = g x" |
|
1560 and "(f ---> l) (at a within S)" |
|
1561 shows "(g ---> l) (at a within S)" |
|
1562 proof- |
|
1563 have "\<forall>x'\<in>S. 0 < dist x' a \<and> dist x' a < dist a b \<longrightarrow> f x' = g x'" using assms(2) |
|
1564 apply auto apply(erule_tac x=x' in ballE) by (auto simp add: dist_commute) |
|
1565 thus ?thesis using Lim_transform_within[of "dist a b" S a f g l] using assms(1,3) unfolding dist_nz by auto |
|
1566 qed |
|
1567 |
|
1568 lemma Lim_transform_away_at: |
|
1569 fixes a b :: "'a::metric_space" |
|
1570 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1571 assumes ab: "a\<noteq>b" and fg: "\<forall>x. x \<noteq> a \<and> x \<noteq> b \<longrightarrow> f x = g x" |
|
1572 and fl: "(f ---> l) (at a)" |
|
1573 shows "(g ---> l) (at a)" |
|
1574 using Lim_transform_away_within[OF ab, of UNIV f g l] fg fl |
|
1575 by (auto simp add: within_UNIV) |
|
1576 |
|
1577 text{* Alternatively, within an open set. *} |
|
1578 |
|
1579 lemma Lim_transform_within_open: |
|
1580 fixes a :: "'a::metric_space" |
|
1581 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1582 assumes "open S" "a \<in> S" "\<forall>x\<in>S. x \<noteq> a \<longrightarrow> f x = g x" "(f ---> l) (at a)" |
|
1583 shows "(g ---> l) (at a)" |
|
1584 proof- |
|
1585 from assms(1,2) obtain e::real where "e>0" and e:"ball a e \<subseteq> S" unfolding open_contains_ball by auto |
|
1586 hence "\<forall>x'. 0 < dist x' a \<and> dist x' a < e \<longrightarrow> f x' = g x'" using assms(3) |
|
1587 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) |
|
1588 thus ?thesis using Lim_transform_at[of e a f g l] `e>0` assms(4) by auto |
|
1589 qed |
|
1590 |
|
1591 text{* A congruence rule allowing us to transform limits assuming not at point. *} |
|
1592 |
|
1593 (* FIXME: Only one congruence rule for tendsto can be used at a time! *) |
|
1594 |
|
1595 lemma Lim_cong_within[cong add]: |
|
1596 fixes a :: "'a::metric_space" |
|
1597 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1598 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))" |
|
1599 by (simp add: Lim_within dist_nz[symmetric]) |
|
1600 |
|
1601 lemma Lim_cong_at[cong add]: |
|
1602 fixes a :: "'a::metric_space" |
|
1603 fixes l :: "'b::metric_space" (* TODO: generalize *) |
|
1604 shows "(\<And>x. x \<noteq> a ==> f x = g x) ==> (((\<lambda>x. f x) ---> l) (at a) \<longleftrightarrow> ((g ---> l) (at a)))" |
|
1605 by (simp add: Lim_at dist_nz[symmetric]) |
|
1606 |
|
1607 text{* Useful lemmas on closure and set of possible sequential limits.*} |
|
1608 |
|
1609 lemma closure_sequential: |
|
1610 fixes l :: "'a::metric_space" (* TODO: generalize *) |
|
1611 shows "l \<in> closure S \<longleftrightarrow> (\<exists>x. (\<forall>n. x n \<in> S) \<and> (x ---> l) sequentially)" (is "?lhs = ?rhs") |
|
1612 proof |
|
1613 assume "?lhs" moreover |
|
1614 { assume "l \<in> S" |
|
1615 hence "?rhs" using Lim_const[of l sequentially] by auto |
|
1616 } moreover |
|
1617 { assume "l islimpt S" |
|
1618 hence "?rhs" unfolding islimpt_sequential by auto |
|
1619 } ultimately |
|
1620 show "?rhs" unfolding closure_def by auto |
|
1621 next |
|
1622 assume "?rhs" |
|
1623 thus "?lhs" unfolding closure_def unfolding islimpt_sequential by auto |
|
1624 qed |
|
1625 |
|
1626 lemma closed_sequential_limits: |
|
1627 fixes S :: "'a::metric_space set" |
|
1628 shows "closed S \<longleftrightarrow> (\<forall>x l. (\<forall>n. x n \<in> S) \<and> (x ---> l) sequentially \<longrightarrow> l \<in> S)" |
|
1629 unfolding closed_limpt |
|
1630 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] |
|
1631 by metis |
|
1632 |
|
1633 lemma closure_approachable: |
|
1634 fixes S :: "'a::metric_space set" |
|
1635 shows "x \<in> closure S \<longleftrightarrow> (\<forall>e>0. \<exists>y\<in>S. dist y x < e)" |
|
1636 apply (auto simp add: closure_def islimpt_approachable) |
|
1637 by (metis dist_self) |
|
1638 |
|
1639 lemma closed_approachable: |
|
1640 fixes S :: "'a::metric_space set" |
|
1641 shows "closed S ==> (\<forall>e>0. \<exists>y\<in>S. dist y x < e) \<longleftrightarrow> x \<in> S" |
|
1642 by (metis closure_closed closure_approachable) |
|
1643 |
|
1644 text{* Some other lemmas about sequences. *} |
|
1645 |
|
1646 lemma seq_offset: |
|
1647 fixes l :: "'a::metric_space" (* TODO: generalize *) |
|
1648 shows "(f ---> l) sequentially ==> ((\<lambda>i. f( i + k)) ---> l) sequentially" |
|
1649 apply (auto simp add: Lim_sequentially) |
|
1650 by (metis trans_le_add1 ) |
|
1651 |
|
1652 lemma seq_offset_neg: |
|
1653 "(f ---> l) sequentially ==> ((\<lambda>i. f(i - k)) ---> l) sequentially" |
|
1654 apply (rule topological_tendstoI) |
|
1655 apply (drule (2) topological_tendstoD) |
|
1656 apply (simp only: eventually_sequentially) |
|
1657 apply (subgoal_tac "\<And>N k (n::nat). N + k <= n ==> N <= n - k") |
|
1658 apply metis |
|
1659 by arith |
|
1660 |
|
1661 lemma seq_offset_rev: |
|
1662 "((\<lambda>i. f(i + k)) ---> l) sequentially ==> (f ---> l) sequentially" |
|
1663 apply (rule topological_tendstoI) |
|
1664 apply (drule (2) topological_tendstoD) |
|
1665 apply (simp only: eventually_sequentially) |
|
1666 apply (subgoal_tac "\<And>N k (n::nat). N + k <= n ==> N <= n - k \<and> (n - k) + k = n") |
|
1667 by metis arith |
|
1668 |
|
1669 lemma seq_harmonic: "((\<lambda>n. inverse (real n)) ---> 0) sequentially" |
|
1670 proof- |
|
1671 { fix e::real assume "e>0" |
|
1672 hence "\<exists>N::nat. \<forall>n::nat\<ge>N. inverse (real n) < e" |
|
1673 using real_arch_inv[of e] apply auto apply(rule_tac x=n in exI) |
|
1674 by (metis not_le le_imp_inverse_le not_less real_of_nat_gt_zero_cancel_iff real_of_nat_less_iff xt1(7)) |
|
1675 } |
|
1676 thus ?thesis unfolding Lim_sequentially dist_norm by simp |
|
1677 qed |
|
1678 |
|
1679 text{* More properties of closed balls. *} |
|
1680 |
|
1681 lemma closed_cball: "closed (cball x e)" |
|
1682 unfolding cball_def closed_def |
|
1683 unfolding Collect_neg_eq [symmetric] not_le |
|
1684 apply (clarsimp simp add: open_dist, rename_tac y) |
|
1685 apply (rule_tac x="dist x y - e" in exI, clarsimp) |
|
1686 apply (rename_tac x') |
|
1687 apply (cut_tac x=x and y=x' and z=y in dist_triangle) |
|
1688 apply simp |
|
1689 done |
|
1690 |
|
1691 lemma open_contains_cball: "open S \<longleftrightarrow> (\<forall>x\<in>S. \<exists>e>0. cball x e \<subseteq> S)" |
|
1692 proof- |
|
1693 { fix x and e::real assume "x\<in>S" "e>0" "ball x e \<subseteq> S" |
|
1694 hence "\<exists>d>0. cball x d \<subseteq> S" unfolding subset_eq by (rule_tac x="e/2" in exI, auto) |
|
1695 } moreover |
|
1696 { fix x and e::real assume "x\<in>S" "e>0" "cball x e \<subseteq> S" |
|
1697 hence "\<exists>d>0. ball x d \<subseteq> S" unfolding subset_eq apply(rule_tac x="e/2" in exI) by auto |
|
1698 } ultimately |
|
1699 show ?thesis unfolding open_contains_ball by auto |
|
1700 qed |
|
1701 |
|
1702 lemma open_contains_cball_eq: "open S ==> (\<forall>x. x \<in> S \<longleftrightarrow> (\<exists>e>0. cball x e \<subseteq> S))" |
|
1703 by (metis open_contains_cball subset_eq order_less_imp_le centre_in_cball mem_def) |
|
1704 |
|
1705 lemma mem_interior_cball: "x \<in> interior S \<longleftrightarrow> (\<exists>e>0. cball x e \<subseteq> S)" |
|
1706 apply (simp add: interior_def, safe) |
|
1707 apply (force simp add: open_contains_cball) |
|
1708 apply (rule_tac x="ball x e" in exI) |
|
1709 apply (simp add: open_ball centre_in_ball subset_trans [OF ball_subset_cball]) |
|
1710 done |
|
1711 |
|
1712 lemma islimpt_ball: |
|
1713 fixes x y :: "'a::{real_normed_vector,perfect_space}" |
|
1714 shows "y islimpt ball x e \<longleftrightarrow> 0 < e \<and> y \<in> cball x e" (is "?lhs = ?rhs") |
|
1715 proof |
|
1716 assume "?lhs" |
|
1717 { assume "e \<le> 0" |
|
1718 hence *:"ball x e = {}" using ball_eq_empty[of x e] by auto |
|
1719 have False using `?lhs` unfolding * using islimpt_EMPTY[of y] by auto |
|
1720 } |
|
1721 hence "e > 0" by (metis not_less) |
|
1722 moreover |
|
1723 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 |
|
1724 ultimately show "?rhs" by auto |
|
1725 next |
|
1726 assume "?rhs" hence "e>0" by auto |
|
1727 { fix d::real assume "d>0" |
|
1728 have "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1729 proof(cases "d \<le> dist x y") |
|
1730 case True thus "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1731 proof(cases "x=y") |
|
1732 case True hence False using `d \<le> dist x y` `d>0` by auto |
|
1733 thus "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" by auto |
|
1734 next |
|
1735 case False |
|
1736 |
|
1737 have "dist x (y - (d / (2 * dist y x)) *\<^sub>R (y - x)) |
|
1738 = norm (x - y + (d / (2 * norm (y - x))) *\<^sub>R (y - x))" |
|
1739 unfolding mem_cball mem_ball dist_norm diff_diff_eq2 diff_add_eq[THEN sym] by auto |
|
1740 also have "\<dots> = \<bar>- 1 + d / (2 * norm (x - y))\<bar> * norm (x - y)" |
|
1741 using scaleR_left_distrib[of "- 1" "d / (2 * norm (y - x))", THEN sym, of "y - x"] |
|
1742 unfolding scaleR_minus_left scaleR_one |
|
1743 by (auto simp add: norm_minus_commute) |
|
1744 also have "\<dots> = \<bar>- norm (x - y) + d / 2\<bar>" |
|
1745 unfolding abs_mult_pos[of "norm (x - y)", OF norm_ge_zero[of "x - y"]] |
|
1746 unfolding real_add_mult_distrib using `x\<noteq>y`[unfolded dist_nz, unfolded dist_norm] by auto |
|
1747 also have "\<dots> \<le> e - d/2" using `d \<le> dist x y` and `d>0` and `?rhs` by(auto simp add: dist_norm) |
|
1748 finally have "y - (d / (2 * dist y x)) *\<^sub>R (y - x) \<in> ball x e" using `d>0` by auto |
|
1749 |
|
1750 moreover |
|
1751 |
|
1752 have "(d / (2*dist y x)) *\<^sub>R (y - x) \<noteq> 0" |
|
1753 using `x\<noteq>y`[unfolded dist_nz] `d>0` unfolding scaleR_eq_0_iff by (auto simp add: dist_commute) |
|
1754 moreover |
|
1755 have "dist (y - (d / (2 * dist y x)) *\<^sub>R (y - x)) y < d" unfolding dist_norm apply simp unfolding norm_minus_cancel |
|
1756 using `d>0` `x\<noteq>y`[unfolded dist_nz] dist_commute[of x y] |
|
1757 unfolding dist_norm by auto |
|
1758 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 |
|
1759 qed |
|
1760 next |
|
1761 case False hence "d > dist x y" by auto |
|
1762 show "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1763 proof(cases "x=y") |
|
1764 case True |
|
1765 obtain z where **: "z \<noteq> y" "dist z y < min e d" |
|
1766 using perfect_choose_dist[of "min e d" y] |
|
1767 using `d > 0` `e>0` by auto |
|
1768 show "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1769 unfolding `x = y` |
|
1770 using `z \<noteq> y` ** |
|
1771 by (rule_tac x=z in bexI, auto simp add: dist_commute) |
|
1772 next |
|
1773 case False thus "\<exists>x'\<in>ball x e. x' \<noteq> y \<and> dist x' y < d" |
|
1774 using `d>0` `d > dist x y` `?rhs` by(rule_tac x=x in bexI, auto) |
|
1775 qed |
|
1776 qed } |
|
1777 thus "?lhs" unfolding mem_cball islimpt_approachable mem_ball by auto |
|
1778 qed |
|
1779 |
|
1780 lemma closure_ball_lemma: |
|
1781 fixes x y :: "'a::real_normed_vector" |
|
1782 assumes "x \<noteq> y" shows "y islimpt ball x (dist x y)" |
|
1783 proof (rule islimptI) |
|
1784 fix T assume "y \<in> T" "open T" |
|
1785 then obtain r where "0 < r" "\<forall>z. dist z y < r \<longrightarrow> z \<in> T" |
|
1786 unfolding open_dist by fast |
|
1787 (* choose point between x and y, within distance r of y. *) |
|
1788 def k \<equiv> "min 1 (r / (2 * dist x y))" |
|
1789 def z \<equiv> "y + scaleR k (x - y)" |
|
1790 have z_def2: "z = x + scaleR (1 - k) (y - x)" |
|
1791 unfolding z_def by (simp add: algebra_simps) |
|
1792 have "dist z y < r" |
|
1793 unfolding z_def k_def using `0 < r` |
|
1794 by (simp add: dist_norm min_def) |
|
1795 hence "z \<in> T" using `\<forall>z. dist z y < r \<longrightarrow> z \<in> T` by simp |
|
1796 have "dist x z < dist x y" |
|
1797 unfolding z_def2 dist_norm |
|
1798 apply (simp add: norm_minus_commute) |
|
1799 apply (simp only: dist_norm [symmetric]) |
|
1800 apply (subgoal_tac "\<bar>1 - k\<bar> * dist x y < 1 * dist x y", simp) |
|
1801 apply (rule mult_strict_right_mono) |
|
1802 apply (simp add: k_def divide_pos_pos zero_less_dist_iff `0 < r` `x \<noteq> y`) |
|
1803 apply (simp add: zero_less_dist_iff `x \<noteq> y`) |
|
1804 done |
|
1805 hence "z \<in> ball x (dist x y)" by simp |
|
1806 have "z \<noteq> y" |
|
1807 unfolding z_def k_def using `x \<noteq> y` `0 < r` |
|
1808 by (simp add: min_def) |
|
1809 show "\<exists>z\<in>ball x (dist x y). z \<in> T \<and> z \<noteq> y" |
|
1810 using `z \<in> ball x (dist x y)` `z \<in> T` `z \<noteq> y` |
|
1811 by fast |
|
1812 qed |
|
1813 |
|
1814 lemma closure_ball: |
|
1815 fixes x :: "'a::real_normed_vector" |
|
1816 shows "0 < e \<Longrightarrow> closure (ball x e) = cball x e" |
|
1817 apply (rule equalityI) |
|
1818 apply (rule closure_minimal) |
|
1819 apply (rule ball_subset_cball) |
|
1820 apply (rule closed_cball) |
|
1821 apply (rule subsetI, rename_tac y) |
|
1822 apply (simp add: le_less [where 'a=real]) |
|
1823 apply (erule disjE) |
|
1824 apply (rule subsetD [OF closure_subset], simp) |
|
1825 apply (simp add: closure_def) |
|
1826 apply clarify |
|
1827 apply (rule closure_ball_lemma) |
|
1828 apply (simp add: zero_less_dist_iff) |
|
1829 done |
|
1830 |
|
1831 (* In a trivial vector space, this fails for e = 0. *) |
|
1832 lemma interior_cball: |
|
1833 fixes x :: "'a::{real_normed_vector, perfect_space}" |
|
1834 shows "interior (cball x e) = ball x e" |
|
1835 proof(cases "e\<ge>0") |
|
1836 case False note cs = this |
|
1837 from cs have "ball x e = {}" using ball_empty[of e x] by auto moreover |
|
1838 { fix y assume "y \<in> cball x e" |
|
1839 hence False unfolding mem_cball using dist_nz[of x y] cs by auto } |
|
1840 hence "cball x e = {}" by auto |
|
1841 hence "interior (cball x e) = {}" using interior_empty by auto |
|
1842 ultimately show ?thesis by blast |
|
1843 next |
|
1844 case True note cs = this |
|
1845 have "ball x e \<subseteq> cball x e" using ball_subset_cball by auto moreover |
|
1846 { fix S y assume as: "S \<subseteq> cball x e" "open S" "y\<in>S" |
|
1847 then obtain d where "d>0" and d:"\<forall>x'. dist x' y < d \<longrightarrow> x' \<in> S" unfolding open_dist by blast |
|
1848 |
|
1849 then obtain xa where xa_y: "xa \<noteq> y" and xa: "dist xa y < d" |
|
1850 using perfect_choose_dist [of d] by auto |
|
1851 have "xa\<in>S" using d[THEN spec[where x=xa]] using xa by(auto simp add: dist_commute) |
|
1852 hence xa_cball:"xa \<in> cball x e" using as(1) by auto |
|
1853 |
|
1854 hence "y \<in> ball x e" proof(cases "x = y") |
|
1855 case True |
|
1856 hence "e>0" using xa_y[unfolded dist_nz] xa_cball[unfolded mem_cball] by (auto simp add: dist_commute) |
|
1857 thus "y \<in> ball x e" using `x = y ` by simp |
|
1858 next |
|
1859 case False |
|
1860 have "dist (y + (d / 2 / dist y x) *\<^sub>R (y - x)) y < d" unfolding dist_norm |
|
1861 using `d>0` norm_ge_zero[of "y - x"] `x \<noteq> y` by auto |
|
1862 hence *:"y + (d / 2 / dist y x) *\<^sub>R (y - x) \<in> cball x e" using d as(1)[unfolded subset_eq] by blast |
|
1863 have "y - x \<noteq> 0" using `x \<noteq> y` by auto |
|
1864 hence **:"d / (2 * norm (y - x)) > 0" unfolding zero_less_norm_iff[THEN sym] |
|
1865 using `d>0` divide_pos_pos[of d "2*norm (y - x)"] by auto |
|
1866 |
|
1867 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)" |
|
1868 by (auto simp add: dist_norm algebra_simps) |
|
1869 also have "\<dots> = norm ((1 + d / (2 * norm (y - x))) *\<^sub>R (y - x))" |
|
1870 by (auto simp add: algebra_simps) |
|
1871 also have "\<dots> = \<bar>1 + d / (2 * norm (y - x))\<bar> * norm (y - x)" |
|
1872 using ** by auto |
|
1873 also have "\<dots> = (dist y x) + d/2"using ** by (auto simp add: left_distrib dist_norm) |
|
1874 finally have "e \<ge> dist x y +d/2" using *[unfolded mem_cball] by (auto simp add: dist_commute) |
|
1875 thus "y \<in> ball x e" unfolding mem_ball using `d>0` by auto |
|
1876 qed } |
|
1877 hence "\<forall>S \<subseteq> cball x e. open S \<longrightarrow> S \<subseteq> ball x e" by auto |
|
1878 ultimately show ?thesis using interior_unique[of "ball x e" "cball x e"] using open_ball[of x e] by auto |
|
1879 qed |
|
1880 |
|
1881 lemma frontier_ball: |
|
1882 fixes a :: "'a::real_normed_vector" |
|
1883 shows "0 < e ==> frontier(ball a e) = {x. dist a x = e}" |
|
1884 apply (simp add: frontier_def closure_ball interior_open open_ball order_less_imp_le) |
|
1885 apply (simp add: expand_set_eq) |
|
1886 by arith |
|
1887 |
|
1888 lemma frontier_cball: |
|
1889 fixes a :: "'a::{real_normed_vector, perfect_space}" |
|
1890 shows "frontier(cball a e) = {x. dist a x = e}" |
|
1891 apply (simp add: frontier_def interior_cball closed_cball closure_closed order_less_imp_le) |
|
1892 apply (simp add: expand_set_eq) |
|
1893 by arith |
|
1894 |
|
1895 lemma cball_eq_empty: "(cball x e = {}) \<longleftrightarrow> e < 0" |
|
1896 apply (simp add: expand_set_eq not_le) |
|
1897 by (metis zero_le_dist dist_self order_less_le_trans) |
|
1898 lemma cball_empty: "e < 0 ==> cball x e = {}" by (simp add: cball_eq_empty) |
|
1899 |
|
1900 lemma cball_eq_sing: |
|
1901 fixes x :: "'a::perfect_space" |
|
1902 shows "(cball x e = {x}) \<longleftrightarrow> e = 0" |
|
1903 proof (rule linorder_cases) |
|
1904 assume e: "0 < e" |
|
1905 obtain a where "a \<noteq> x" "dist a x < e" |
|
1906 using perfect_choose_dist [OF e] by auto |
|
1907 hence "a \<noteq> x" "dist x a \<le> e" by (auto simp add: dist_commute) |
|
1908 with e show ?thesis by (auto simp add: expand_set_eq) |
|
1909 qed auto |
|
1910 |
|
1911 lemma cball_sing: |
|
1912 fixes x :: "'a::metric_space" |
|
1913 shows "e = 0 ==> cball x e = {x}" |
|
1914 by (auto simp add: expand_set_eq) |
|
1915 |
|
1916 text{* For points in the interior, localization of limits makes no difference. *} |
|
1917 |
|
1918 lemma eventually_within_interior: |
|
1919 assumes "x \<in> interior S" |
|
1920 shows "eventually P (at x within S) \<longleftrightarrow> eventually P (at x)" (is "?lhs = ?rhs") |
|
1921 proof- |
|
1922 from assms obtain T where T: "open T" "x \<in> T" "T \<subseteq> S" |
|
1923 unfolding interior_def by fast |
|
1924 { assume "?lhs" |
|
1925 then obtain A where "open A" "x \<in> A" "\<forall>y\<in>A. y \<noteq> x \<longrightarrow> y \<in> S \<longrightarrow> P y" |
|
1926 unfolding Limits.eventually_within Limits.eventually_at_topological |
|
1927 by auto |
|
1928 with T have "open (A \<inter> T)" "x \<in> A \<inter> T" "\<forall>y\<in>(A \<inter> T). y \<noteq> x \<longrightarrow> P y" |
|
1929 by auto |
|
1930 then have "?rhs" |
|
1931 unfolding Limits.eventually_at_topological by auto |
|
1932 } moreover |
|
1933 { assume "?rhs" hence "?lhs" |
|
1934 unfolding Limits.eventually_within |
|
1935 by (auto elim: eventually_elim1) |
|
1936 } ultimately |
|
1937 show "?thesis" .. |
|
1938 qed |
|
1939 |
|
1940 lemma lim_within_interior: |
|
1941 "x \<in> interior S \<Longrightarrow> (f ---> l) (at x within S) \<longleftrightarrow> (f ---> l) (at x)" |
|
1942 unfolding tendsto_def by (simp add: eventually_within_interior) |
|
1943 |
|
1944 lemma netlimit_within_interior: |
|
1945 fixes x :: "'a::{perfect_space, real_normed_vector}" |
|
1946 (* FIXME: generalize to perfect_space *) |
|
1947 assumes "x \<in> interior S" |
|
1948 shows "netlimit(at x within S) = x" (is "?lhs = ?rhs") |
|
1949 proof- |
|
1950 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 |
|
1951 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 |
|
1952 thus ?thesis using netlimit_within by auto |
|
1953 qed |
|
1954 |
|
1955 subsection{* Boundedness. *} |
|
1956 |
|
1957 (* FIXME: This has to be unified with BSEQ!! *) |
|
1958 definition |
|
1959 bounded :: "'a::metric_space set \<Rightarrow> bool" where |
|
1960 "bounded S \<longleftrightarrow> (\<exists>x e. \<forall>y\<in>S. dist x y \<le> e)" |
|
1961 |
|
1962 lemma bounded_any_center: "bounded S \<longleftrightarrow> (\<exists>e. \<forall>y\<in>S. dist a y \<le> e)" |
|
1963 unfolding bounded_def |
|
1964 apply safe |
|
1965 apply (rule_tac x="dist a x + e" in exI, clarify) |
|
1966 apply (drule (1) bspec) |
|
1967 apply (erule order_trans [OF dist_triangle add_left_mono]) |
|
1968 apply auto |
|
1969 done |
|
1970 |
|
1971 lemma bounded_iff: "bounded S \<longleftrightarrow> (\<exists>a. \<forall>x\<in>S. norm x \<le> a)" |
|
1972 unfolding bounded_any_center [where a=0] |
|
1973 by (simp add: dist_norm) |
|
1974 |
|
1975 lemma bounded_empty[simp]: "bounded {}" by (simp add: bounded_def) |
|
1976 lemma bounded_subset: "bounded T \<Longrightarrow> S \<subseteq> T ==> bounded S" |
|
1977 by (metis bounded_def subset_eq) |
|
1978 |
|
1979 lemma bounded_interior[intro]: "bounded S ==> bounded(interior S)" |
|
1980 by (metis bounded_subset interior_subset) |
|
1981 |
|
1982 lemma bounded_closure[intro]: assumes "bounded S" shows "bounded(closure S)" |
|
1983 proof- |
|
1984 from assms obtain x and a where a: "\<forall>y\<in>S. dist x y \<le> a" unfolding bounded_def by auto |
|
1985 { fix y assume "y \<in> closure S" |
|
1986 then obtain f where f: "\<forall>n. f n \<in> S" "(f ---> y) sequentially" |
|
1987 unfolding closure_sequential by auto |
|
1988 have "\<forall>n. f n \<in> S \<longrightarrow> dist x (f n) \<le> a" using a by simp |
|
1989 hence "eventually (\<lambda>n. dist x (f n) \<le> a) sequentially" |
|
1990 by (rule eventually_mono, simp add: f(1)) |
|
1991 have "dist x y \<le> a" |
|
1992 apply (rule Lim_dist_ubound [of sequentially f]) |
|
1993 apply (rule trivial_limit_sequentially) |
|
1994 apply (rule f(2)) |
|
1995 apply fact |
|
1996 done |
|
1997 } |
|
1998 thus ?thesis unfolding bounded_def by auto |
|
1999 qed |
|
2000 |
|
2001 lemma bounded_cball[simp,intro]: "bounded (cball x e)" |
|
2002 apply (simp add: bounded_def) |
|
2003 apply (rule_tac x=x in exI) |
|
2004 apply (rule_tac x=e in exI) |
|
2005 apply auto |
|
2006 done |
|
2007 |
|
2008 lemma bounded_ball[simp,intro]: "bounded(ball x e)" |
|
2009 by (metis ball_subset_cball bounded_cball bounded_subset) |
|
2010 |
|
2011 lemma finite_imp_bounded[intro]: assumes "finite S" shows "bounded S" |
|
2012 proof- |
|
2013 { fix a F assume as:"bounded F" |
|
2014 then obtain x e where "\<forall>y\<in>F. dist x y \<le> e" unfolding bounded_def by auto |
|
2015 hence "\<forall>y\<in>(insert a F). dist x y \<le> max e (dist x a)" by auto |
|
2016 hence "bounded (insert a F)" unfolding bounded_def by (intro exI) |
|
2017 } |
|
2018 thus ?thesis using finite_induct[of S bounded] using bounded_empty assms by auto |
|
2019 qed |
|
2020 |
|
2021 lemma bounded_Un[simp]: "bounded (S \<union> T) \<longleftrightarrow> bounded S \<and> bounded T" |
|
2022 apply (auto simp add: bounded_def) |
|
2023 apply (rename_tac x y r s) |
|
2024 apply (rule_tac x=x in exI) |
|
2025 apply (rule_tac x="max r (dist x y + s)" in exI) |
|
2026 apply (rule ballI, rename_tac z, safe) |
|
2027 apply (drule (1) bspec, simp) |
|
2028 apply (drule (1) bspec) |
|
2029 apply (rule min_max.le_supI2) |
|
2030 apply (erule order_trans [OF dist_triangle add_left_mono]) |
|
2031 done |
|
2032 |
|
2033 lemma bounded_Union[intro]: "finite F \<Longrightarrow> (\<forall>S\<in>F. bounded S) \<Longrightarrow> bounded(\<Union>F)" |
|
2034 by (induct rule: finite_induct[of F], auto) |
|
2035 |
|
2036 lemma bounded_pos: "bounded S \<longleftrightarrow> (\<exists>b>0. \<forall>x\<in> S. norm x <= b)" |
|
2037 apply (simp add: bounded_iff) |
|
2038 apply (subgoal_tac "\<And>x (y::real). 0 < 1 + abs y \<and> (x <= y \<longrightarrow> x <= 1 + abs y)") |
|
2039 by metis arith |
|
2040 |
|
2041 lemma bounded_Int[intro]: "bounded S \<or> bounded T \<Longrightarrow> bounded (S \<inter> T)" |
|
2042 by (metis Int_lower1 Int_lower2 bounded_subset) |
|
2043 |
|
2044 lemma bounded_diff[intro]: "bounded S ==> bounded (S - T)" |
|
2045 apply (metis Diff_subset bounded_subset) |
|
2046 done |
|
2047 |
|
2048 lemma bounded_insert[intro]:"bounded(insert x S) \<longleftrightarrow> bounded S" |
|
2049 by (metis Diff_cancel Un_empty_right Un_insert_right bounded_Un bounded_subset finite.emptyI finite_imp_bounded infinite_remove subset_insertI) |
|
2050 |
|
2051 lemma not_bounded_UNIV[simp, intro]: |
|
2052 "\<not> bounded (UNIV :: 'a::{real_normed_vector, perfect_space} set)" |
|
2053 proof(auto simp add: bounded_pos not_le) |
|
2054 obtain x :: 'a where "x \<noteq> 0" |
|
2055 using perfect_choose_dist [OF zero_less_one] by fast |
|
2056 fix b::real assume b: "b >0" |
|
2057 have b1: "b +1 \<ge> 0" using b by simp |
|
2058 with `x \<noteq> 0` have "b < norm (scaleR (b + 1) (sgn x))" |
|
2059 by (simp add: norm_sgn) |
|
2060 then show "\<exists>x::'a. b < norm x" .. |
|
2061 qed |
|
2062 |
|
2063 lemma bounded_linear_image: |
|
2064 assumes "bounded S" "bounded_linear f" |
|
2065 shows "bounded(f ` S)" |
|
2066 proof- |
|
2067 from assms(1) obtain b where b:"b>0" "\<forall>x\<in>S. norm x \<le> b" unfolding bounded_pos by auto |
|
2068 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) |
|
2069 { fix x assume "x\<in>S" |
|
2070 hence "norm x \<le> b" using b by auto |
|
2071 hence "norm (f x) \<le> B * b" using B(2) apply(erule_tac x=x in allE) |
|
2072 by (metis B(1) B(2) real_le_trans real_mult_le_cancel_iff2) |
|
2073 } |
|
2074 thus ?thesis unfolding bounded_pos apply(rule_tac x="b*B" in exI) |
|
2075 using b B real_mult_order[of b B] by (auto simp add: real_mult_commute) |
|
2076 qed |
|
2077 |
|
2078 lemma bounded_scaling: |
|
2079 fixes S :: "'a::real_normed_vector set" |
|
2080 shows "bounded S \<Longrightarrow> bounded ((\<lambda>x. c *\<^sub>R x) ` S)" |
|
2081 apply (rule bounded_linear_image, assumption) |
|
2082 apply (rule scaleR.bounded_linear_right) |
|
2083 done |
|
2084 |
|
2085 lemma bounded_translation: |
|
2086 fixes S :: "'a::real_normed_vector set" |
|
2087 assumes "bounded S" shows "bounded ((\<lambda>x. a + x) ` S)" |
|
2088 proof- |
|
2089 from assms obtain b where b:"b>0" "\<forall>x\<in>S. norm x \<le> b" unfolding bounded_pos by auto |
|
2090 { fix x assume "x\<in>S" |
|
2091 hence "norm (a + x) \<le> b + norm a" using norm_triangle_ineq[of a x] b by auto |
|
2092 } |
|
2093 thus ?thesis unfolding bounded_pos using norm_ge_zero[of a] b(1) using add_strict_increasing[of b 0 "norm a"] |
|
2094 by (auto intro!: add exI[of _ "b + norm a"]) |
|
2095 qed |
|
2096 |
|
2097 |
|
2098 text{* Some theorems on sups and infs using the notion "bounded". *} |
|
2099 |
|
2100 lemma bounded_real: |
|
2101 fixes S :: "real set" |
|
2102 shows "bounded S \<longleftrightarrow> (\<exists>a. \<forall>x\<in>S. abs x <= a)" |
|
2103 by (simp add: bounded_iff) |
|
2104 |
|
2105 lemma bounded_has_rsup: assumes "bounded S" "S \<noteq> {}" |
|
2106 shows "\<forall>x\<in>S. x <= rsup S" and "\<forall>b. (\<forall>x\<in>S. x <= b) \<longrightarrow> rsup S <= b" |
|
2107 proof |
|
2108 fix x assume "x\<in>S" |
|
2109 from assms(1) obtain a where a:"\<forall>x\<in>S. \<bar>x\<bar> \<le> a" unfolding bounded_real by auto |
|
2110 hence *:"S *<= a" using setleI[of S a] by (metis abs_le_interval_iff mem_def) |
|
2111 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 |
|
2112 next |
|
2113 show "\<forall>b. (\<forall>x\<in>S. x \<le> b) \<longrightarrow> rsup S \<le> b" using assms |
|
2114 using rsup[of S, unfolded isLub_def isUb_def leastP_def setle_def setge_def] |
|
2115 apply (auto simp add: bounded_real) |
|
2116 by (auto simp add: isLub_def isUb_def leastP_def setle_def setge_def) |
|
2117 qed |
|
2118 |
|
2119 lemma rsup_insert: assumes "bounded S" |
|
2120 shows "rsup(insert x S) = (if S = {} then x else max x (rsup S))" |
|
2121 proof(cases "S={}") |
|
2122 case True thus ?thesis using rsup_finite_in[of "{x}"] by auto |
|
2123 next |
|
2124 let ?S = "insert x S" |
|
2125 case False |
|
2126 hence *:"\<forall>x\<in>S. x \<le> rsup S" using bounded_has_rsup(1)[of S] using assms by auto |
|
2127 hence "insert x S *<= max x (rsup S)" unfolding setle_def by auto |
|
2128 hence "isLub UNIV ?S (rsup ?S)" using rsup[of ?S] by auto |
|
2129 moreover |
|
2130 have **:"isUb UNIV ?S (max x (rsup S))" unfolding isUb_def setle_def using * by auto |
|
2131 { fix y assume as:"isUb UNIV (insert x S) y" |
|
2132 hence "max x (rsup S) \<le> y" unfolding isUb_def using rsup_le[OF `S\<noteq>{}`] |
|
2133 unfolding setle_def by auto } |
|
2134 hence "max x (rsup S) <=* isUb UNIV (insert x S)" unfolding setge_def Ball_def mem_def by auto |
|
2135 hence "isLub UNIV ?S (max x (rsup S))" using ** isLubI2[of UNIV ?S "max x (rsup S)"] unfolding Collect_def by auto |
|
2136 ultimately show ?thesis using real_isLub_unique[of UNIV ?S] using `S\<noteq>{}` by auto |
|
2137 qed |
|
2138 |
|
2139 lemma sup_insert_finite: "finite S \<Longrightarrow> rsup(insert x S) = (if S = {} then x else max x (rsup S))" |
|
2140 apply (rule rsup_insert) |
|
2141 apply (rule finite_imp_bounded) |
|
2142 by simp |
|
2143 |
|
2144 lemma bounded_has_rinf: |
|
2145 assumes "bounded S" "S \<noteq> {}" |
|
2146 shows "\<forall>x\<in>S. x >= rinf S" and "\<forall>b. (\<forall>x\<in>S. x >= b) \<longrightarrow> rinf S >= b" |
|
2147 proof |
|
2148 fix x assume "x\<in>S" |
|
2149 from assms(1) obtain a where a:"\<forall>x\<in>S. \<bar>x\<bar> \<le> a" unfolding bounded_real by auto |
|
2150 hence *:"- a <=* S" using setgeI[of S "-a"] unfolding abs_le_interval_iff by auto |
|
2151 thus "x \<ge> rinf S" using rinf[OF `S\<noteq>{}`] using isGlbD2[of UNIV S "rinf S" x] using `x\<in>S` by auto |
|
2152 next |
|
2153 show "\<forall>b. (\<forall>x\<in>S. x >= b) \<longrightarrow> rinf S \<ge> b" using assms |
|
2154 using rinf[of S, unfolded isGlb_def isLb_def greatestP_def setle_def setge_def] |
|
2155 apply (auto simp add: bounded_real) |
|
2156 by (auto simp add: isGlb_def isLb_def greatestP_def setle_def setge_def) |
|
2157 qed |
|
2158 |
|
2159 (* TODO: Move this to RComplete.thy -- would need to include Glb into RComplete *) |
|
2160 lemma real_isGlb_unique: "[| isGlb R S x; isGlb R S y |] ==> x = (y::real)" |
|
2161 apply (frule isGlb_isLb) |
|
2162 apply (frule_tac x = y in isGlb_isLb) |
|
2163 apply (blast intro!: order_antisym dest!: isGlb_le_isLb) |
|
2164 done |
|
2165 |
|
2166 lemma rinf_insert: assumes "bounded S" |
|
2167 shows "rinf(insert x S) = (if S = {} then x else min x (rinf S))" (is "?lhs = ?rhs") |
|
2168 proof(cases "S={}") |
|
2169 case True thus ?thesis using rinf_finite_in[of "{x}"] by auto |
|
2170 next |
|
2171 let ?S = "insert x S" |
|
2172 case False |
|
2173 hence *:"\<forall>x\<in>S. x \<ge> rinf S" using bounded_has_rinf(1)[of S] using assms by auto |
|
2174 hence "min x (rinf S) <=* insert x S" unfolding setge_def by auto |
|
2175 hence "isGlb UNIV ?S (rinf ?S)" using rinf[of ?S] by auto |
|
2176 moreover |
|
2177 have **:"isLb UNIV ?S (min x (rinf S))" unfolding isLb_def setge_def using * by auto |
|
2178 { fix y assume as:"isLb UNIV (insert x S) y" |
|
2179 hence "min x (rinf S) \<ge> y" unfolding isLb_def using rinf_ge[OF `S\<noteq>{}`] |
|
2180 unfolding setge_def by auto } |
|
2181 hence "isLb UNIV (insert x S) *<= min x (rinf S)" unfolding setle_def Ball_def mem_def by auto |
|
2182 hence "isGlb UNIV ?S (min x (rinf S))" using ** isGlbI2[of UNIV ?S "min x (rinf S)"] unfolding Collect_def by auto |
|
2183 ultimately show ?thesis using real_isGlb_unique[of UNIV ?S] using `S\<noteq>{}` by auto |
|
2184 qed |
|
2185 |
|
2186 lemma inf_insert_finite: "finite S ==> rinf(insert x S) = (if S = {} then x else min x (rinf S))" |
|
2187 by (rule rinf_insert, rule finite_imp_bounded, simp) |
|
2188 |
|
2189 subsection{* Compactness (the definition is the one based on convegent subsequences). *} |
|
2190 |
|
2191 definition |
|
2192 compact :: "'a::metric_space set \<Rightarrow> bool" where (* TODO: generalize *) |
|
2193 "compact S \<longleftrightarrow> |
|
2194 (\<forall>f. (\<forall>n. f n \<in> S) \<longrightarrow> |
|
2195 (\<exists>l\<in>S. \<exists>r. subseq r \<and> ((f o r) ---> l) sequentially))" |
|
2196 |
|
2197 text {* |
|
2198 A metric space (or topological vector space) is said to have the |
|
2199 Heine-Borel property if every closed and bounded subset is compact. |
|
2200 *} |
|
2201 |
|
2202 class heine_borel = |
|
2203 assumes bounded_imp_convergent_subsequence: |
|
2204 "bounded s \<Longrightarrow> \<forall>n. f n \<in> s |
|
2205 \<Longrightarrow> \<exists>l r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" |
|
2206 |
|
2207 lemma bounded_closed_imp_compact: |
|
2208 fixes s::"'a::heine_borel set" |
|
2209 assumes "bounded s" and "closed s" shows "compact s" |
|
2210 proof (unfold compact_def, clarify) |
|
2211 fix f :: "nat \<Rightarrow> 'a" assume f: "\<forall>n. f n \<in> s" |
|
2212 obtain l r where r: "subseq r" and l: "((f \<circ> r) ---> l) sequentially" |
|
2213 using bounded_imp_convergent_subsequence [OF `bounded s` `\<forall>n. f n \<in> s`] by auto |
|
2214 from f have fr: "\<forall>n. (f \<circ> r) n \<in> s" by simp |
|
2215 have "l \<in> s" using `closed s` fr l |
|
2216 unfolding closed_sequential_limits by blast |
|
2217 show "\<exists>l\<in>s. \<exists>r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" |
|
2218 using `l \<in> s` r l by blast |
|
2219 qed |
|
2220 |
|
2221 lemma subseq_bigger: assumes "subseq r" shows "n \<le> r n" |
|
2222 proof(induct n) |
|
2223 show "0 \<le> r 0" by auto |
|
2224 next |
|
2225 fix n assume "n \<le> r n" |
|
2226 moreover have "r n < r (Suc n)" |
|
2227 using assms [unfolded subseq_def] by auto |
|
2228 ultimately show "Suc n \<le> r (Suc n)" by auto |
|
2229 qed |
|
2230 |
|
2231 lemma eventually_subseq: |
|
2232 assumes r: "subseq r" |
|
2233 shows "eventually P sequentially \<Longrightarrow> eventually (\<lambda>n. P (r n)) sequentially" |
|
2234 unfolding eventually_sequentially |
|
2235 by (metis subseq_bigger [OF r] le_trans) |
|
2236 |
|
2237 lemma lim_subseq: |
|
2238 "subseq r \<Longrightarrow> (s ---> l) sequentially \<Longrightarrow> ((s o r) ---> l) sequentially" |
|
2239 unfolding tendsto_def eventually_sequentially o_def |
|
2240 by (metis subseq_bigger le_trans) |
|
2241 |
|
2242 lemma num_Axiom: "EX! g. g 0 = e \<and> (\<forall>n. g (Suc n) = f n (g n))" |
|
2243 unfolding Ex1_def |
|
2244 apply (rule_tac x="nat_rec e f" in exI) |
|
2245 apply (rule conjI)+ |
|
2246 apply (rule def_nat_rec_0, simp) |
|
2247 apply (rule allI, rule def_nat_rec_Suc, simp) |
|
2248 apply (rule allI, rule impI, rule ext) |
|
2249 apply (erule conjE) |
|
2250 apply (induct_tac x) |
|
2251 apply (simp add: nat_rec_0) |
|
2252 apply (erule_tac x="n" in allE) |
|
2253 apply (simp) |
|
2254 done |
|
2255 |
|
2256 lemma convergent_bounded_increasing: fixes s ::"nat\<Rightarrow>real" |
|
2257 assumes "incseq s" and "\<forall>n. abs(s n) \<le> b" |
|
2258 shows "\<exists> l. \<forall>e::real>0. \<exists> N. \<forall>n \<ge> N. abs(s n - l) < e" |
|
2259 proof- |
|
2260 have "isUb UNIV (range s) b" using assms(2) and abs_le_D1 unfolding isUb_def and setle_def by auto |
|
2261 then obtain t where t:"isLub UNIV (range s) t" using reals_complete[of "range s" ] by auto |
|
2262 { fix e::real assume "e>0" and as:"\<forall>N. \<exists>n\<ge>N. \<not> \<bar>s n - t\<bar> < e" |
|
2263 { fix n::nat |
|
2264 obtain N where "N\<ge>n" and n:"\<bar>s N - t\<bar> \<ge> e" using as[THEN spec[where x=n]] by auto |
|
2265 have "t \<ge> s N" using isLub_isUb[OF t, unfolded isUb_def setle_def] by auto |
|
2266 with n have "s N \<le> t - e" using `e>0` by auto |
|
2267 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 } |
|
2268 hence "isUb UNIV (range s) (t - e)" unfolding isUb_def and setle_def by auto |
|
2269 hence False using isLub_le_isUb[OF t, of "t - e"] and `e>0` by auto } |
|
2270 thus ?thesis by blast |
|
2271 qed |
|
2272 |
|
2273 lemma convergent_bounded_monotone: fixes s::"nat \<Rightarrow> real" |
|
2274 assumes "\<forall>n. abs(s n) \<le> b" and "monoseq s" |
|
2275 shows "\<exists>l. \<forall>e::real>0. \<exists>N. \<forall>n\<ge>N. abs(s n - l) < e" |
|
2276 using convergent_bounded_increasing[of s b] assms using convergent_bounded_increasing[of "\<lambda>n. - s n" b] |
|
2277 unfolding monoseq_def incseq_def |
|
2278 apply auto unfolding minus_add_distrib[THEN sym, unfolded diff_minus[THEN sym]] |
|
2279 unfolding abs_minus_cancel by(rule_tac x="-l" in exI)auto |
|
2280 |
|
2281 lemma compact_real_lemma: |
|
2282 assumes "\<forall>n::nat. abs(s n) \<le> b" |
|
2283 shows "\<exists>(l::real) r. subseq r \<and> ((s \<circ> r) ---> l) sequentially" |
|
2284 proof- |
|
2285 obtain r where r:"subseq r" "monoseq (\<lambda>n. s (r n))" |
|
2286 using seq_monosub[of s] by auto |
|
2287 thus ?thesis using convergent_bounded_monotone[of "\<lambda>n. s (r n)" b] and assms |
|
2288 unfolding tendsto_iff dist_norm eventually_sequentially by auto |
|
2289 qed |
|
2290 |
|
2291 instance real :: heine_borel |
|
2292 proof |
|
2293 fix s :: "real set" and f :: "nat \<Rightarrow> real" |
|
2294 assume s: "bounded s" and f: "\<forall>n. f n \<in> s" |
|
2295 then obtain b where b: "\<forall>n. abs (f n) \<le> b" |
|
2296 unfolding bounded_iff by auto |
|
2297 obtain l :: real and r :: "nat \<Rightarrow> nat" where |
|
2298 r: "subseq r" and l: "((f \<circ> r) ---> l) sequentially" |
|
2299 using compact_real_lemma [OF b] by auto |
|
2300 thus "\<exists>l r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" |
|
2301 by auto |
|
2302 qed |
|
2303 |
|
2304 lemma bounded_component: "bounded s \<Longrightarrow> bounded ((\<lambda>x. x $ i) ` s)" |
|
2305 unfolding bounded_def |
|
2306 apply clarify |
|
2307 apply (rule_tac x="x $ i" in exI) |
|
2308 apply (rule_tac x="e" in exI) |
|
2309 apply clarify |
|
2310 apply (rule order_trans [OF dist_nth_le], simp) |
|
2311 done |
|
2312 |
|
2313 lemma compact_lemma: |
|
2314 fixes f :: "nat \<Rightarrow> 'a::heine_borel ^ 'n::finite" |
|
2315 assumes "bounded s" and "\<forall>n. f n \<in> s" |
|
2316 shows "\<forall>d. |
|
2317 \<exists>l r. subseq r \<and> |
|
2318 (\<forall>e>0. eventually (\<lambda>n. \<forall>i\<in>d. dist (f (r n) $ i) (l $ i) < e) sequentially)" |
|
2319 proof |
|
2320 fix d::"'n set" have "finite d" by simp |
|
2321 thus "\<exists>l::'a ^ 'n. \<exists>r. subseq r \<and> |
|
2322 (\<forall>e>0. eventually (\<lambda>n. \<forall>i\<in>d. dist (f (r n) $ i) (l $ i) < e) sequentially)" |
|
2323 proof(induct d) case empty thus ?case unfolding subseq_def by auto |
|
2324 next case (insert k d) |
|
2325 have s': "bounded ((\<lambda>x. x $ k) ` s)" using `bounded s` by (rule bounded_component) |
|
2326 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" |
|
2327 using insert(3) by auto |
|
2328 have f': "\<forall>n. f (r1 n) $ k \<in> (\<lambda>x. x $ k) ` s" using `\<forall>n. f n \<in> s` by simp |
|
2329 obtain l2 r2 where r2:"subseq r2" and lr2:"((\<lambda>i. f (r1 (r2 i)) $ k) ---> l2) sequentially" |
|
2330 using bounded_imp_convergent_subsequence[OF s' f'] unfolding o_def by auto |
|
2331 def r \<equiv> "r1 \<circ> r2" have r:"subseq r" |
|
2332 using r1 and r2 unfolding r_def o_def subseq_def by auto |
|
2333 moreover |
|
2334 def l \<equiv> "(\<chi> i. if i = k then l2 else l1$i)::'a^'n" |
|
2335 { fix e::real assume "e>0" |
|
2336 from lr1 `e>0` have N1:"eventually (\<lambda>n. \<forall>i\<in>d. dist (f (r1 n) $ i) (l1 $ i) < e) sequentially" by blast |
|
2337 from lr2 `e>0` have N2:"eventually (\<lambda>n. dist (f (r1 (r2 n)) $ k) l2 < e) sequentially" by (rule tendstoD) |
|
2338 from r2 N1 have N1': "eventually (\<lambda>n. \<forall>i\<in>d. dist (f (r1 (r2 n)) $ i) (l1 $ i) < e) sequentially" |
|
2339 by (rule eventually_subseq) |
|
2340 have "eventually (\<lambda>n. \<forall>i\<in>(insert k d). dist (f (r n) $ i) (l $ i) < e) sequentially" |
|
2341 using N1' N2 by (rule eventually_elim2, simp add: l_def r_def) |
|
2342 } |
|
2343 ultimately show ?case by auto |
|
2344 qed |
|
2345 qed |
|
2346 |
|
2347 instance "^" :: (heine_borel, finite) heine_borel |
|
2348 proof |
|
2349 fix s :: "('a ^ 'b) set" and f :: "nat \<Rightarrow> 'a ^ 'b" |
|
2350 assume s: "bounded s" and f: "\<forall>n. f n \<in> s" |
|
2351 then obtain l r where r: "subseq r" |
|
2352 and l: "\<forall>e>0. eventually (\<lambda>n. \<forall>i\<in>UNIV. dist (f (r n) $ i) (l $ i) < e) sequentially" |
|
2353 using compact_lemma [OF s f] by blast |
|
2354 let ?d = "UNIV::'b set" |
|
2355 { fix e::real assume "e>0" |
|
2356 hence "0 < e / (real_of_nat (card ?d))" |
|
2357 using zero_less_card_finite using divide_pos_pos[of e, of "real_of_nat (card ?d)"] by auto |
|
2358 with l have "eventually (\<lambda>n. \<forall>i. dist (f (r n) $ i) (l $ i) < e / (real_of_nat (card ?d))) sequentially" |
|
2359 by simp |
|
2360 moreover |
|
2361 { fix n assume n: "\<forall>i. dist (f (r n) $ i) (l $ i) < e / (real_of_nat (card ?d))" |
|
2362 have "dist (f (r n)) l \<le> (\<Sum>i\<in>?d. dist (f (r n) $ i) (l $ i))" |
|
2363 unfolding dist_vector_def using zero_le_dist by (rule setL2_le_setsum) |
|
2364 also have "\<dots> < (\<Sum>i\<in>?d. e / (real_of_nat (card ?d)))" |
|
2365 by (rule setsum_strict_mono) (simp_all add: n) |
|
2366 finally have "dist (f (r n)) l < e" by simp |
|
2367 } |
|
2368 ultimately have "eventually (\<lambda>n. dist (f (r n)) l < e) sequentially" |
|
2369 by (rule eventually_elim1) |
|
2370 } |
|
2371 hence *:"((f \<circ> r) ---> l) sequentially" unfolding o_def tendsto_iff by simp |
|
2372 with r show "\<exists>l r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" by auto |
|
2373 qed |
|
2374 |
|
2375 lemma bounded_fst: "bounded s \<Longrightarrow> bounded (fst ` s)" |
|
2376 unfolding bounded_def |
|
2377 apply clarify |
|
2378 apply (rule_tac x="a" in exI) |
|
2379 apply (rule_tac x="e" in exI) |
|
2380 apply clarsimp |
|
2381 apply (drule (1) bspec) |
|
2382 apply (simp add: dist_Pair_Pair) |
|
2383 apply (erule order_trans [OF real_sqrt_sum_squares_ge1]) |
|
2384 done |
|
2385 |
|
2386 lemma bounded_snd: "bounded s \<Longrightarrow> bounded (snd ` s)" |
|
2387 unfolding bounded_def |
|
2388 apply clarify |
|
2389 apply (rule_tac x="b" in exI) |
|
2390 apply (rule_tac x="e" in exI) |
|
2391 apply clarsimp |
|
2392 apply (drule (1) bspec) |
|
2393 apply (simp add: dist_Pair_Pair) |
|
2394 apply (erule order_trans [OF real_sqrt_sum_squares_ge2]) |
|
2395 done |
|
2396 |
|
2397 instance "*" :: (heine_borel, heine_borel) heine_borel |
|
2398 proof |
|
2399 fix s :: "('a * 'b) set" and f :: "nat \<Rightarrow> 'a * 'b" |
|
2400 assume s: "bounded s" and f: "\<forall>n. f n \<in> s" |
|
2401 from s have s1: "bounded (fst ` s)" by (rule bounded_fst) |
|
2402 from f have f1: "\<forall>n. fst (f n) \<in> fst ` s" by simp |
|
2403 obtain l1 r1 where r1: "subseq r1" |
|
2404 and l1: "((\<lambda>n. fst (f (r1 n))) ---> l1) sequentially" |
|
2405 using bounded_imp_convergent_subsequence [OF s1 f1] |
|
2406 unfolding o_def by fast |
|
2407 from s have s2: "bounded (snd ` s)" by (rule bounded_snd) |
|
2408 from f have f2: "\<forall>n. snd (f (r1 n)) \<in> snd ` s" by simp |
|
2409 obtain l2 r2 where r2: "subseq r2" |
|
2410 and l2: "((\<lambda>n. snd (f (r1 (r2 n)))) ---> l2) sequentially" |
|
2411 using bounded_imp_convergent_subsequence [OF s2 f2] |
|
2412 unfolding o_def by fast |
|
2413 have l1': "((\<lambda>n. fst (f (r1 (r2 n)))) ---> l1) sequentially" |
|
2414 using lim_subseq [OF r2 l1] unfolding o_def . |
|
2415 have l: "((f \<circ> (r1 \<circ> r2)) ---> (l1, l2)) sequentially" |
|
2416 using tendsto_Pair [OF l1' l2] unfolding o_def by simp |
|
2417 have r: "subseq (r1 \<circ> r2)" |
|
2418 using r1 r2 unfolding subseq_def by simp |
|
2419 show "\<exists>l r. subseq r \<and> ((f \<circ> r) ---> l) sequentially" |
|
2420 using l r by fast |
|
2421 qed |
|
2422 |
|
2423 subsection{* Completeness. *} |
|
2424 |
|
2425 lemma cauchy_def: |
|
2426 "Cauchy s \<longleftrightarrow> (\<forall>e>0. \<exists>N. \<forall>m n. m \<ge> N \<and> n \<ge> N --> dist(s m)(s n) < e)" |
|
2427 unfolding Cauchy_def by blast |
|
2428 |
|
2429 definition |
|
2430 complete :: "'a::metric_space set \<Rightarrow> bool" where |
|
2431 "complete s \<longleftrightarrow> (\<forall>f. (\<forall>n. f n \<in> s) \<and> Cauchy f |
|
2432 --> (\<exists>l \<in> s. (f ---> l) sequentially))" |
|
2433 |
|
2434 lemma cauchy: "Cauchy s \<longleftrightarrow> (\<forall>e>0.\<exists> N::nat. \<forall>n\<ge>N. dist(s n)(s N) < e)" (is "?lhs = ?rhs") |
|
2435 proof- |
|
2436 { assume ?rhs |
|
2437 { fix e::real |
|
2438 assume "e>0" |
|
2439 with `?rhs` obtain N where N:"\<forall>n\<ge>N. dist (s n) (s N) < e/2" |
|
2440 by (erule_tac x="e/2" in allE) auto |
|
2441 { fix n m |
|
2442 assume nm:"N \<le> m \<and> N \<le> n" |
|
2443 hence "dist (s m) (s n) < e" using N |
|
2444 using dist_triangle_half_l[of "s m" "s N" "e" "s n"] |
|
2445 by blast |
|
2446 } |
|
2447 hence "\<exists>N. \<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist (s m) (s n) < e" |
|
2448 by blast |
|
2449 } |
|
2450 hence ?lhs |
|
2451 unfolding cauchy_def |
|
2452 by blast |
|
2453 } |
|
2454 thus ?thesis |
|
2455 unfolding cauchy_def |
|
2456 using dist_triangle_half_l |
|
2457 by blast |
|
2458 qed |
|
2459 |
|
2460 lemma convergent_imp_cauchy: |
|
2461 "(s ---> l) sequentially ==> Cauchy s" |
|
2462 proof(simp only: cauchy_def, rule, rule) |
|
2463 fix e::real assume "e>0" "(s ---> l) sequentially" |
|
2464 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 |
|
2465 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 |
|
2466 qed |
|
2467 |
|
2468 lemma cauchy_imp_bounded: assumes "Cauchy s" shows "bounded {y. (\<exists>n::nat. y = s n)}" |
|
2469 proof- |
|
2470 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 |
|
2471 hence N:"\<forall>n. N \<le> n \<longrightarrow> dist (s N) (s n) < 1" by auto |
|
2472 moreover |
|
2473 have "bounded (s ` {0..N})" using finite_imp_bounded[of "s ` {1..N}"] by auto |
|
2474 then obtain a where a:"\<forall>x\<in>s ` {0..N}. dist (s N) x \<le> a" |
|
2475 unfolding bounded_any_center [where a="s N"] by auto |
|
2476 ultimately show "?thesis" |
|
2477 unfolding bounded_any_center [where a="s N"] |
|
2478 apply(rule_tac x="max a 1" in exI) apply auto |
|
2479 apply(erule_tac x=n in allE) apply(erule_tac x=n in ballE) by auto |
|
2480 qed |
|
2481 |
|
2482 lemma compact_imp_complete: assumes "compact s" shows "complete s" |
|
2483 proof- |
|
2484 { fix f assume as: "(\<forall>n::nat. f n \<in> s)" "Cauchy f" |
|
2485 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 |
|
2486 |
|
2487 note lr' = subseq_bigger [OF lr(2)] |
|
2488 |
|
2489 { fix e::real assume "e>0" |
|
2490 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 |
|
2491 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 |
|
2492 { fix n::nat assume n:"n \<ge> max N M" |
|
2493 have "dist ((f \<circ> r) n) l < e/2" using n M by auto |
|
2494 moreover have "r n \<ge> N" using lr'[of n] n by auto |
|
2495 hence "dist (f n) ((f \<circ> r) n) < e / 2" using N using n by auto |
|
2496 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) } |
|
2497 hence "\<exists>N. \<forall>n\<ge>N. dist (f n) l < e" by blast } |
|
2498 hence "\<exists>l\<in>s. (f ---> l) sequentially" using `l\<in>s` unfolding Lim_sequentially by auto } |
|
2499 thus ?thesis unfolding complete_def by auto |
|
2500 qed |
|
2501 |
|
2502 instance heine_borel < complete_space |
|
2503 proof |
|
2504 fix f :: "nat \<Rightarrow> 'a" assume "Cauchy f" |
|
2505 hence "bounded (range f)" unfolding image_def |
|
2506 using cauchy_imp_bounded [of f] by auto |
|
2507 hence "compact (closure (range f))" |
|
2508 using bounded_closed_imp_compact [of "closure (range f)"] by auto |
|
2509 hence "complete (closure (range f))" |
|
2510 using compact_imp_complete by auto |
|
2511 moreover have "\<forall>n. f n \<in> closure (range f)" |
|
2512 using closure_subset [of "range f"] by auto |
|
2513 ultimately have "\<exists>l\<in>closure (range f). (f ---> l) sequentially" |
|
2514 using `Cauchy f` unfolding complete_def by auto |
|
2515 then show "convergent f" |
|
2516 unfolding convergent_def LIMSEQ_conv_tendsto [symmetric] by auto |
|
2517 qed |
|
2518 |
|
2519 lemma complete_univ: "complete (UNIV :: 'a::complete_space set)" |
|
2520 proof(simp add: complete_def, rule, rule) |
|
2521 fix f :: "nat \<Rightarrow> 'a" assume "Cauchy f" |
|
2522 hence "convergent f" by (rule Cauchy_convergent) |
|
2523 hence "\<exists>l. f ----> l" unfolding convergent_def . |
|
2524 thus "\<exists>l. (f ---> l) sequentially" unfolding LIMSEQ_conv_tendsto . |
|
2525 qed |
|
2526 |
|
2527 lemma complete_imp_closed: assumes "complete s" shows "closed s" |
|
2528 proof - |
|
2529 { fix x assume "x islimpt s" |
|
2530 then obtain f where f: "\<forall>n. f n \<in> s - {x}" "(f ---> x) sequentially" |
|
2531 unfolding islimpt_sequential by auto |
|
2532 then obtain l where l: "l\<in>s" "(f ---> l) sequentially" |
|
2533 using `complete s`[unfolded complete_def] using convergent_imp_cauchy[of f x] by auto |
|
2534 hence "x \<in> s" using Lim_unique[of sequentially f l x] trivial_limit_sequentially f(2) by auto |
|
2535 } |
|
2536 thus "closed s" unfolding closed_limpt by auto |
|
2537 qed |
|
2538 |
|
2539 lemma complete_eq_closed: |
|
2540 fixes s :: "'a::complete_space set" |
|
2541 shows "complete s \<longleftrightarrow> closed s" (is "?lhs = ?rhs") |
|
2542 proof |
|
2543 assume ?lhs thus ?rhs by (rule complete_imp_closed) |
|
2544 next |
|
2545 assume ?rhs |
|
2546 { fix f assume as:"\<forall>n::nat. f n \<in> s" "Cauchy f" |
|
2547 then obtain l where "(f ---> l) sequentially" using complete_univ[unfolded complete_def, THEN spec[where x=f]] by auto |
|
2548 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 } |
|
2549 thus ?lhs unfolding complete_def by auto |
|
2550 qed |
|
2551 |
|
2552 lemma convergent_eq_cauchy: |
|
2553 fixes s :: "nat \<Rightarrow> 'a::complete_space" |
|
2554 shows "(\<exists>l. (s ---> l) sequentially) \<longleftrightarrow> Cauchy s" (is "?lhs = ?rhs") |
|
2555 proof |
|
2556 assume ?lhs then obtain l where "(s ---> l) sequentially" by auto |
|
2557 thus ?rhs using convergent_imp_cauchy by auto |
|
2558 next |
|
2559 assume ?rhs thus ?lhs using complete_univ[unfolded complete_def, THEN spec[where x=s]] by auto |
|
2560 qed |
|
2561 |
|
2562 lemma convergent_imp_bounded: |
|
2563 fixes s :: "nat \<Rightarrow> 'a::metric_space" |
|
2564 shows "(s ---> l) sequentially ==> bounded (s ` (UNIV::(nat set)))" |
|
2565 using convergent_imp_cauchy[of s] |
|
2566 using cauchy_imp_bounded[of s] |
|
2567 unfolding image_def |
|
2568 by auto |
|
2569 |
|
2570 subsection{* Total boundedness. *} |
|
2571 |
|
2572 fun helper_1::"('a::metric_space set) \<Rightarrow> real \<Rightarrow> nat \<Rightarrow> 'a" where |
|
2573 "helper_1 s e n = (SOME y::'a. y \<in> s \<and> (\<forall>m<n. \<not> (dist (helper_1 s e m) y < e)))" |
|
2574 declare helper_1.simps[simp del] |
|
2575 |
|
2576 lemma compact_imp_totally_bounded: |
|
2577 assumes "compact s" |
|
2578 shows "\<forall>e>0. \<exists>k. finite k \<and> k \<subseteq> s \<and> s \<subseteq> (\<Union>((\<lambda>x. ball x e) ` k))" |
|
2579 proof(rule, rule, rule ccontr) |
|
2580 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)" |
|
2581 def x \<equiv> "helper_1 s e" |
|
2582 { fix n |
|
2583 have "x n \<in> s \<and> (\<forall>m<n. \<not> dist (x m) (x n) < e)" |
|
2584 proof(induct_tac rule:nat_less_induct) |
|
2585 fix n def Q \<equiv> "(\<lambda>y. y \<in> s \<and> (\<forall>m<n. \<not> dist (x m) y < e))" |
|
2586 assume as:"\<forall>m<n. x m \<in> s \<and> (\<forall>ma<m. \<not> dist (x ma) (x m) < e)" |
|
2587 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 |
|
2588 then obtain z where z:"z\<in>s" "z \<notin> (\<Union>x\<in>x ` {0..<n}. ball x e)" unfolding subset_eq by auto |
|
2589 have "Q (x n)" unfolding x_def and helper_1.simps[of s e n] |
|
2590 apply(rule someI2[where a=z]) unfolding x_def[symmetric] and Q_def using z by auto |
|
2591 thus "x n \<in> s \<and> (\<forall>m<n. \<not> dist (x m) (x n) < e)" unfolding Q_def by auto |
|
2592 qed } |
|
2593 hence "\<forall>n::nat. x n \<in> s" and x:"\<forall>n. \<forall>m < n. \<not> (dist (x m) (x n) < e)" by blast+ |
|
2594 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 |
|
2595 from this(3) have "Cauchy (x \<circ> r)" using convergent_imp_cauchy by auto |
|
2596 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 |
|
2597 show False |
|
2598 using N[THEN spec[where x=N], THEN spec[where x="N+1"]] |
|
2599 using r[unfolded subseq_def, THEN spec[where x=N], THEN spec[where x="N+1"]] |
|
2600 using x[THEN spec[where x="r (N+1)"], THEN spec[where x="r (N)"]] by auto |
|
2601 qed |
|
2602 |
|
2603 subsection{* Heine-Borel theorem (following Burkill \& Burkill vol. 2) *} |
|
2604 |
|
2605 lemma heine_borel_lemma: fixes s::"'a::metric_space set" |
|
2606 assumes "compact s" "s \<subseteq> (\<Union> t)" "\<forall>b \<in> t. open b" |
|
2607 shows "\<exists>e>0. \<forall>x \<in> s. \<exists>b \<in> t. ball x e \<subseteq> b" |
|
2608 proof(rule ccontr) |
|
2609 assume "\<not> (\<exists>e>0. \<forall>x\<in>s. \<exists>b\<in>t. ball x e \<subseteq> b)" |
|
2610 hence cont:"\<forall>e>0. \<exists>x\<in>s. \<forall>xa\<in>t. \<not> (ball x e \<subseteq> xa)" by auto |
|
2611 { fix n::nat |
|
2612 have "1 / real (n + 1) > 0" by auto |
|
2613 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 } |
|
2614 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 |
|
2615 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)" |
|
2616 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 |
|
2617 |
|
2618 then obtain l r where l:"l\<in>s" and r:"subseq r" and lr:"((f \<circ> r) ---> l) sequentially" |
|
2619 using assms(1)[unfolded compact_def, THEN spec[where x=f]] by auto |
|
2620 |
|
2621 obtain b where "l\<in>b" "b\<in>t" using assms(2) and l by auto |
|
2622 then obtain e where "e>0" and e:"\<forall>z. dist z l < e \<longrightarrow> z\<in>b" |
|
2623 using assms(3)[THEN bspec[where x=b]] unfolding open_dist by auto |
|
2624 |
|
2625 then obtain N1 where N1:"\<forall>n\<ge>N1. dist ((f \<circ> r) n) l < e / 2" |
|
2626 using lr[unfolded Lim_sequentially, THEN spec[where x="e/2"]] by auto |
|
2627 |
|
2628 obtain N2::nat where N2:"N2>0" "inverse (real N2) < e /2" using real_arch_inv[of "e/2"] and `e>0` by auto |
|
2629 have N2':"inverse (real (r (N1 + N2) +1 )) < e/2" |
|
2630 apply(rule order_less_trans) apply(rule less_imp_inverse_less) using N2 |
|
2631 using subseq_bigger[OF r, of "N1 + N2"] by auto |
|
2632 |
|
2633 def x \<equiv> "(f (r (N1 + N2)))" |
|
2634 have x:"\<not> ball x (inverse (real (r (N1 + N2) + 1))) \<subseteq> b" unfolding x_def |
|
2635 using f[THEN spec[where x="r (N1 + N2)"]] using `b\<in>t` by auto |
|
2636 have "\<exists>y\<in>ball x (inverse (real (r (N1 + N2) + 1))). y\<notin>b" apply(rule ccontr) using x by auto |
|
2637 then obtain y where y:"y \<in> ball x (inverse (real (r (N1 + N2) + 1)))" "y \<notin> b" by auto |
|
2638 |
|
2639 have "dist x l < e/2" using N1 unfolding x_def o_def by auto |
|
2640 hence "dist y l < e" using y N2' using dist_triangle[of y l x]by (auto simp add:dist_commute) |
|
2641 |
|
2642 thus False using e and `y\<notin>b` by auto |
|
2643 qed |
|
2644 |
|
2645 lemma compact_imp_heine_borel: "compact s ==> (\<forall>f. (\<forall>t \<in> f. open t) \<and> s \<subseteq> (\<Union> f) |
|
2646 \<longrightarrow> (\<exists>f'. f' \<subseteq> f \<and> finite f' \<and> s \<subseteq> (\<Union> f')))" |
|
2647 proof clarify |
|
2648 fix f assume "compact s" " \<forall>t\<in>f. open t" "s \<subseteq> \<Union>f" |
|
2649 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 |
|
2650 hence "\<forall>x\<in>s. \<exists>b. b\<in>f \<and> ball x e \<subseteq> b" by auto |
|
2651 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 |
|
2652 then obtain bb where bb:"\<forall>x\<in>s. (bb x) \<in> f \<and> ball x e \<subseteq> (bb x)" by blast |
|
2653 |
|
2654 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 |
|
2655 then obtain k where k:"finite k" "k \<subseteq> s" "s \<subseteq> \<Union>(\<lambda>x. ball x e) ` k" by auto |
|
2656 |
|
2657 have "finite (bb ` k)" using k(1) by auto |
|
2658 moreover |
|
2659 { fix x assume "x\<in>s" |
|
2660 hence "x\<in>\<Union>(\<lambda>x. ball x e) ` k" using k(3) unfolding subset_eq by auto |
|
2661 hence "\<exists>X\<in>bb ` k. x \<in> X" using bb k(2) by blast |
|
2662 hence "x \<in> \<Union>(bb ` k)" using Union_iff[of x "bb ` k"] by auto |
|
2663 } |
|
2664 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 |
|
2665 qed |
|
2666 |
|
2667 subsection{* Bolzano-Weierstrass property. *} |
|
2668 |
|
2669 lemma heine_borel_imp_bolzano_weierstrass: |
|
2670 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'))" |
|
2671 "infinite t" "t \<subseteq> s" |
|
2672 shows "\<exists>x \<in> s. x islimpt t" |
|
2673 proof(rule ccontr) |
|
2674 assume "\<not> (\<exists>x \<in> s. x islimpt t)" |
|
2675 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 |
|
2676 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 |
|
2677 obtain g where g:"g\<subseteq>{t. \<exists>x. x \<in> s \<and> t = f x}" "finite g" "s \<subseteq> \<Union>g" |
|
2678 using assms(1)[THEN spec[where x="{t. \<exists>x. x\<in>s \<and> t = f x}"]] using f by auto |
|
2679 from g(1,3) have g':"\<forall>x\<in>g. \<exists>xa \<in> s. x = f xa" by auto |
|
2680 { fix x y assume "x\<in>t" "y\<in>t" "f x = f y" |
|
2681 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 |
|
2682 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 } |
|
2683 hence "infinite (f ` t)" using assms(2) using finite_imageD[unfolded inj_on_def, of f t] by auto |
|
2684 moreover |
|
2685 { fix x assume "x\<in>t" "f x \<notin> g" |
|
2686 from g(3) assms(3) `x\<in>t` obtain h where "h\<in>g" and "x\<in>h" by auto |
|
2687 then obtain y where "y\<in>s" "h = f y" using g'[THEN bspec[where x=h]] by auto |
|
2688 hence "y = x" using f[THEN bspec[where x=y]] and `x\<in>t` and `x\<in>h`[unfolded `h = f y`] by auto |
|
2689 hence False using `f x \<notin> g` `h\<in>g` unfolding `h = f y` by auto } |
|
2690 hence "f ` t \<subseteq> g" by auto |
|
2691 ultimately show False using g(2) using finite_subset by auto |
|
2692 qed |
|
2693 |
|
2694 subsection{* Complete the chain of compactness variants. *} |
|
2695 |
|
2696 primrec helper_2::"(real \<Rightarrow> 'a::metric_space) \<Rightarrow> nat \<Rightarrow> 'a" where |
|
2697 "helper_2 beyond 0 = beyond 0" | |
|
2698 "helper_2 beyond (Suc n) = beyond (dist arbitrary (helper_2 beyond n) + 1 )" |
|
2699 |
|
2700 lemma bolzano_weierstrass_imp_bounded: fixes s::"'a::metric_space set" |
|
2701 assumes "\<forall>t. infinite t \<and> t \<subseteq> s --> (\<exists>x \<in> s. x islimpt t)" |
|
2702 shows "bounded s" |
|
2703 proof(rule ccontr) |
|
2704 assume "\<not> bounded s" |
|
2705 then obtain beyond where "\<forall>a. beyond a \<in>s \<and> \<not> dist arbitrary (beyond a) \<le> a" |
|
2706 unfolding bounded_any_center [where a=arbitrary] |
|
2707 apply simp using choice[of "\<lambda>a x. x\<in>s \<and> \<not> dist arbitrary x \<le> a"] by auto |
|
2708 hence beyond:"\<And>a. beyond a \<in>s" "\<And>a. dist arbitrary (beyond a) > a" |
|
2709 unfolding linorder_not_le by auto |
|
2710 def x \<equiv> "helper_2 beyond" |
|
2711 |
|
2712 { fix m n ::nat assume "m<n" |
|
2713 hence "dist arbitrary (x m) + 1 < dist arbitrary (x n)" |
|
2714 proof(induct n) |
|
2715 case 0 thus ?case by auto |
|
2716 next |
|
2717 case (Suc n) |
|
2718 have *:"dist arbitrary (x n) + 1 < dist arbitrary (x (Suc n))" |
|
2719 unfolding x_def and helper_2.simps |
|
2720 using beyond(2)[of "dist arbitrary (helper_2 beyond n) + 1"] by auto |
|
2721 thus ?case proof(cases "m < n") |
|
2722 case True thus ?thesis using Suc and * by auto |
|
2723 next |
|
2724 case False hence "m = n" using Suc(2) by auto |
|
2725 thus ?thesis using * by auto |
|
2726 qed |
|
2727 qed } note * = this |
|
2728 { fix m n ::nat assume "m\<noteq>n" |
|
2729 have "1 < dist (x m) (x n)" |
|
2730 proof(cases "m<n") |
|
2731 case True |
|
2732 hence "1 < dist arbitrary (x n) - dist arbitrary (x m)" using *[of m n] by auto |
|
2733 thus ?thesis using dist_triangle [of arbitrary "x n" "x m"] by arith |
|
2734 next |
|
2735 case False hence "n<m" using `m\<noteq>n` by auto |
|
2736 hence "1 < dist arbitrary (x m) - dist arbitrary (x n)" using *[of n m] by auto |
|
2737 thus ?thesis using dist_triangle2 [of arbitrary "x m" "x n"] by arith |
|
2738 qed } note ** = this |
|
2739 { fix a b assume "x a = x b" "a \<noteq> b" |
|
2740 hence False using **[of a b] by auto } |
|
2741 hence "inj x" unfolding inj_on_def by auto |
|
2742 moreover |
|
2743 { fix n::nat |
|
2744 have "x n \<in> s" |
|
2745 proof(cases "n = 0") |
|
2746 case True thus ?thesis unfolding x_def using beyond by auto |
|
2747 next |
|
2748 case False then obtain z where "n = Suc z" using not0_implies_Suc by auto |
|
2749 thus ?thesis unfolding x_def using beyond by auto |
|
2750 qed } |
|
2751 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 |
|
2752 |
|
2753 then obtain l where "l\<in>s" and l:"l islimpt range x" using assms[THEN spec[where x="range x"]] by auto |
|
2754 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 |
|
2755 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"]] |
|
2756 unfolding dist_nz by auto |
|
2757 show False using y and z and dist_triangle_half_l[of "x y" l 1 "x z"] and **[of y z] by auto |
|
2758 qed |
|
2759 |
|
2760 lemma sequence_infinite_lemma: |
|
2761 fixes l :: "'a::metric_space" (* TODO: generalize *) |
|
2762 assumes "\<forall>n::nat. (f n \<noteq> l)" "(f ---> l) sequentially" |
|
2763 shows "infinite {y. (\<exists> n. y = f n)}" |
|
2764 proof(rule ccontr) |
|
2765 let ?A = "(\<lambda>x. dist x l) ` {y. \<exists>n. y = f n}" |
|
2766 assume "\<not> infinite {y. \<exists>n. y = f n}" |
|
2767 hence **:"finite ?A" "?A \<noteq> {}" by auto |
|
2768 obtain k where k:"dist (f k) l = Min ?A" using Min_in[OF **] by auto |
|
2769 have "0 < Min ?A" using assms(1) unfolding dist_nz unfolding Min_gr_iff[OF **] by auto |
|
2770 then obtain N where "dist (f N) l < Min ?A" using assms(2)[unfolded Lim_sequentially, THEN spec[where x="Min ?A"]] by auto |
|
2771 moreover have "dist (f N) l \<in> ?A" by auto |
|
2772 ultimately show False using Min_le[OF **(1), of "dist (f N) l"] by auto |
|
2773 qed |
|
2774 |
|
2775 lemma sequence_unique_limpt: |
|
2776 fixes l :: "'a::metric_space" (* TODO: generalize *) |
|
2777 assumes "\<forall>n::nat. (f n \<noteq> l)" "(f ---> l) sequentially" "l' islimpt {y. (\<exists>n. y = f n)}" |
|
2778 shows "l' = l" |
|
2779 proof(rule ccontr) |
|
2780 def e \<equiv> "dist l' l" |
|
2781 assume "l' \<noteq> l" hence "e>0" unfolding dist_nz e_def by auto |
|
2782 then obtain N::nat where N:"\<forall>n\<ge>N. dist (f n) l < e / 2" |
|
2783 using assms(2)[unfolded Lim_sequentially, THEN spec[where x="e/2"]] by auto |
|
2784 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}))" |
|
2785 have "d>0" using `e>0` unfolding d_def e_def using zero_le_dist[of _ l', unfolded order_le_less] by auto |
|
2786 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 |
|
2787 have "k\<ge>N" using k(1)[unfolded dist_nz] using k(2)[unfolded d_def] |
|
2788 by force |
|
2789 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 |
|
2790 thus False unfolding e_def by auto |
|
2791 qed |
|
2792 |
|
2793 lemma bolzano_weierstrass_imp_closed: |
|
2794 fixes s :: "'a::metric_space set" (* TODO: can this be generalized? *) |
|
2795 assumes "\<forall>t. infinite t \<and> t \<subseteq> s --> (\<exists>x \<in> s. x islimpt t)" |
|
2796 shows "closed s" |
|
2797 proof- |
|
2798 { fix x l assume as: "\<forall>n::nat. x n \<in> s" "(x ---> l) sequentially" |
|
2799 hence "l \<in> s" |
|
2800 proof(cases "\<forall>n. x n \<noteq> l") |
|
2801 case False thus "l\<in>s" using as(1) by auto |
|
2802 next |
|
2803 case True note cas = this |
|
2804 with as(2) have "infinite {y. \<exists>n. y = x n}" using sequence_infinite_lemma[of x l] by auto |
|
2805 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 |
|
2806 thus "l\<in>s" using sequence_unique_limpt[of x l l'] using as cas by auto |
|
2807 qed } |
|
2808 thus ?thesis unfolding closed_sequential_limits by fast |
|
2809 qed |
|
2810 |
|
2811 text{* Hence express everything as an equivalence. *} |
|
2812 |
|
2813 lemma compact_eq_heine_borel: |
|
2814 fixes s :: "'a::heine_borel set" |
|
2815 shows "compact s \<longleftrightarrow> |
|
2816 (\<forall>f. (\<forall>t \<in> f. open t) \<and> s \<subseteq> (\<Union> f) |
|
2817 --> (\<exists>f'. f' \<subseteq> f \<and> finite f' \<and> s \<subseteq> (\<Union> f')))" (is "?lhs = ?rhs") |
|
2818 proof |
|
2819 assume ?lhs thus ?rhs using compact_imp_heine_borel[of s] by blast |
|
2820 next |
|
2821 assume ?rhs |
|
2822 hence "\<forall>t. infinite t \<and> t \<subseteq> s \<longrightarrow> (\<exists>x\<in>s. x islimpt t)" |
|
2823 by (blast intro: heine_borel_imp_bolzano_weierstrass[of s]) |
|
2824 thus ?lhs using bolzano_weierstrass_imp_bounded[of s] bolzano_weierstrass_imp_closed[of s] bounded_closed_imp_compact[of s] by blast |
|
2825 qed |
|
2826 |
|
2827 lemma compact_eq_bolzano_weierstrass: |
|
2828 fixes s :: "'a::heine_borel set" |
|
2829 shows "compact s \<longleftrightarrow> (\<forall>t. infinite t \<and> t \<subseteq> s --> (\<exists>x \<in> s. x islimpt t))" (is "?lhs = ?rhs") |
|
2830 proof |
|
2831 assume ?lhs thus ?rhs unfolding compact_eq_heine_borel using heine_borel_imp_bolzano_weierstrass[of s] by auto |
|
2832 next |
|
2833 assume ?rhs thus ?lhs using bolzano_weierstrass_imp_bounded bolzano_weierstrass_imp_closed bounded_closed_imp_compact by auto |
|
2834 qed |
|
2835 |
|
2836 lemma compact_eq_bounded_closed: |
|
2837 fixes s :: "'a::heine_borel set" |
|
2838 shows "compact s \<longleftrightarrow> bounded s \<and> closed s" (is "?lhs = ?rhs") |
|
2839 proof |
|
2840 assume ?lhs thus ?rhs unfolding compact_eq_bolzano_weierstrass using bolzano_weierstrass_imp_bounded bolzano_weierstrass_imp_closed by auto |
|
2841 next |
|
2842 assume ?rhs thus ?lhs using bounded_closed_imp_compact by auto |
|
2843 qed |
|
2844 |
|
2845 lemma compact_imp_bounded: |
|
2846 fixes s :: "'a::metric_space set" |
|
2847 shows "compact s ==> bounded s" |
|
2848 proof - |
|
2849 assume "compact s" |
|
2850 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')" |
|
2851 by (rule compact_imp_heine_borel) |
|
2852 hence "\<forall>t. infinite t \<and> t \<subseteq> s \<longrightarrow> (\<exists>x \<in> s. x islimpt t)" |
|
2853 using heine_borel_imp_bolzano_weierstrass[of s] by auto |
|
2854 thus "bounded s" |
|
2855 by (rule bolzano_weierstrass_imp_bounded) |
|
2856 qed |
|
2857 |
|
2858 lemma compact_imp_closed: |
|
2859 fixes s :: "'a::metric_space set" |
|
2860 shows "compact s ==> closed s" |
|
2861 proof - |
|
2862 assume "compact s" |
|
2863 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')" |
|
2864 by (rule compact_imp_heine_borel) |
|
2865 hence "\<forall>t. infinite t \<and> t \<subseteq> s \<longrightarrow> (\<exists>x \<in> s. x islimpt t)" |
|
2866 using heine_borel_imp_bolzano_weierstrass[of s] by auto |
|
2867 thus "closed s" |
|
2868 by (rule bolzano_weierstrass_imp_closed) |
|
2869 qed |
|
2870 |
|
2871 text{* In particular, some common special cases. *} |
|
2872 |
|
2873 lemma compact_empty[simp]: |
|
2874 "compact {}" |
|
2875 unfolding compact_def |
|
2876 by simp |
|
2877 |
|
2878 (* TODO: can any of the next 3 lemmas be generalized to metric spaces? *) |
|
2879 |
|
2880 (* FIXME : Rename *) |
|
2881 lemma compact_union[intro]: |
|
2882 fixes s t :: "'a::heine_borel set" |
|
2883 shows "compact s \<Longrightarrow> compact t ==> compact (s \<union> t)" |
|
2884 unfolding compact_eq_bounded_closed |
|
2885 using bounded_Un[of s t] |
|
2886 using closed_Un[of s t] |
|
2887 by simp |
|
2888 |
|
2889 lemma compact_inter[intro]: |
|
2890 fixes s t :: "'a::heine_borel set" |
|
2891 shows "compact s \<Longrightarrow> compact t ==> compact (s \<inter> t)" |
|
2892 unfolding compact_eq_bounded_closed |
|
2893 using bounded_Int[of s t] |
|
2894 using closed_Int[of s t] |
|
2895 by simp |
|
2896 |
|
2897 lemma compact_inter_closed[intro]: |
|
2898 fixes s t :: "'a::heine_borel set" |
|
2899 shows "compact s \<Longrightarrow> closed t ==> compact (s \<inter> t)" |
|
2900 unfolding compact_eq_bounded_closed |
|
2901 using closed_Int[of s t] |
|
2902 using bounded_subset[of "s \<inter> t" s] |
|
2903 by blast |
|
2904 |
|
2905 lemma closed_inter_compact[intro]: |
|
2906 fixes s t :: "'a::heine_borel set" |
|
2907 shows "closed s \<Longrightarrow> compact t ==> compact (s \<inter> t)" |
|
2908 proof- |
|
2909 assume "closed s" "compact t" |
|
2910 moreover |
|
2911 have "s \<inter> t = t \<inter> s" by auto ultimately |
|
2912 show ?thesis |
|
2913 using compact_inter_closed[of t s] |
|
2914 by auto |
|
2915 qed |
|
2916 |
|
2917 lemma closed_sing [simp]: |
|
2918 fixes a :: "'a::metric_space" |
|
2919 shows "closed {a}" |
|
2920 apply (clarsimp simp add: closed_def open_dist) |
|
2921 apply (rule ccontr) |
|
2922 apply (drule_tac x="dist x a" in spec) |
|
2923 apply (simp add: dist_nz dist_commute) |
|
2924 done |
|
2925 |
|
2926 lemma finite_imp_closed: |
|
2927 fixes s :: "'a::metric_space set" |
|
2928 shows "finite s ==> closed s" |
|
2929 proof (induct set: finite) |
|
2930 case empty show "closed {}" by simp |
|
2931 next |
|
2932 case (insert x F) |
|
2933 hence "closed ({x} \<union> F)" by (simp only: closed_Un closed_sing) |
|
2934 thus "closed (insert x F)" by simp |
|
2935 qed |
|
2936 |
|
2937 lemma finite_imp_compact: |
|
2938 fixes s :: "'a::heine_borel set" |
|
2939 shows "finite s ==> compact s" |
|
2940 unfolding compact_eq_bounded_closed |
|
2941 using finite_imp_closed finite_imp_bounded |
|
2942 by blast |
|
2943 |
|
2944 lemma compact_sing [simp]: "compact {a}" |
|
2945 unfolding compact_def o_def subseq_def |
|
2946 by (auto simp add: tendsto_const) |
|
2947 |
|
2948 lemma compact_cball[simp]: |
|
2949 fixes x :: "'a::heine_borel" |
|
2950 shows "compact(cball x e)" |
|
2951 using compact_eq_bounded_closed bounded_cball closed_cball |
|
2952 by blast |
|
2953 |
|
2954 lemma compact_frontier_bounded[intro]: |
|
2955 fixes s :: "'a::heine_borel set" |
|
2956 shows "bounded s ==> compact(frontier s)" |
|
2957 unfolding frontier_def |
|
2958 using compact_eq_bounded_closed |
|
2959 by blast |
|
2960 |
|
2961 lemma compact_frontier[intro]: |
|
2962 fixes s :: "'a::heine_borel set" |
|
2963 shows "compact s ==> compact (frontier s)" |
|
2964 using compact_eq_bounded_closed compact_frontier_bounded |
|
2965 by blast |
|
2966 |
|
2967 lemma frontier_subset_compact: |
|
2968 fixes s :: "'a::heine_borel set" |
|
2969 shows "compact s ==> frontier s \<subseteq> s" |
|
2970 using frontier_subset_closed compact_eq_bounded_closed |
|
2971 by blast |
|
2972 |
|
2973 lemma open_delete: |
|
2974 fixes s :: "'a::metric_space set" |
|
2975 shows "open s ==> open(s - {x})" |
|
2976 using open_Diff[of s "{x}"] closed_sing |
|
2977 by blast |
|
2978 |
|
2979 text{* Finite intersection property. I could make it an equivalence in fact. *} |
|
2980 |
|
2981 lemma compact_imp_fip: |
|
2982 fixes s :: "'a::heine_borel set" |
|
2983 assumes "compact s" "\<forall>t \<in> f. closed t" |
|
2984 "\<forall>f'. finite f' \<and> f' \<subseteq> f --> (s \<inter> (\<Inter> f') \<noteq> {})" |
|
2985 shows "s \<inter> (\<Inter> f) \<noteq> {}" |
|
2986 proof |
|
2987 assume as:"s \<inter> (\<Inter> f) = {}" |
|
2988 hence "s \<subseteq> \<Union>op - UNIV ` f" by auto |
|
2989 moreover have "Ball (op - UNIV ` f) open" using open_Diff closed_Diff using assms(2) by auto |
|
2990 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 |
|
2991 hence "finite (op - UNIV ` f') \<and> op - UNIV ` f' \<subseteq> f" by(auto simp add: Diff_Diff_Int) |
|
2992 hence "s \<inter> \<Inter>op - UNIV ` f' \<noteq> {}" using assms(3)[THEN spec[where x="op - UNIV ` f'"]] by auto |
|
2993 thus False using f'(3) unfolding subset_eq and Union_iff by blast |
|
2994 qed |
|
2995 |
|
2996 subsection{* Bounded closed nest property (proof does not use Heine-Borel). *} |
|
2997 |
|
2998 lemma bounded_closed_nest: |
|
2999 assumes "\<forall>n. closed(s n)" "\<forall>n. (s n \<noteq> {})" |
|
3000 "(\<forall>m n. m \<le> n --> s n \<subseteq> s m)" "bounded(s 0)" |
|
3001 shows "\<exists>a::'a::heine_borel. \<forall>n::nat. a \<in> s(n)" |
|
3002 proof- |
|
3003 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 |
|
3004 from assms(4,1) have *:"compact (s 0)" using bounded_closed_imp_compact[of "s 0"] by auto |
|
3005 |
|
3006 then obtain l r where lr:"l\<in>s 0" "subseq r" "((x \<circ> r) ---> l) sequentially" |
|
3007 unfolding compact_def apply(erule_tac x=x in allE) using x using assms(3) by blast |
|
3008 |
|
3009 { fix n::nat |
|
3010 { fix e::real assume "e>0" |
|
3011 with lr(3) obtain N where N:"\<forall>m\<ge>N. dist ((x \<circ> r) m) l < e" unfolding Lim_sequentially by auto |
|
3012 hence "dist ((x \<circ> r) (max N n)) l < e" by auto |
|
3013 moreover |
|
3014 have "r (max N n) \<ge> n" using lr(2) using subseq_bigger[of r "max N n"] by auto |
|
3015 hence "(x \<circ> r) (max N n) \<in> s n" |
|
3016 using x apply(erule_tac x=n in allE) |
|
3017 using x apply(erule_tac x="r (max N n)" in allE) |
|
3018 using assms(3) apply(erule_tac x=n in allE)apply( erule_tac x="r (max N n)" in allE) by auto |
|
3019 ultimately have "\<exists>y\<in>s n. dist y l < e" by auto |
|
3020 } |
|
3021 hence "l \<in> s n" using closed_approachable[of "s n" l] assms(1) by blast |
|
3022 } |
|
3023 thus ?thesis by auto |
|
3024 qed |
|
3025 |
|
3026 text{* Decreasing case does not even need compactness, just completeness. *} |
|
3027 |
|
3028 lemma decreasing_closed_nest: |
|
3029 assumes "\<forall>n. closed(s n)" |
|
3030 "\<forall>n. (s n \<noteq> {})" |
|
3031 "\<forall>m n. m \<le> n --> s n \<subseteq> s m" |
|
3032 "\<forall>e>0. \<exists>n. \<forall>x \<in> (s n). \<forall> y \<in> (s n). dist x y < e" |
|
3033 shows "\<exists>a::'a::heine_borel. \<forall>n::nat. a \<in> s n" |
|
3034 proof- |
|
3035 have "\<forall>n. \<exists> x. x\<in>s n" using assms(2) by auto |
|
3036 hence "\<exists>t. \<forall>n. t n \<in> s n" using choice[of "\<lambda> n x. x \<in> s n"] by auto |
|
3037 then obtain t where t: "\<forall>n. t n \<in> s n" by auto |
|
3038 { fix e::real assume "e>0" |
|
3039 then obtain N where N:"\<forall>x\<in>s N. \<forall>y\<in>s N. dist x y < e" using assms(4) by auto |
|
3040 { fix m n ::nat assume "N \<le> m \<and> N \<le> n" |
|
3041 hence "t m \<in> s N" "t n \<in> s N" using assms(3) t unfolding subset_eq t by blast+ |
|
3042 hence "dist (t m) (t n) < e" using N by auto |
|
3043 } |
|
3044 hence "\<exists>N. \<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist (t m) (t n) < e" by auto |
|
3045 } |
|
3046 hence "Cauchy t" unfolding cauchy_def by auto |
|
3047 then obtain l where l:"(t ---> l) sequentially" using complete_univ unfolding complete_def by auto |
|
3048 { fix n::nat |
|
3049 { fix e::real assume "e>0" |
|
3050 then obtain N::nat where N:"\<forall>n\<ge>N. dist (t n) l < e" using l[unfolded Lim_sequentially] by auto |
|
3051 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 |
|
3052 hence "\<exists>y\<in>s n. dist y l < e" apply(rule_tac x="t (max n N)" in bexI) using N by auto |
|
3053 } |
|
3054 hence "l \<in> s n" using closed_approachable[of "s n" l] assms(1) by auto |
|
3055 } |
|
3056 then show ?thesis by auto |
|
3057 qed |
|
3058 |
|
3059 text{* Strengthen it to the intersection actually being a singleton. *} |
|
3060 |
|
3061 lemma decreasing_closed_nest_sing: |
|
3062 assumes "\<forall>n. closed(s n)" |
|
3063 "\<forall>n. s n \<noteq> {}" |
|
3064 "\<forall>m n. m \<le> n --> s n \<subseteq> s m" |
|
3065 "\<forall>e>0. \<exists>n. \<forall>x \<in> (s n). \<forall> y\<in>(s n). dist x y < e" |
|
3066 shows "\<exists>a::'a::heine_borel. \<Inter> {t. (\<exists>n::nat. t = s n)} = {a}" |
|
3067 proof- |
|
3068 obtain a where a:"\<forall>n. a \<in> s n" using decreasing_closed_nest[of s] using assms by auto |
|
3069 { fix b assume b:"b \<in> \<Inter>{t. \<exists>n. t = s n}" |
|
3070 { fix e::real assume "e>0" |
|
3071 hence "dist a b < e" using assms(4 )using b using a by blast |
|
3072 } |
|
3073 hence "dist a b = 0" by (metis dist_eq_0_iff dist_nz real_less_def) |
|
3074 } |
|
3075 with a have "\<Inter>{t. \<exists>n. t = s n} = {a}" by auto |
|
3076 thus ?thesis by auto |
|
3077 qed |
|
3078 |
|
3079 text{* Cauchy-type criteria for uniform convergence. *} |
|
3080 |
|
3081 lemma uniformly_convergent_eq_cauchy: fixes s::"nat \<Rightarrow> 'b \<Rightarrow> 'a::heine_borel" shows |
|
3082 "(\<exists>l. \<forall>e>0. \<exists>N. \<forall>n x. N \<le> n \<and> P x --> dist(s n x)(l x) < e) \<longleftrightarrow> |
|
3083 (\<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") |
|
3084 proof(rule) |
|
3085 assume ?lhs |
|
3086 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 |
|
3087 { fix e::real assume "e>0" |
|
3088 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 |
|
3089 { fix n m::nat and x::"'b" assume "N \<le> m \<and> N \<le> n \<and> P x" |
|
3090 hence "dist (s m x) (s n x) < e" |
|
3091 using N[THEN spec[where x=m], THEN spec[where x=x]] |
|
3092 using N[THEN spec[where x=n], THEN spec[where x=x]] |
|
3093 using dist_triangle_half_l[of "s m x" "l x" e "s n x"] by auto } |
|
3094 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 } |
|
3095 thus ?rhs by auto |
|
3096 next |
|
3097 assume ?rhs |
|
3098 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 |
|
3099 then obtain l where l:"\<forall>x. P x \<longrightarrow> ((\<lambda>n. s n x) ---> l x) sequentially" unfolding convergent_eq_cauchy[THEN sym] |
|
3100 using choice[of "\<lambda>x l. P x \<longrightarrow> ((\<lambda>n. s n x) ---> l) sequentially"] by auto |
|
3101 { fix e::real assume "e>0" |
|
3102 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" |
|
3103 using `?rhs`[THEN spec[where x="e/2"]] by auto |
|
3104 { fix x assume "P x" |
|
3105 then obtain M where M:"\<forall>n\<ge>M. dist (s n x) (l x) < e/2" |
|
3106 using l[THEN spec[where x=x], unfolded Lim_sequentially] using `e>0` by(auto elim!: allE[where x="e/2"]) |
|
3107 fix n::nat assume "n\<ge>N" |
|
3108 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]] |
|
3109 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) } |
|
3110 hence "\<exists>N. \<forall>n x. N \<le> n \<and> P x \<longrightarrow> dist(s n x)(l x) < e" by auto } |
|
3111 thus ?lhs by auto |
|
3112 qed |
|
3113 |
|
3114 lemma uniformly_cauchy_imp_uniformly_convergent: |
|
3115 fixes s :: "nat \<Rightarrow> 'a \<Rightarrow> 'b::heine_borel" |
|
3116 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" |
|
3117 "\<forall>x. P x --> (\<forall>e>0. \<exists>N. \<forall>n. N \<le> n --> dist(s n x)(l x) < e)" |
|
3118 shows "\<forall>e>0. \<exists>N. \<forall>n x. N \<le> n \<and> P x --> dist(s n x)(l x) < e" |
|
3119 proof- |
|
3120 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" |
|
3121 using assms(1) unfolding uniformly_convergent_eq_cauchy[THEN sym] by auto |
|
3122 moreover |
|
3123 { fix x assume "P x" |
|
3124 hence "l x = l' x" using Lim_unique[OF trivial_limit_sequentially, of "\<lambda>n. s n x" "l x" "l' x"] |
|
3125 using l and assms(2) unfolding Lim_sequentially by blast } |
|
3126 ultimately show ?thesis by auto |
|
3127 qed |
|
3128 |
|
3129 subsection{* Define continuity over a net to take in restrictions of the set. *} |
|
3130 |
|
3131 definition |
|
3132 continuous :: "'a::t2_space net \<Rightarrow> ('a \<Rightarrow> 'b::topological_space) \<Rightarrow> bool" where |
|
3133 "continuous net f \<longleftrightarrow> (f ---> f(netlimit net)) net" |
|
3134 |
|
3135 lemma continuous_trivial_limit: |
|
3136 "trivial_limit net ==> continuous net f" |
|
3137 unfolding continuous_def tendsto_def trivial_limit_eq by auto |
|
3138 |
|
3139 lemma continuous_within: "continuous (at x within s) f \<longleftrightarrow> (f ---> f(x)) (at x within s)" |
|
3140 unfolding continuous_def |
|
3141 unfolding tendsto_def |
|
3142 using netlimit_within[of x s] |
|
3143 by (cases "trivial_limit (at x within s)") (auto simp add: trivial_limit_eventually) |
|
3144 |
|
3145 lemma continuous_at: "continuous (at x) f \<longleftrightarrow> (f ---> f(x)) (at x)" |
|
3146 using continuous_within [of x UNIV f] by (simp add: within_UNIV) |
|
3147 |
|
3148 lemma continuous_at_within: |
|
3149 assumes "continuous (at x) f" shows "continuous (at x within s) f" |
|
3150 using assms unfolding continuous_at continuous_within |
|
3151 by (rule Lim_at_within) |
|
3152 |
|
3153 text{* Derive the epsilon-delta forms, which we often use as "definitions" *} |
|
3154 |
|
3155 lemma continuous_within_eps_delta: |
|
3156 "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)" |
|
3157 unfolding continuous_within and Lim_within |
|
3158 apply auto unfolding dist_nz[THEN sym] apply(auto elim!:allE) apply(rule_tac x=d in exI) by auto |
|
3159 |
|
3160 lemma continuous_at_eps_delta: "continuous (at x) f \<longleftrightarrow> (\<forall>e>0. \<exists>d>0. |
|
3161 \<forall>x'. dist x' x < d --> dist(f x')(f x) < e)" |
|
3162 using continuous_within_eps_delta[of x UNIV f] |
|
3163 unfolding within_UNIV by blast |
|
3164 |
|
3165 text{* Versions in terms of open balls. *} |
|
3166 |
|
3167 lemma continuous_within_ball: |
|
3168 "continuous (at x within s) f \<longleftrightarrow> (\<forall>e>0. \<exists>d>0. |
|
3169 f ` (ball x d \<inter> s) \<subseteq> ball (f x) e)" (is "?lhs = ?rhs") |
|
3170 proof |
|
3171 assume ?lhs |
|
3172 { fix e::real assume "e>0" |
|
3173 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" |
|
3174 using `?lhs`[unfolded continuous_within Lim_within] by auto |
|
3175 { fix y assume "y\<in>f ` (ball x d \<inter> s)" |
|
3176 hence "y \<in> ball (f x) e" using d(2) unfolding dist_nz[THEN sym] |
|
3177 apply (auto simp add: dist_commute mem_ball) apply(erule_tac x=xa in ballE) apply auto using `e>0` by auto |
|
3178 } |
|
3179 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) } |
|
3180 thus ?rhs by auto |
|
3181 next |
|
3182 assume ?rhs thus ?lhs unfolding continuous_within Lim_within ball_def subset_eq |
|
3183 apply (auto simp add: dist_commute) apply(erule_tac x=e in allE) by auto |
|
3184 qed |
|
3185 |
|
3186 lemma continuous_at_ball: |
|
3187 "continuous (at x) f \<longleftrightarrow> (\<forall>e>0. \<exists>d>0. f ` (ball x d) \<subseteq> ball (f x) e)" (is "?lhs = ?rhs") |
|
3188 proof |
|
3189 assume ?lhs thus ?rhs unfolding continuous_at Lim_at subset_eq Ball_def Bex_def image_iff mem_ball |
|
3190 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) |
|
3191 unfolding dist_nz[THEN sym] by auto |
|
3192 next |
|
3193 assume ?rhs thus ?lhs unfolding continuous_at Lim_at subset_eq Ball_def Bex_def image_iff mem_ball |
|
3194 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) |
|
3195 qed |
|
3196 |
|
3197 text{* For setwise continuity, just start from the epsilon-delta definitions. *} |
|
3198 |
|
3199 definition |
|
3200 continuous_on :: "'a::metric_space set \<Rightarrow> ('a \<Rightarrow> 'b::metric_space) \<Rightarrow> bool" where |
|
3201 "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)" |
|
3202 |
|
3203 |
|
3204 definition |
|
3205 uniformly_continuous_on :: |
|
3206 "'a::metric_space set \<Rightarrow> ('a \<Rightarrow> 'b::metric_space) \<Rightarrow> bool" where |
|
3207 "uniformly_continuous_on s f \<longleftrightarrow> |
|
3208 (\<forall>e>0. \<exists>d>0. \<forall>x\<in>s. \<forall> x'\<in>s. dist x' x < d |
|
3209 --> dist (f x') (f x) < e)" |
|
3210 |
|
3211 text{* Some simple consequential lemmas. *} |
|
3212 |
|
3213 lemma uniformly_continuous_imp_continuous: |
|
3214 " uniformly_continuous_on s f ==> continuous_on s f" |
|
3215 unfolding uniformly_continuous_on_def continuous_on_def by blast |
|
3216 |
|
3217 lemma continuous_at_imp_continuous_within: |
|
3218 "continuous (at x) f ==> continuous (at x within s) f" |
|
3219 unfolding continuous_within continuous_at using Lim_at_within by auto |
|
3220 |
|
3221 lemma continuous_at_imp_continuous_on: assumes "(\<forall>x \<in> s. continuous (at x) f)" |
|
3222 shows "continuous_on s f" |
|
3223 proof(simp add: continuous_at continuous_on_def, rule, rule, rule) |
|
3224 fix x and e::real assume "x\<in>s" "e>0" |
|
3225 hence "eventually (\<lambda>xa. dist (f xa) (f x) < e) (at x)" using assms unfolding continuous_at tendsto_iff by auto |
|
3226 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 |
|
3227 { fix x' assume "\<not> 0 < dist x' x" |
|
3228 hence "x=x'" |
|
3229 using dist_nz[of x' x] by auto |
|
3230 hence "dist (f x') (f x) < e" using `e>0` by auto |
|
3231 } |
|
3232 thus "\<exists>d>0. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (f x') (f x) < e" using d by auto |
|
3233 qed |
|
3234 |
|
3235 lemma continuous_on_eq_continuous_within: |
|
3236 "continuous_on s f \<longleftrightarrow> (\<forall>x \<in> s. continuous (at x within s) f)" (is "?lhs = ?rhs") |
|
3237 proof |
|
3238 assume ?rhs |
|
3239 { fix x assume "x\<in>s" |
|
3240 fix e::real assume "e>0" |
|
3241 assume "\<exists>d>0. \<forall>xa\<in>s. 0 < dist xa x \<and> dist xa x < d \<longrightarrow> dist (f xa) (f x) < e" |
|
3242 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 |
|
3243 { fix x' assume as:"x'\<in>s" "dist x' x < d" |
|
3244 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) } |
|
3245 hence "\<exists>d>0. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (f x') (f x) < e" using `d>0` by auto |
|
3246 } |
|
3247 thus ?lhs using `?rhs` unfolding continuous_on_def continuous_within Lim_within by auto |
|
3248 next |
|
3249 assume ?lhs |
|
3250 thus ?rhs unfolding continuous_on_def continuous_within Lim_within by blast |
|
3251 qed |
|
3252 |
|
3253 lemma continuous_on: |
|
3254 "continuous_on s f \<longleftrightarrow> (\<forall>x \<in> s. (f ---> f(x)) (at x within s))" |
|
3255 by (auto simp add: continuous_on_eq_continuous_within continuous_within) |
|
3256 |
|
3257 lemma continuous_on_eq_continuous_at: |
|
3258 "open s ==> (continuous_on s f \<longleftrightarrow> (\<forall>x \<in> s. continuous (at x) f))" |
|
3259 by (auto simp add: continuous_on continuous_at Lim_within_open) |
|
3260 |
|
3261 lemma continuous_within_subset: |
|
3262 "continuous (at x within s) f \<Longrightarrow> t \<subseteq> s |
|
3263 ==> continuous (at x within t) f" |
|
3264 unfolding continuous_within by(metis Lim_within_subset) |
|
3265 |
|
3266 lemma continuous_on_subset: |
|
3267 "continuous_on s f \<Longrightarrow> t \<subseteq> s ==> continuous_on t f" |
|
3268 unfolding continuous_on by (metis subset_eq Lim_within_subset) |
|
3269 |
|
3270 lemma continuous_on_interior: |
|
3271 "continuous_on s f \<Longrightarrow> x \<in> interior s ==> continuous (at x) f" |
|
3272 unfolding interior_def |
|
3273 apply simp |
|
3274 by (meson continuous_on_eq_continuous_at continuous_on_subset) |
|
3275 |
|
3276 lemma continuous_on_eq: |
|
3277 "(\<forall>x \<in> s. f x = g x) \<Longrightarrow> continuous_on s f |
|
3278 ==> continuous_on s g" |
|
3279 by (simp add: continuous_on_def) |
|
3280 |
|
3281 text{* Characterization of various kinds of continuity in terms of sequences. *} |
|
3282 |
|
3283 (* \<longrightarrow> could be generalized, but \<longleftarrow> requires metric space *) |
|
3284 lemma continuous_within_sequentially: |
|
3285 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" |
|
3286 shows "continuous (at a within s) f \<longleftrightarrow> |
|
3287 (\<forall>x. (\<forall>n::nat. x n \<in> s) \<and> (x ---> a) sequentially |
|
3288 --> ((f o x) ---> f a) sequentially)" (is "?lhs = ?rhs") |
|
3289 proof |
|
3290 assume ?lhs |
|
3291 { 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" |
|
3292 fix e::real assume "e>0" |
|
3293 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 |
|
3294 from x(2) `d>0` obtain N where N:"\<forall>n\<ge>N. dist (x n) a < d" by auto |
|
3295 hence "\<exists>N. \<forall>n\<ge>N. dist ((f \<circ> x) n) (f a) < e" |
|
3296 apply(rule_tac x=N in exI) using N d apply auto using x(1) |
|
3297 apply(erule_tac x=n in allE) apply(erule_tac x=n in allE) |
|
3298 apply(erule_tac x="x n" in ballE) apply auto unfolding dist_nz[THEN sym] apply auto using `e>0` by auto |
|
3299 } |
|
3300 thus ?rhs unfolding continuous_within unfolding Lim_sequentially by simp |
|
3301 next |
|
3302 assume ?rhs |
|
3303 { fix e::real assume "e>0" |
|
3304 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)" |
|
3305 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 |
|
3306 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)" |
|
3307 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 |
|
3308 { fix d::real assume "d>0" |
|
3309 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 |
|
3310 then obtain N::nat where N:"inverse (real (N + 1)) < d" by auto |
|
3311 { fix n::nat assume n:"n\<ge>N" |
|
3312 hence "dist (x (inverse (real (n + 1)))) a < inverse (real (n + 1))" using x[THEN spec[where x="inverse (real (n + 1))"]] by auto |
|
3313 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) |
|
3314 ultimately have "dist (x (inverse (real (n + 1)))) a < d" by auto |
|
3315 } |
|
3316 hence "\<exists>N::nat. \<forall>n\<ge>N. dist (x (inverse (real (n + 1)))) a < d" by auto |
|
3317 } |
|
3318 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 |
|
3319 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 |
|
3320 hence "False" apply(erule_tac x=e in allE) using `e>0` using x by auto |
|
3321 } |
|
3322 thus ?lhs unfolding continuous_within unfolding Lim_within unfolding Lim_sequentially by blast |
|
3323 qed |
|
3324 |
|
3325 lemma continuous_at_sequentially: |
|
3326 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" |
|
3327 shows "continuous (at a) f \<longleftrightarrow> (\<forall>x. (x ---> a) sequentially |
|
3328 --> ((f o x) ---> f a) sequentially)" |
|
3329 using continuous_within_sequentially[of a UNIV f] unfolding within_UNIV by auto |
|
3330 |
|
3331 lemma continuous_on_sequentially: |
|
3332 "continuous_on s f \<longleftrightarrow> (\<forall>x. \<forall>a \<in> s. (\<forall>n. x(n) \<in> s) \<and> (x ---> a) sequentially |
|
3333 --> ((f o x) ---> f(a)) sequentially)" (is "?lhs = ?rhs") |
|
3334 proof |
|
3335 assume ?rhs thus ?lhs using continuous_within_sequentially[of _ s f] unfolding continuous_on_eq_continuous_within by auto |
|
3336 next |
|
3337 assume ?lhs thus ?rhs unfolding continuous_on_eq_continuous_within using continuous_within_sequentially[of _ s f] by auto |
|
3338 qed |
|
3339 |
|
3340 lemma uniformly_continuous_on_sequentially: |
|
3341 fixes f :: "'a::real_normed_vector \<Rightarrow> 'b::real_normed_vector" |
|
3342 shows "uniformly_continuous_on s f \<longleftrightarrow> (\<forall>x y. (\<forall>n. x n \<in> s) \<and> (\<forall>n. y n \<in> s) \<and> |
|
3343 ((\<lambda>n. x n - y n) ---> 0) sequentially |
|
3344 \<longrightarrow> ((\<lambda>n. f(x n) - f(y n)) ---> 0) sequentially)" (is "?lhs = ?rhs") |
|
3345 proof |
|
3346 assume ?lhs |
|
3347 { 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" |
|
3348 { fix e::real assume "e>0" |
|
3349 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" |
|
3350 using `?lhs`[unfolded uniformly_continuous_on_def, THEN spec[where x=e]] by auto |
|
3351 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 |
|
3352 { fix n assume "n\<ge>N" |
|
3353 hence "norm (f (x n) - f (y n) - 0) < e" |
|
3354 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 |
|
3355 unfolding dist_commute and dist_norm by simp } |
|
3356 hence "\<exists>N. \<forall>n\<ge>N. norm (f (x n) - f (y n) - 0) < e" by auto } |
|
3357 hence "((\<lambda>n. f(x n) - f(y n)) ---> 0) sequentially" unfolding Lim_sequentially and dist_norm by auto } |
|
3358 thus ?rhs by auto |
|
3359 next |
|
3360 assume ?rhs |
|
3361 { assume "\<not> ?lhs" |
|
3362 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 |
|
3363 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" |
|
3364 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 |
|
3365 by (auto simp add: dist_commute) |
|
3366 def x \<equiv> "\<lambda>n::nat. fst (fa (inverse (real n + 1)))" |
|
3367 def y \<equiv> "\<lambda>n::nat. snd (fa (inverse (real n + 1)))" |
|
3368 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" |
|
3369 unfolding x_def and y_def using fa by auto |
|
3370 have 1:"\<And>(x::'a) y. dist (x - y) 0 = dist x y" unfolding dist_norm by auto |
|
3371 have 2:"\<And>(x::'b) y. dist (x - y) 0 = dist x y" unfolding dist_norm by auto |
|
3372 { fix e::real assume "e>0" |
|
3373 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 |
|
3374 { fix n::nat assume "n\<ge>N" |
|
3375 hence "inverse (real n + 1) < inverse (real N)" using real_of_nat_ge_zero and `N\<noteq>0` by auto |
|
3376 also have "\<dots> < e" using N by auto |
|
3377 finally have "inverse (real n + 1) < e" by auto |
|
3378 hence "dist (x n - y n) 0 < e" unfolding 1 using xy0[THEN spec[where x=n]] by auto } |
|
3379 hence "\<exists>N. \<forall>n\<ge>N. dist (x n - y n) 0 < e" by auto } |
|
3380 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 |
|
3381 hence False unfolding 2 using fxy and `e>0` by auto } |
|
3382 thus ?lhs unfolding uniformly_continuous_on_def by blast |
|
3383 qed |
|
3384 |
|
3385 text{* The usual transformation theorems. *} |
|
3386 |
|
3387 lemma continuous_transform_within: |
|
3388 fixes f g :: "'a::metric_space \<Rightarrow> 'b::metric_space" |
|
3389 assumes "0 < d" "x \<in> s" "\<forall>x' \<in> s. dist x' x < d --> f x' = g x'" |
|
3390 "continuous (at x within s) f" |
|
3391 shows "continuous (at x within s) g" |
|
3392 proof- |
|
3393 { fix e::real assume "e>0" |
|
3394 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 |
|
3395 { fix x' assume "x'\<in>s" "0 < dist x' x" "dist x' x < (min d d')" |
|
3396 hence "dist (f x') (g x) < e" using assms(2,3) apply(erule_tac x=x in ballE) using d' by auto } |
|
3397 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 |
|
3398 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 } |
|
3399 hence "(f ---> g x) (at x within s)" unfolding Lim_within using assms(1) by auto |
|
3400 thus ?thesis unfolding continuous_within using Lim_transform_within[of d s x f g "g x"] using assms by blast |
|
3401 qed |
|
3402 |
|
3403 lemma continuous_transform_at: |
|
3404 fixes f g :: "'a::metric_space \<Rightarrow> 'b::metric_space" |
|
3405 assumes "0 < d" "\<forall>x'. dist x' x < d --> f x' = g x'" |
|
3406 "continuous (at x) f" |
|
3407 shows "continuous (at x) g" |
|
3408 proof- |
|
3409 { fix e::real assume "e>0" |
|
3410 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 |
|
3411 { fix x' assume "0 < dist x' x" "dist x' x < (min d d')" |
|
3412 hence "dist (f x') (g x) < e" using assms(2) apply(erule_tac x=x in allE) using d' by auto |
|
3413 } |
|
3414 hence "\<forall>xa. 0 < dist xa x \<and> dist xa x < (min d d') \<longrightarrow> dist (f xa) (g x) < e" by blast |
|
3415 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 |
|
3416 } |
|
3417 hence "(f ---> g x) (at x)" unfolding Lim_at using assms(1) by auto |
|
3418 thus ?thesis unfolding continuous_at using Lim_transform_at[of d x f g "g x"] using assms by blast |
|
3419 qed |
|
3420 |
|
3421 text{* Combination results for pointwise continuity. *} |
|
3422 |
|
3423 lemma continuous_const: "continuous net (\<lambda>x. c)" |
|
3424 by (auto simp add: continuous_def Lim_const) |
|
3425 |
|
3426 lemma continuous_cmul: |
|
3427 fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector" |
|
3428 shows "continuous net f ==> continuous net (\<lambda>x. c *\<^sub>R f x)" |
|
3429 by (auto simp add: continuous_def Lim_cmul) |
|
3430 |
|
3431 lemma continuous_neg: |
|
3432 fixes f :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector" |
|
3433 shows "continuous net f ==> continuous net (\<lambda>x. -(f x))" |
|
3434 by (auto simp add: continuous_def Lim_neg) |
|
3435 |
|
3436 lemma continuous_add: |
|
3437 fixes f g :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector" |
|
3438 shows "continuous net f \<Longrightarrow> continuous net g \<Longrightarrow> continuous net (\<lambda>x. f x + g x)" |
|
3439 by (auto simp add: continuous_def Lim_add) |
|
3440 |
|
3441 lemma continuous_sub: |
|
3442 fixes f g :: "'a::t2_space \<Rightarrow> 'b::real_normed_vector" |
|
3443 shows "continuous net f \<Longrightarrow> continuous net g \<Longrightarrow> continuous net (\<lambda>x. f x - g x)" |
|
3444 by (auto simp add: continuous_def Lim_sub) |
|
3445 |
|
3446 text{* Same thing for setwise continuity. *} |
|
3447 |
|
3448 lemma continuous_on_const: |
|
3449 "continuous_on s (\<lambda>x. c)" |
|
3450 unfolding continuous_on_eq_continuous_within using continuous_const by blast |
|
3451 |
|
3452 lemma continuous_on_cmul: |
|
3453 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3454 shows "continuous_on s f ==> continuous_on s (\<lambda>x. c *\<^sub>R (f x))" |
|
3455 unfolding continuous_on_eq_continuous_within using continuous_cmul by blast |
|
3456 |
|
3457 lemma continuous_on_neg: |
|
3458 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3459 shows "continuous_on s f \<Longrightarrow> continuous_on s (\<lambda>x. - f x)" |
|
3460 unfolding continuous_on_eq_continuous_within using continuous_neg by blast |
|
3461 |
|
3462 lemma continuous_on_add: |
|
3463 fixes f g :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3464 shows "continuous_on s f \<Longrightarrow> continuous_on s g |
|
3465 \<Longrightarrow> continuous_on s (\<lambda>x. f x + g x)" |
|
3466 unfolding continuous_on_eq_continuous_within using continuous_add by blast |
|
3467 |
|
3468 lemma continuous_on_sub: |
|
3469 fixes f g :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3470 shows "continuous_on s f \<Longrightarrow> continuous_on s g |
|
3471 \<Longrightarrow> continuous_on s (\<lambda>x. f x - g x)" |
|
3472 unfolding continuous_on_eq_continuous_within using continuous_sub by blast |
|
3473 |
|
3474 text{* Same thing for uniform continuity, using sequential formulations. *} |
|
3475 |
|
3476 lemma uniformly_continuous_on_const: |
|
3477 "uniformly_continuous_on s (\<lambda>x. c)" |
|
3478 unfolding uniformly_continuous_on_def by simp |
|
3479 |
|
3480 lemma uniformly_continuous_on_cmul: |
|
3481 fixes f :: "'a::real_normed_vector \<Rightarrow> 'b::real_normed_vector" |
|
3482 (* FIXME: generalize 'a to metric_space *) |
|
3483 assumes "uniformly_continuous_on s f" |
|
3484 shows "uniformly_continuous_on s (\<lambda>x. c *\<^sub>R f(x))" |
|
3485 proof- |
|
3486 { fix x y assume "((\<lambda>n. f (x n) - f (y n)) ---> 0) sequentially" |
|
3487 hence "((\<lambda>n. c *\<^sub>R f (x n) - c *\<^sub>R f (y n)) ---> 0) sequentially" |
|
3488 using Lim_cmul[of "(\<lambda>n. f (x n) - f (y n))" 0 sequentially c] |
|
3489 unfolding scaleR_zero_right scaleR_right_diff_distrib by auto |
|
3490 } |
|
3491 thus ?thesis using assms unfolding uniformly_continuous_on_sequentially by auto |
|
3492 qed |
|
3493 |
|
3494 lemma dist_minus: |
|
3495 fixes x y :: "'a::real_normed_vector" |
|
3496 shows "dist (- x) (- y) = dist x y" |
|
3497 unfolding dist_norm minus_diff_minus norm_minus_cancel .. |
|
3498 |
|
3499 lemma uniformly_continuous_on_neg: |
|
3500 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3501 shows "uniformly_continuous_on s f |
|
3502 ==> uniformly_continuous_on s (\<lambda>x. -(f x))" |
|
3503 unfolding uniformly_continuous_on_def dist_minus . |
|
3504 |
|
3505 lemma uniformly_continuous_on_add: |
|
3506 fixes f g :: "'a::real_normed_vector \<Rightarrow> 'b::real_normed_vector" (* FIXME: generalize 'a *) |
|
3507 assumes "uniformly_continuous_on s f" "uniformly_continuous_on s g" |
|
3508 shows "uniformly_continuous_on s (\<lambda>x. f x + g x)" |
|
3509 proof- |
|
3510 { fix x y assume "((\<lambda>n. f (x n) - f (y n)) ---> 0) sequentially" |
|
3511 "((\<lambda>n. g (x n) - g (y n)) ---> 0) sequentially" |
|
3512 hence "((\<lambda>xa. f (x xa) - f (y xa) + (g (x xa) - g (y xa))) ---> 0 + 0) sequentially" |
|
3513 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 |
|
3514 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 } |
|
3515 thus ?thesis using assms unfolding uniformly_continuous_on_sequentially by auto |
|
3516 qed |
|
3517 |
|
3518 lemma uniformly_continuous_on_sub: |
|
3519 fixes f :: "'a::real_normed_vector \<Rightarrow> 'b::real_normed_vector" (* FIXME: generalize 'a *) |
|
3520 shows "uniformly_continuous_on s f \<Longrightarrow> uniformly_continuous_on s g |
|
3521 ==> uniformly_continuous_on s (\<lambda>x. f x - g x)" |
|
3522 unfolding ab_diff_minus |
|
3523 using uniformly_continuous_on_add[of s f "\<lambda>x. - g x"] |
|
3524 using uniformly_continuous_on_neg[of s g] by auto |
|
3525 |
|
3526 text{* Identity function is continuous in every sense. *} |
|
3527 |
|
3528 lemma continuous_within_id: |
|
3529 "continuous (at a within s) (\<lambda>x. x)" |
|
3530 unfolding continuous_within by (rule Lim_at_within [OF Lim_ident_at]) |
|
3531 |
|
3532 lemma continuous_at_id: |
|
3533 "continuous (at a) (\<lambda>x. x)" |
|
3534 unfolding continuous_at by (rule Lim_ident_at) |
|
3535 |
|
3536 lemma continuous_on_id: |
|
3537 "continuous_on s (\<lambda>x. x)" |
|
3538 unfolding continuous_on Lim_within by auto |
|
3539 |
|
3540 lemma uniformly_continuous_on_id: |
|
3541 "uniformly_continuous_on s (\<lambda>x. x)" |
|
3542 unfolding uniformly_continuous_on_def by auto |
|
3543 |
|
3544 text{* Continuity of all kinds is preserved under composition. *} |
|
3545 |
|
3546 lemma continuous_within_compose: |
|
3547 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3548 fixes g :: "'b::metric_space \<Rightarrow> 'c::metric_space" |
|
3549 assumes "continuous (at x within s) f" "continuous (at (f x) within f ` s) g" |
|
3550 shows "continuous (at x within s) (g o f)" |
|
3551 proof- |
|
3552 { fix e::real assume "e>0" |
|
3553 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 |
|
3554 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 |
|
3555 { fix y assume as:"y\<in>s" "0 < dist y x" "dist y x < d'" |
|
3556 hence "dist (f y) (f x) < d" using d'[THEN bspec[where x=y]] by (auto simp add:dist_commute) |
|
3557 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 } |
|
3558 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 } |
|
3559 thus ?thesis unfolding continuous_within Lim_within by auto |
|
3560 qed |
|
3561 |
|
3562 lemma continuous_at_compose: |
|
3563 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3564 fixes g :: "'b::metric_space \<Rightarrow> 'c::metric_space" |
|
3565 assumes "continuous (at x) f" "continuous (at (f x)) g" |
|
3566 shows "continuous (at x) (g o f)" |
|
3567 proof- |
|
3568 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 |
|
3569 thus ?thesis using assms(1) using continuous_within_compose[of x UNIV f g, unfolded within_UNIV] by auto |
|
3570 qed |
|
3571 |
|
3572 lemma continuous_on_compose: |
|
3573 "continuous_on s f \<Longrightarrow> continuous_on (f ` s) g \<Longrightarrow> continuous_on s (g o f)" |
|
3574 unfolding continuous_on_eq_continuous_within using continuous_within_compose[of _ s f g] by auto |
|
3575 |
|
3576 lemma uniformly_continuous_on_compose: |
|
3577 assumes "uniformly_continuous_on s f" "uniformly_continuous_on (f ` s) g" |
|
3578 shows "uniformly_continuous_on s (g o f)" |
|
3579 proof- |
|
3580 { fix e::real assume "e>0" |
|
3581 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 |
|
3582 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 |
|
3583 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 } |
|
3584 thus ?thesis using assms unfolding uniformly_continuous_on_def by auto |
|
3585 qed |
|
3586 |
|
3587 text{* Continuity in terms of open preimages. *} |
|
3588 |
|
3589 lemma continuous_at_open: |
|
3590 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3591 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") |
|
3592 proof |
|
3593 assume ?lhs |
|
3594 { fix t assume as: "open t" "f x \<in> t" |
|
3595 then obtain e where "e>0" and e:"ball (f x) e \<subseteq> t" unfolding open_contains_ball by auto |
|
3596 |
|
3597 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 |
|
3598 |
|
3599 have "open (ball x d)" using open_ball by auto |
|
3600 moreover have "x \<in> ball x d" unfolding centre_in_ball using `d>0` by simp |
|
3601 moreover |
|
3602 { fix x' assume "x'\<in>ball x d" hence "f x' \<in> t" |
|
3603 using e[unfolded subset_eq Ball_def mem_ball, THEN spec[where x="f x'"]] d[THEN spec[where x=x']] |
|
3604 unfolding mem_ball apply (auto simp add: dist_commute) |
|
3605 unfolding dist_nz[THEN sym] using as(2) by auto } |
|
3606 hence "\<forall>x'\<in>ball x d. f x' \<in> t" by auto |
|
3607 ultimately have "\<exists>s. open s \<and> x \<in> s \<and> (\<forall>x'\<in>s. f x' \<in> t)" |
|
3608 apply(rule_tac x="ball x d" in exI) by simp } |
|
3609 thus ?rhs by auto |
|
3610 next |
|
3611 assume ?rhs |
|
3612 { fix e::real assume "e>0" |
|
3613 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"]] |
|
3614 unfolding centre_in_ball[of "f x" e, THEN sym] by auto |
|
3615 then obtain d where "d>0" and d:"ball x d \<subseteq> s" unfolding open_contains_ball by auto |
|
3616 { fix y assume "0 < dist y x \<and> dist y x < d" |
|
3617 hence "dist (f y) (f x) < e" using d[unfolded subset_eq Ball_def mem_ball, THEN spec[where x=y]] |
|
3618 using s(3)[THEN bspec[where x=y], unfolded mem_ball] by (auto simp add: dist_commute) } |
|
3619 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 } |
|
3620 thus ?lhs unfolding continuous_at Lim_at by auto |
|
3621 qed |
|
3622 |
|
3623 lemma continuous_on_open: |
|
3624 "continuous_on s f \<longleftrightarrow> |
|
3625 (\<forall>t. openin (subtopology euclidean (f ` s)) t |
|
3626 --> openin (subtopology euclidean s) {x \<in> s. f x \<in> t})" (is "?lhs = ?rhs") |
|
3627 proof |
|
3628 assume ?lhs |
|
3629 { fix t assume as:"openin (subtopology euclidean (f ` s)) t" |
|
3630 have "{x \<in> s. f x \<in> t} \<subseteq> s" using as[unfolded openin_euclidean_subtopology_iff] by auto |
|
3631 moreover |
|
3632 { fix x assume as':"x\<in>{x \<in> s. f x \<in> t}" |
|
3633 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 |
|
3634 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 |
|
3635 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) } |
|
3636 ultimately have "openin (subtopology euclidean s) {x \<in> s. f x \<in> t}" unfolding openin_euclidean_subtopology_iff by auto } |
|
3637 thus ?rhs unfolding continuous_on Lim_within using openin by auto |
|
3638 next |
|
3639 assume ?rhs |
|
3640 { fix e::real and x assume "x\<in>s" "e>0" |
|
3641 { 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)" |
|
3642 hence "dist (f x') (f x) < e" using dist_triangle[of "f x'" "f x" "f xa"] |
|
3643 by (auto simp add: dist_commute) } |
|
3644 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 |
|
3645 apply(rule_tac x="e - dist (f xa) (f x)" in exI) using `e>0` by (auto simp add: dist_commute) |
|
3646 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}" |
|
3647 using `?rhs`[unfolded openin_euclidean_subtopology_iff, THEN spec[where x="ball (f x) e \<inter> f ` s"]] by auto |
|
3648 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) } |
|
3649 thus ?lhs unfolding continuous_on Lim_within by auto |
|
3650 qed |
|
3651 |
|
3652 (* ------------------------------------------------------------------------- *) |
|
3653 (* Similarly in terms of closed sets. *) |
|
3654 (* ------------------------------------------------------------------------- *) |
|
3655 |
|
3656 lemma continuous_on_closed: |
|
3657 "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") |
|
3658 proof |
|
3659 assume ?lhs |
|
3660 { fix t |
|
3661 have *:"s - {x \<in> s. f x \<in> f ` s - t} = {x \<in> s. f x \<in> t}" by auto |
|
3662 have **:"f ` s - (f ` s - (f ` s - t)) = f ` s - t" by auto |
|
3663 assume as:"closedin (subtopology euclidean (f ` s)) t" |
|
3664 hence "closedin (subtopology euclidean (f ` s)) (f ` s - (f ` s - t))" unfolding closedin_def topspace_euclidean_subtopology unfolding ** by auto |
|
3665 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"]] |
|
3666 unfolding openin_closedin_eq topspace_euclidean_subtopology unfolding * by auto } |
|
3667 thus ?rhs by auto |
|
3668 next |
|
3669 assume ?rhs |
|
3670 { fix t |
|
3671 have *:"s - {x \<in> s. f x \<in> f ` s - t} = {x \<in> s. f x \<in> t}" by auto |
|
3672 assume as:"openin (subtopology euclidean (f ` s)) t" |
|
3673 hence "openin (subtopology euclidean s) {x \<in> s. f x \<in> t}" using `?rhs`[THEN spec[where x="(f ` s) - t"]] |
|
3674 unfolding openin_closedin_eq topspace_euclidean_subtopology *[THEN sym] closedin_subtopology by auto } |
|
3675 thus ?lhs unfolding continuous_on_open by auto |
|
3676 qed |
|
3677 |
|
3678 text{* Half-global and completely global cases. *} |
|
3679 |
|
3680 lemma continuous_open_in_preimage: |
|
3681 assumes "continuous_on s f" "open t" |
|
3682 shows "openin (subtopology euclidean s) {x \<in> s. f x \<in> t}" |
|
3683 proof- |
|
3684 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 |
|
3685 have "openin (subtopology euclidean (f ` s)) (t \<inter> f ` s)" |
|
3686 using openin_open_Int[of t "f ` s", OF assms(2)] unfolding openin_open by auto |
|
3687 thus ?thesis using assms(1)[unfolded continuous_on_open, THEN spec[where x="t \<inter> f ` s"]] using * by auto |
|
3688 qed |
|
3689 |
|
3690 lemma continuous_closed_in_preimage: |
|
3691 assumes "continuous_on s f" "closed t" |
|
3692 shows "closedin (subtopology euclidean s) {x \<in> s. f x \<in> t}" |
|
3693 proof- |
|
3694 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 |
|
3695 have "closedin (subtopology euclidean (f ` s)) (t \<inter> f ` s)" |
|
3696 using closedin_closed_Int[of t "f ` s", OF assms(2)] unfolding Int_commute by auto |
|
3697 thus ?thesis |
|
3698 using assms(1)[unfolded continuous_on_closed, THEN spec[where x="t \<inter> f ` s"]] using * by auto |
|
3699 qed |
|
3700 |
|
3701 lemma continuous_open_preimage: |
|
3702 assumes "continuous_on s f" "open s" "open t" |
|
3703 shows "open {x \<in> s. f x \<in> t}" |
|
3704 proof- |
|
3705 obtain T where T: "open T" "{x \<in> s. f x \<in> t} = s \<inter> T" |
|
3706 using continuous_open_in_preimage[OF assms(1,3)] unfolding openin_open by auto |
|
3707 thus ?thesis using open_Int[of s T, OF assms(2)] by auto |
|
3708 qed |
|
3709 |
|
3710 lemma continuous_closed_preimage: |
|
3711 assumes "continuous_on s f" "closed s" "closed t" |
|
3712 shows "closed {x \<in> s. f x \<in> t}" |
|
3713 proof- |
|
3714 obtain T where T: "closed T" "{x \<in> s. f x \<in> t} = s \<inter> T" |
|
3715 using continuous_closed_in_preimage[OF assms(1,3)] unfolding closedin_closed by auto |
|
3716 thus ?thesis using closed_Int[of s T, OF assms(2)] by auto |
|
3717 qed |
|
3718 |
|
3719 lemma continuous_open_preimage_univ: |
|
3720 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3721 shows "\<forall>x. continuous (at x) f \<Longrightarrow> open s \<Longrightarrow> open {x. f x \<in> s}" |
|
3722 using continuous_open_preimage[of UNIV f s] open_UNIV continuous_at_imp_continuous_on by auto |
|
3723 |
|
3724 lemma continuous_closed_preimage_univ: |
|
3725 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3726 shows "(\<forall>x. continuous (at x) f) \<Longrightarrow> closed s ==> closed {x. f x \<in> s}" |
|
3727 using continuous_closed_preimage[of UNIV f s] closed_UNIV continuous_at_imp_continuous_on by auto |
|
3728 |
|
3729 lemma continuous_open_vimage: |
|
3730 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3731 shows "\<forall>x. continuous (at x) f \<Longrightarrow> open s \<Longrightarrow> open (f -` s)" |
|
3732 unfolding vimage_def by (rule continuous_open_preimage_univ) |
|
3733 |
|
3734 lemma continuous_closed_vimage: |
|
3735 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3736 shows "\<forall>x. continuous (at x) f \<Longrightarrow> closed s \<Longrightarrow> closed (f -` s)" |
|
3737 unfolding vimage_def by (rule continuous_closed_preimage_univ) |
|
3738 |
|
3739 text{* Equality of continuous functions on closure and related results. *} |
|
3740 |
|
3741 lemma continuous_closed_in_preimage_constant: |
|
3742 "continuous_on s f ==> closedin (subtopology euclidean s) {x \<in> s. f x = a}" |
|
3743 using continuous_closed_in_preimage[of s f "{a}"] closed_sing by auto |
|
3744 |
|
3745 lemma continuous_closed_preimage_constant: |
|
3746 "continuous_on s f \<Longrightarrow> closed s ==> closed {x \<in> s. f x = a}" |
|
3747 using continuous_closed_preimage[of s f "{a}"] closed_sing by auto |
|
3748 |
|
3749 lemma continuous_constant_on_closure: |
|
3750 assumes "continuous_on (closure s) f" |
|
3751 "\<forall>x \<in> s. f x = a" |
|
3752 shows "\<forall>x \<in> (closure s). f x = a" |
|
3753 using continuous_closed_preimage_constant[of "closure s" f a] |
|
3754 assms closure_minimal[of s "{x \<in> closure s. f x = a}"] closure_subset unfolding subset_eq by auto |
|
3755 |
|
3756 lemma image_closure_subset: |
|
3757 assumes "continuous_on (closure s) f" "closed t" "(f ` s) \<subseteq> t" |
|
3758 shows "f ` (closure s) \<subseteq> t" |
|
3759 proof- |
|
3760 have "s \<subseteq> {x \<in> closure s. f x \<in> t}" using assms(3) closure_subset by auto |
|
3761 moreover have "closed {x \<in> closure s. f x \<in> t}" |
|
3762 using continuous_closed_preimage[OF assms(1)] and assms(2) by auto |
|
3763 ultimately have "closure s = {x \<in> closure s . f x \<in> t}" |
|
3764 using closure_minimal[of s "{x \<in> closure s. f x \<in> t}"] by auto |
|
3765 thus ?thesis by auto |
|
3766 qed |
|
3767 |
|
3768 lemma continuous_on_closure_norm_le: |
|
3769 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
3770 assumes "continuous_on (closure s) f" "\<forall>y \<in> s. norm(f y) \<le> b" "x \<in> (closure s)" |
|
3771 shows "norm(f x) \<le> b" |
|
3772 proof- |
|
3773 have *:"f ` s \<subseteq> cball 0 b" using assms(2)[unfolded mem_cball_0[THEN sym]] by auto |
|
3774 show ?thesis |
|
3775 using image_closure_subset[OF assms(1) closed_cball[of 0 b] *] assms(3) |
|
3776 unfolding subset_eq apply(erule_tac x="f x" in ballE) by (auto simp add: dist_norm) |
|
3777 qed |
|
3778 |
|
3779 text{* Making a continuous function avoid some value in a neighbourhood. *} |
|
3780 |
|
3781 lemma continuous_within_avoid: |
|
3782 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3783 assumes "continuous (at x within s) f" "x \<in> s" "f x \<noteq> a" |
|
3784 shows "\<exists>e>0. \<forall>y \<in> s. dist x y < e --> f y \<noteq> a" |
|
3785 proof- |
|
3786 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" |
|
3787 using assms(1)[unfolded continuous_within Lim_within, THEN spec[where x="dist (f x) a"]] assms(3)[unfolded dist_nz] by auto |
|
3788 { fix y assume " y\<in>s" "dist x y < d" |
|
3789 hence "f y \<noteq> a" using d[THEN bspec[where x=y]] assms(3)[unfolded dist_nz] |
|
3790 apply auto unfolding dist_nz[THEN sym] by (auto simp add: dist_commute) } |
|
3791 thus ?thesis using `d>0` by auto |
|
3792 qed |
|
3793 |
|
3794 lemma continuous_at_avoid: |
|
3795 fixes f :: "'a::metric_space \<Rightarrow> 'b::metric_space" (* FIXME: generalize *) |
|
3796 assumes "continuous (at x) f" "f x \<noteq> a" |
|
3797 shows "\<exists>e>0. \<forall>y. dist x y < e \<longrightarrow> f y \<noteq> a" |
|
3798 using assms using continuous_within_avoid[of x UNIV f a, unfolded within_UNIV] by auto |
|
3799 |
|
3800 lemma continuous_on_avoid: |
|
3801 assumes "continuous_on s f" "x \<in> s" "f x \<noteq> a" |
|
3802 shows "\<exists>e>0. \<forall>y \<in> s. dist x y < e \<longrightarrow> f y \<noteq> a" |
|
3803 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 |
|
3804 |
|
3805 lemma continuous_on_open_avoid: |
|
3806 assumes "continuous_on s f" "open s" "x \<in> s" "f x \<noteq> a" |
|
3807 shows "\<exists>e>0. \<forall>y. dist x y < e \<longrightarrow> f y \<noteq> a" |
|
3808 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 |
|
3809 |
|
3810 text{* Proving a function is constant by proving open-ness of level set. *} |
|
3811 |
|
3812 lemma continuous_levelset_open_in_cases: |
|
3813 "connected s \<Longrightarrow> continuous_on s f \<Longrightarrow> |
|
3814 openin (subtopology euclidean s) {x \<in> s. f x = a} |
|
3815 ==> (\<forall>x \<in> s. f x \<noteq> a) \<or> (\<forall>x \<in> s. f x = a)" |
|
3816 unfolding connected_clopen using continuous_closed_in_preimage_constant by auto |
|
3817 |
|
3818 lemma continuous_levelset_open_in: |
|
3819 "connected s \<Longrightarrow> continuous_on s f \<Longrightarrow> |
|
3820 openin (subtopology euclidean s) {x \<in> s. f x = a} \<Longrightarrow> |
|
3821 (\<exists>x \<in> s. f x = a) ==> (\<forall>x \<in> s. f x = a)" |
|
3822 using continuous_levelset_open_in_cases[of s f ] |
|
3823 by meson |
|
3824 |
|
3825 lemma continuous_levelset_open: |
|
3826 assumes "connected s" "continuous_on s f" "open {x \<in> s. f x = a}" "\<exists>x \<in> s. f x = a" |
|
3827 shows "\<forall>x \<in> s. f x = a" |
|
3828 using continuous_levelset_open_in[OF assms(1,2), of a, unfolded openin_open] using assms (3,4) by auto |
|
3829 |
|
3830 text{* Some arithmetical combinations (more to prove). *} |
|
3831 |
|
3832 lemma open_scaling[intro]: |
|
3833 fixes s :: "'a::real_normed_vector set" |
|
3834 assumes "c \<noteq> 0" "open s" |
|
3835 shows "open((\<lambda>x. c *\<^sub>R x) ` s)" |
|
3836 proof- |
|
3837 { fix x assume "x \<in> s" |
|
3838 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 |
|
3839 have "e * abs c > 0" using assms(1)[unfolded zero_less_abs_iff[THEN sym]] using real_mult_order[OF `e>0`] by auto |
|
3840 moreover |
|
3841 { fix y assume "dist y (c *\<^sub>R x) < e * \<bar>c\<bar>" |
|
3842 hence "norm ((1 / c) *\<^sub>R y - x) < e" unfolding dist_norm |
|
3843 using norm_scaleR[of c "(1 / c) *\<^sub>R y - x", unfolded scaleR_right_diff_distrib, unfolded scaleR_scaleR] assms(1) |
|
3844 assms(1)[unfolded zero_less_abs_iff[THEN sym]] by (simp del:zero_less_abs_iff) |
|
3845 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 } |
|
3846 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 } |
|
3847 thus ?thesis unfolding open_dist by auto |
|
3848 qed |
|
3849 |
|
3850 lemma minus_image_eq_vimage: |
|
3851 fixes A :: "'a::ab_group_add set" |
|
3852 shows "(\<lambda>x. - x) ` A = (\<lambda>x. - x) -` A" |
|
3853 by (auto intro!: image_eqI [where f="\<lambda>x. - x"]) |
|
3854 |
|
3855 lemma open_negations: |
|
3856 fixes s :: "'a::real_normed_vector set" |
|
3857 shows "open s ==> open ((\<lambda> x. -x) ` s)" |
|
3858 unfolding scaleR_minus1_left [symmetric] |
|
3859 by (rule open_scaling, auto) |
|
3860 |
|
3861 lemma open_translation: |
|
3862 fixes s :: "'a::real_normed_vector set" |
|
3863 assumes "open s" shows "open((\<lambda>x. a + x) ` s)" |
|
3864 proof- |
|
3865 { 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 } |
|
3866 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 |
|
3867 ultimately show ?thesis using continuous_open_preimage_univ[of "\<lambda>x. x - a" s] using assms by auto |
|
3868 qed |
|
3869 |
|
3870 lemma open_affinity: |
|
3871 fixes s :: "'a::real_normed_vector set" |
|
3872 assumes "open s" "c \<noteq> 0" |
|
3873 shows "open ((\<lambda>x. a + c *\<^sub>R x) ` s)" |
|
3874 proof- |
|
3875 have *:"(\<lambda>x. a + c *\<^sub>R x) = (\<lambda>x. a + x) \<circ> (\<lambda>x. c *\<^sub>R x)" unfolding o_def .. |
|
3876 have "op + a ` op *\<^sub>R c ` s = (op + a \<circ> op *\<^sub>R c) ` s" by auto |
|
3877 thus ?thesis using assms open_translation[of "op *\<^sub>R c ` s" a] unfolding * by auto |
|
3878 qed |
|
3879 |
|
3880 lemma interior_translation: |
|
3881 fixes s :: "'a::real_normed_vector set" |
|
3882 shows "interior ((\<lambda>x. a + x) ` s) = (\<lambda>x. a + x) ` (interior s)" |
|
3883 proof (rule set_ext, rule) |
|
3884 fix x assume "x \<in> interior (op + a ` s)" |
|
3885 then obtain e where "e>0" and e:"ball x e \<subseteq> op + a ` s" unfolding mem_interior by auto |
|
3886 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 |
|
3887 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 |
|
3888 next |
|
3889 fix x assume "x \<in> op + a ` interior s" |
|
3890 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 |
|
3891 { fix z have *:"a + y - z = y + a - z" by auto |
|
3892 assume "z\<in>ball x e" |
|
3893 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 |
|
3894 hence "z \<in> op + a ` s" unfolding image_iff by(auto intro!: bexI[where x="z - a"]) } |
|
3895 hence "ball x e \<subseteq> op + a ` s" unfolding subset_eq by auto |
|
3896 thus "x \<in> interior (op + a ` s)" unfolding mem_interior using `e>0` by auto |
|
3897 qed |
|
3898 |
|
3899 subsection {* Preservation of compactness and connectedness under continuous function. *} |
|
3900 |
|
3901 lemma compact_continuous_image: |
|
3902 assumes "continuous_on s f" "compact s" |
|
3903 shows "compact(f ` s)" |
|
3904 proof- |
|
3905 { fix x assume x:"\<forall>n::nat. x n \<in> f ` s" |
|
3906 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 |
|
3907 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 |
|
3908 { fix e::real assume "e>0" |
|
3909 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 |
|
3910 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 |
|
3911 { 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 } |
|
3912 hence "\<exists>N. \<forall>n\<ge>N. dist ((x \<circ> r) n) (f l) < e" by auto } |
|
3913 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 } |
|
3914 thus ?thesis unfolding compact_def by auto |
|
3915 qed |
|
3916 |
|
3917 lemma connected_continuous_image: |
|
3918 assumes "continuous_on s f" "connected s" |
|
3919 shows "connected(f ` s)" |
|
3920 proof- |
|
3921 { fix T assume as: "T \<noteq> {}" "T \<noteq> f ` s" "openin (subtopology euclidean (f ` s)) T" "closedin (subtopology euclidean (f ` s)) T" |
|
3922 have "{x \<in> s. f x \<in> T} = {} \<or> {x \<in> s. f x \<in> T} = s" |
|
3923 using assms(1)[unfolded continuous_on_open, THEN spec[where x=T]] |
|
3924 using assms(1)[unfolded continuous_on_closed, THEN spec[where x=T]] |
|
3925 using assms(2)[unfolded connected_clopen, THEN spec[where x="{x \<in> s. f x \<in> T}"]] as(3,4) by auto |
|
3926 hence False using as(1,2) |
|
3927 using as(4)[unfolded closedin_def topspace_euclidean_subtopology] by auto } |
|
3928 thus ?thesis unfolding connected_clopen by auto |
|
3929 qed |
|
3930 |
|
3931 text{* Continuity implies uniform continuity on a compact domain. *} |
|
3932 |
|
3933 lemma compact_uniformly_continuous: |
|
3934 assumes "continuous_on s f" "compact s" |
|
3935 shows "uniformly_continuous_on s f" |
|
3936 proof- |
|
3937 { fix x assume x:"x\<in>s" |
|
3938 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 |
|
3939 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 } |
|
3940 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 |
|
3941 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)" |
|
3942 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 |
|
3943 |
|
3944 { fix e::real assume "e>0" |
|
3945 |
|
3946 { 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 } |
|
3947 hence "s \<subseteq> \<Union>{ball x (d x (e / 2)) |x. x \<in> s}" unfolding subset_eq by auto |
|
3948 moreover |
|
3949 { fix b assume "b\<in>{ball x (d x (e / 2)) |x. x \<in> s}" hence "open b" by auto } |
|
3950 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 |
|
3951 |
|
3952 { fix x y assume "x\<in>s" "y\<in>s" and as:"dist y x < ea" |
|
3953 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 |
|
3954 hence "x\<in>ball z (d z (e / 2))" using `ea>0` unfolding subset_eq by auto |
|
3955 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` |
|
3956 by (auto simp add: dist_commute) |
|
3957 moreover have "y\<in>ball z (d z (e / 2))" using as and `ea>0` and z[unfolded subset_eq] |
|
3958 by (auto simp add: dist_commute) |
|
3959 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` |
|
3960 by (auto simp add: dist_commute) |
|
3961 ultimately have "dist (f y) (f x) < e" using dist_triangle_half_r[of "f z" "f x" e "f y"] |
|
3962 by (auto simp add: dist_commute) } |
|
3963 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 } |
|
3964 thus ?thesis unfolding uniformly_continuous_on_def by auto |
|
3965 qed |
|
3966 |
|
3967 text{* Continuity of inverse function on compact domain. *} |
|
3968 |
|
3969 lemma continuous_on_inverse: |
|
3970 fixes f :: "'a::heine_borel \<Rightarrow> 'b::heine_borel" |
|
3971 (* TODO: can this be generalized more? *) |
|
3972 assumes "continuous_on s f" "compact s" "\<forall>x \<in> s. g (f x) = x" |
|
3973 shows "continuous_on (f ` s) g" |
|
3974 proof- |
|
3975 have *:"g ` f ` s = s" using assms(3) by (auto simp add: image_iff) |
|
3976 { fix t assume t:"closedin (subtopology euclidean (g ` f ` s)) t" |
|
3977 then obtain T where T: "closed T" "t = s \<inter> T" unfolding closedin_closed unfolding * by auto |
|
3978 have "continuous_on (s \<inter> T) f" using continuous_on_subset[OF assms(1), of "s \<inter> t"] |
|
3979 unfolding T(2) and Int_left_absorb by auto |
|
3980 moreover have "compact (s \<inter> T)" |
|
3981 using assms(2) unfolding compact_eq_bounded_closed |
|
3982 using bounded_subset[of s "s \<inter> T"] and T(1) by auto |
|
3983 ultimately have "closed (f ` t)" using T(1) unfolding T(2) |
|
3984 using compact_continuous_image [of "s \<inter> T" f] unfolding compact_eq_bounded_closed by auto |
|
3985 moreover have "{x \<in> f ` s. g x \<in> t} = f ` s \<inter> f ` t" using assms(3) unfolding T(2) by auto |
|
3986 ultimately have "closedin (subtopology euclidean (f ` s)) {x \<in> f ` s. g x \<in> t}" |
|
3987 unfolding closedin_closed by auto } |
|
3988 thus ?thesis unfolding continuous_on_closed by auto |
|
3989 qed |
|
3990 |
|
3991 subsection{* A uniformly convergent limit of continuous functions is continuous. *} |
|
3992 |
|
3993 lemma norm_triangle_lt: |
|
3994 fixes x y :: "'a::real_normed_vector" |
|
3995 shows "norm x + norm y < e \<Longrightarrow> norm (x + y) < e" |
|
3996 by (rule le_less_trans [OF norm_triangle_ineq]) |
|
3997 |
|
3998 lemma continuous_uniform_limit: |
|
3999 fixes f :: "'a \<Rightarrow> 'b::metric_space \<Rightarrow> 'c::real_normed_vector" |
|
4000 assumes "\<not> (trivial_limit net)" "eventually (\<lambda>n. continuous_on s (f n)) net" |
|
4001 "\<forall>e>0. eventually (\<lambda>n. \<forall>x \<in> s. norm(f n x - g x) < e) net" |
|
4002 shows "continuous_on s g" |
|
4003 proof- |
|
4004 { fix x and e::real assume "x\<in>s" "e>0" |
|
4005 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 |
|
4006 then obtain n where n:"\<forall>xa\<in>s. norm (f n xa - g xa) < e / 3" "continuous_on s (f n)" |
|
4007 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 |
|
4008 have "e / 3 > 0" using `e>0` by auto |
|
4009 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" |
|
4010 using n(2)[unfolded continuous_on_def, THEN bspec[where x=x], OF `x\<in>s`, THEN spec[where x="e/3"]] by blast |
|
4011 { fix y assume "y\<in>s" "dist y x < d" |
|
4012 hence "dist (f n y) (f n x) < e / 3" using d[THEN bspec[where x=y]] by auto |
|
4013 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"] |
|
4014 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 |
|
4015 hence "dist (g y) (g x) < e" unfolding dist_norm using n(1)[THEN bspec[where x=y], OF `y\<in>s`] |
|
4016 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) } |
|
4017 hence "\<exists>d>0. \<forall>x'\<in>s. dist x' x < d \<longrightarrow> dist (g x') (g x) < e" using `d>0` by auto } |
|
4018 thus ?thesis unfolding continuous_on_def by auto |
|
4019 qed |
|
4020 |
|
4021 subsection{* Topological properties of linear functions. *} |
|
4022 |
|
4023 lemma linear_lim_0: |
|
4024 assumes "bounded_linear f" shows "(f ---> 0) (at (0))" |
|
4025 proof- |
|
4026 interpret f: bounded_linear f by fact |
|
4027 have "(f ---> f 0) (at 0)" |
|
4028 using tendsto_ident_at by (rule f.tendsto) |
|
4029 thus ?thesis unfolding f.zero . |
|
4030 qed |
|
4031 |
|
4032 lemma linear_continuous_at: |
|
4033 assumes "bounded_linear f" shows "continuous (at a) f" |
|
4034 unfolding continuous_at using assms |
|
4035 apply (rule bounded_linear.tendsto) |
|
4036 apply (rule tendsto_ident_at) |
|
4037 done |
|
4038 |
|
4039 lemma linear_continuous_within: |
|
4040 shows "bounded_linear f ==> continuous (at x within s) f" |
|
4041 using continuous_at_imp_continuous_within[of x f s] using linear_continuous_at[of f] by auto |
|
4042 |
|
4043 lemma linear_continuous_on: |
|
4044 shows "bounded_linear f ==> continuous_on s f" |
|
4045 using continuous_at_imp_continuous_on[of s f] using linear_continuous_at[of f] by auto |
|
4046 |
|
4047 text{* Also bilinear functions, in composition form. *} |
|
4048 |
|
4049 lemma bilinear_continuous_at_compose: |
|
4050 shows "continuous (at x) f \<Longrightarrow> continuous (at x) g \<Longrightarrow> bounded_bilinear h |
|
4051 ==> continuous (at x) (\<lambda>x. h (f x) (g x))" |
|
4052 unfolding continuous_at using Lim_bilinear[of f "f x" "(at x)" g "g x" h] by auto |
|
4053 |
|
4054 lemma bilinear_continuous_within_compose: |
|
4055 shows "continuous (at x within s) f \<Longrightarrow> continuous (at x within s) g \<Longrightarrow> bounded_bilinear h |
|
4056 ==> continuous (at x within s) (\<lambda>x. h (f x) (g x))" |
|
4057 unfolding continuous_within using Lim_bilinear[of f "f x"] by auto |
|
4058 |
|
4059 lemma bilinear_continuous_on_compose: |
|
4060 shows "continuous_on s f \<Longrightarrow> continuous_on s g \<Longrightarrow> bounded_bilinear h |
|
4061 ==> continuous_on s (\<lambda>x. h (f x) (g x))" |
|
4062 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 |
|
4063 using bilinear_continuous_within_compose[of _ s f g h] by auto |
|
4064 |
|
4065 subsection{* Topological stuff lifted from and dropped to R *} |
|
4066 |
|
4067 |
|
4068 lemma open_real: |
|
4069 fixes s :: "real set" shows |
|
4070 "open s \<longleftrightarrow> |
|
4071 (\<forall>x \<in> s. \<exists>e>0. \<forall>x'. abs(x' - x) < e --> x' \<in> s)" (is "?lhs = ?rhs") |
|
4072 unfolding open_dist dist_norm by simp |
|
4073 |
|
4074 lemma islimpt_approachable_real: |
|
4075 fixes s :: "real set" |
|
4076 shows "x islimpt s \<longleftrightarrow> (\<forall>e>0. \<exists>x'\<in> s. x' \<noteq> x \<and> abs(x' - x) < e)" |
|
4077 unfolding islimpt_approachable dist_norm by simp |
|
4078 |
|
4079 lemma closed_real: |
|
4080 fixes s :: "real set" |
|
4081 shows "closed s \<longleftrightarrow> |
|
4082 (\<forall>x. (\<forall>e>0. \<exists>x' \<in> s. x' \<noteq> x \<and> abs(x' - x) < e) |
|
4083 --> x \<in> s)" |
|
4084 unfolding closed_limpt islimpt_approachable dist_norm by simp |
|
4085 |
|
4086 lemma continuous_at_real_range: |
|
4087 fixes f :: "'a::real_normed_vector \<Rightarrow> real" |
|
4088 shows "continuous (at x) f \<longleftrightarrow> (\<forall>e>0. \<exists>d>0. |
|
4089 \<forall>x'. norm(x' - x) < d --> abs(f x' - f x) < e)" |
|
4090 unfolding continuous_at unfolding Lim_at |
|
4091 unfolding dist_nz[THEN sym] unfolding dist_norm apply auto |
|
4092 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 |
|
4093 apply(erule_tac x=e in allE) by auto |
|
4094 |
|
4095 lemma continuous_on_real_range: |
|
4096 fixes f :: "'a::real_normed_vector \<Rightarrow> real" |
|
4097 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))" |
|
4098 unfolding continuous_on_def dist_norm by simp |
|
4099 |
|
4100 lemma continuous_at_norm: "continuous (at x) norm" |
|
4101 unfolding continuous_at by (intro tendsto_intros) |
|
4102 |
|
4103 lemma continuous_on_norm: "continuous_on s norm" |
|
4104 unfolding continuous_on by (intro ballI tendsto_intros) |
|
4105 |
|
4106 lemma continuous_at_component: "continuous (at a) (\<lambda>x. x $ i)" |
|
4107 unfolding continuous_at by (intro tendsto_intros) |
|
4108 |
|
4109 lemma continuous_on_component: "continuous_on s (\<lambda>x. x $ i)" |
|
4110 unfolding continuous_on by (intro ballI tendsto_intros) |
|
4111 |
|
4112 lemma continuous_at_infnorm: "continuous (at x) infnorm" |
|
4113 unfolding continuous_at Lim_at o_def unfolding dist_norm |
|
4114 apply auto apply (rule_tac x=e in exI) apply auto |
|
4115 using order_trans[OF real_abs_sub_infnorm infnorm_le_norm, of _ x] by (metis xt1(7)) |
|
4116 |
|
4117 text{* Hence some handy theorems on distance, diameter etc. of/from a set. *} |
|
4118 |
|
4119 lemma compact_attains_sup: |
|
4120 fixes s :: "real set" |
|
4121 assumes "compact s" "s \<noteq> {}" |
|
4122 shows "\<exists>x \<in> s. \<forall>y \<in> s. y \<le> x" |
|
4123 proof- |
|
4124 from assms(1) have a:"bounded s" "closed s" unfolding compact_eq_bounded_closed by auto |
|
4125 { 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" |
|
4126 have "isLub UNIV s (rsup s)" using rsup[OF assms(2)] unfolding setle_def using as(1) by auto |
|
4127 moreover have "isUb UNIV s (rsup s - e)" unfolding isUb_def unfolding setle_def using as(4,2) by auto |
|
4128 ultimately have False using isLub_le_isUb[of UNIV s "rsup s" "rsup s - e"] using `e>0` by auto } |
|
4129 thus ?thesis using bounded_has_rsup(1)[OF a(1) assms(2)] using a(2)[unfolded closed_real, THEN spec[where x="rsup s"]] |
|
4130 apply(rule_tac x="rsup s" in bexI) by auto |
|
4131 qed |
|
4132 |
|
4133 lemma compact_attains_inf: |
|
4134 fixes s :: "real set" |
|
4135 assumes "compact s" "s \<noteq> {}" shows "\<exists>x \<in> s. \<forall>y \<in> s. x \<le> y" |
|
4136 proof- |
|
4137 from assms(1) have a:"bounded s" "closed s" unfolding compact_eq_bounded_closed by auto |
|
4138 { fix e::real assume as: "\<forall>x\<in>s. x \<ge> rinf s" "rinf s \<notin> s" "0 < e" |
|
4139 "\<forall>x'\<in>s. x' = rinf s \<or> \<not> abs (x' - rinf s) < e" |
|
4140 have "isGlb UNIV s (rinf s)" using rinf[OF assms(2)] unfolding setge_def using as(1) by auto |
|
4141 moreover |
|
4142 { fix x assume "x \<in> s" |
|
4143 hence *:"abs (x - rinf s) = x - rinf s" using as(1)[THEN bspec[where x=x]] by auto |
|
4144 have "rinf s + e \<le> x" using as(4)[THEN bspec[where x=x]] using as(2) `x\<in>s` unfolding * by auto } |
|
4145 hence "isLb UNIV s (rinf s + e)" unfolding isLb_def and setge_def by auto |
|
4146 ultimately have False using isGlb_le_isLb[of UNIV s "rinf s" "rinf s + e"] using `e>0` by auto } |
|
4147 thus ?thesis using bounded_has_rinf(1)[OF a(1) assms(2)] using a(2)[unfolded closed_real, THEN spec[where x="rinf s"]] |
|
4148 apply(rule_tac x="rinf s" in bexI) by auto |
|
4149 qed |
|
4150 |
|
4151 lemma continuous_attains_sup: |
|
4152 fixes f :: "'a::metric_space \<Rightarrow> real" |
|
4153 shows "compact s \<Longrightarrow> s \<noteq> {} \<Longrightarrow> continuous_on s f |
|
4154 ==> (\<exists>x \<in> s. \<forall>y \<in> s. f y \<le> f x)" |
|
4155 using compact_attains_sup[of "f ` s"] |
|
4156 using compact_continuous_image[of s f] by auto |
|
4157 |
|
4158 lemma continuous_attains_inf: |
|
4159 fixes f :: "'a::metric_space \<Rightarrow> real" |
|
4160 shows "compact s \<Longrightarrow> s \<noteq> {} \<Longrightarrow> continuous_on s f |
|
4161 \<Longrightarrow> (\<exists>x \<in> s. \<forall>y \<in> s. f x \<le> f y)" |
|
4162 using compact_attains_inf[of "f ` s"] |
|
4163 using compact_continuous_image[of s f] by auto |
|
4164 |
|
4165 lemma distance_attains_sup: |
|
4166 assumes "compact s" "s \<noteq> {}" |
|
4167 shows "\<exists>x \<in> s. \<forall>y \<in> s. dist a y \<le> dist a x" |
|
4168 proof (rule continuous_attains_sup [OF assms]) |
|
4169 { fix x assume "x\<in>s" |
|
4170 have "(dist a ---> dist a x) (at x within s)" |
|
4171 by (intro tendsto_dist tendsto_const Lim_at_within Lim_ident_at) |
|
4172 } |
|
4173 thus "continuous_on s (dist a)" |
|
4174 unfolding continuous_on .. |
|
4175 qed |
|
4176 |
|
4177 text{* For *minimal* distance, we only need closure, not compactness. *} |
|
4178 |
|
4179 lemma distance_attains_inf: |
|
4180 fixes a :: "'a::heine_borel" |
|
4181 assumes "closed s" "s \<noteq> {}" |
|
4182 shows "\<exists>x \<in> s. \<forall>y \<in> s. dist a x \<le> dist a y" |
|
4183 proof- |
|
4184 from assms(2) obtain b where "b\<in>s" by auto |
|
4185 let ?B = "cball a (dist b a) \<inter> s" |
|
4186 have "b \<in> ?B" using `b\<in>s` by (simp add: dist_commute) |
|
4187 hence "?B \<noteq> {}" by auto |
|
4188 moreover |
|
4189 { fix x assume "x\<in>?B" |
|
4190 fix e::real assume "e>0" |
|
4191 { fix x' assume "x'\<in>?B" and as:"dist x' x < e" |
|
4192 from as have "\<bar>dist a x' - dist a x\<bar> < e" |
|
4193 unfolding abs_less_iff minus_diff_eq |
|
4194 using dist_triangle2 [of a x' x] |
|
4195 using dist_triangle [of a x x'] |
|
4196 by arith |
|
4197 } |
|
4198 hence "\<exists>d>0. \<forall>x'\<in>?B. dist x' x < d \<longrightarrow> \<bar>dist a x' - dist a x\<bar> < e" |
|
4199 using `e>0` by auto |
|
4200 } |
|
4201 hence "continuous_on (cball a (dist b a) \<inter> s) (dist a)" |
|
4202 unfolding continuous_on Lim_within dist_norm real_norm_def |
|
4203 by fast |
|
4204 moreover have "compact ?B" |
|
4205 using compact_cball[of a "dist b a"] |
|
4206 unfolding compact_eq_bounded_closed |
|
4207 using bounded_Int and closed_Int and assms(1) by auto |
|
4208 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" |
|
4209 using continuous_attains_inf[of ?B "dist a"] by fastsimp |
|
4210 thus ?thesis by fastsimp |
|
4211 qed |
|
4212 |
|
4213 subsection{* We can now extend limit compositions to consider the scalar multiplier. *} |
|
4214 |
|
4215 lemma Lim_mul: |
|
4216 fixes f :: "'a \<Rightarrow> 'b::real_normed_vector" |
|
4217 assumes "(c ---> d) net" "(f ---> l) net" |
|
4218 shows "((\<lambda>x. c(x) *\<^sub>R f x) ---> (d *\<^sub>R l)) net" |
|
4219 using assms by (rule scaleR.tendsto) |
|
4220 |
|
4221 lemma Lim_vmul: |
|
4222 fixes c :: "'a \<Rightarrow> real" and v :: "'b::real_normed_vector" |
|
4223 shows "(c ---> d) net ==> ((\<lambda>x. c(x) *\<^sub>R v) ---> d *\<^sub>R v) net" |
|
4224 by (intro tendsto_intros) |
|
4225 |
|
4226 lemma continuous_vmul: |
|
4227 fixes c :: "'a::metric_space \<Rightarrow> real" and v :: "'b::real_normed_vector" |
|
4228 shows "continuous net c ==> continuous net (\<lambda>x. c(x) *\<^sub>R v)" |
|
4229 unfolding continuous_def using Lim_vmul[of c] by auto |
|
4230 |
|
4231 lemma continuous_mul: |
|
4232 fixes c :: "'a::metric_space \<Rightarrow> real" |
|
4233 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
4234 shows "continuous net c \<Longrightarrow> continuous net f |
|
4235 ==> continuous net (\<lambda>x. c(x) *\<^sub>R f x) " |
|
4236 unfolding continuous_def by (intro tendsto_intros) |
|
4237 |
|
4238 lemma continuous_on_vmul: |
|
4239 fixes c :: "'a::metric_space \<Rightarrow> real" and v :: "'b::real_normed_vector" |
|
4240 shows "continuous_on s c ==> continuous_on s (\<lambda>x. c(x) *\<^sub>R v)" |
|
4241 unfolding continuous_on_eq_continuous_within using continuous_vmul[of _ c] by auto |
|
4242 |
|
4243 lemma continuous_on_mul: |
|
4244 fixes c :: "'a::metric_space \<Rightarrow> real" |
|
4245 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_vector" |
|
4246 shows "continuous_on s c \<Longrightarrow> continuous_on s f |
|
4247 ==> continuous_on s (\<lambda>x. c(x) *\<^sub>R f x)" |
|
4248 unfolding continuous_on_eq_continuous_within using continuous_mul[of _ c] by auto |
|
4249 |
|
4250 text{* And so we have continuity of inverse. *} |
|
4251 |
|
4252 lemma Lim_inv: |
|
4253 fixes f :: "'a \<Rightarrow> real" |
|
4254 assumes "(f ---> l) (net::'a net)" "l \<noteq> 0" |
|
4255 shows "((inverse o f) ---> inverse l) net" |
|
4256 unfolding o_def using assms by (rule tendsto_inverse) |
|
4257 |
|
4258 lemma continuous_inv: |
|
4259 fixes f :: "'a::metric_space \<Rightarrow> real" |
|
4260 shows "continuous net f \<Longrightarrow> f(netlimit net) \<noteq> 0 |
|
4261 ==> continuous net (inverse o f)" |
|
4262 unfolding continuous_def using Lim_inv by auto |
|
4263 |
|
4264 lemma continuous_at_within_inv: |
|
4265 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_field" |
|
4266 assumes "continuous (at a within s) f" "f a \<noteq> 0" |
|
4267 shows "continuous (at a within s) (inverse o f)" |
|
4268 using assms unfolding continuous_within o_def |
|
4269 by (intro tendsto_intros) |
|
4270 |
|
4271 lemma continuous_at_inv: |
|
4272 fixes f :: "'a::metric_space \<Rightarrow> 'b::real_normed_field" |
|
4273 shows "continuous (at a) f \<Longrightarrow> f a \<noteq> 0 |
|
4274 ==> continuous (at a) (inverse o f) " |
|
4275 using within_UNIV[THEN sym, of "at a"] using continuous_at_within_inv[of a UNIV] by auto |
|
4276 |
|
4277 subsection{* Preservation properties for pasted sets. *} |
|
4278 |
|
4279 lemma bounded_pastecart: |
|
4280 fixes s :: "('a::real_normed_vector ^ _) set" (* FIXME: generalize to metric_space *) |
|
4281 assumes "bounded s" "bounded t" |
|
4282 shows "bounded { pastecart x y | x y . (x \<in> s \<and> y \<in> t)}" |
|
4283 proof- |
|
4284 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 |
|
4285 { fix x y assume "x\<in>s" "y\<in>t" |
|
4286 hence "norm x \<le> a" "norm y \<le> b" using ab by auto |
|
4287 hence "norm (pastecart x y) \<le> a + b" using norm_pastecart[of x y] by auto } |
|
4288 thus ?thesis unfolding bounded_iff by auto |
|
4289 qed |
|
4290 |
|
4291 lemma bounded_Times: |
|
4292 assumes "bounded s" "bounded t" shows "bounded (s \<times> t)" |
|
4293 proof- |
|
4294 obtain x y a b where "\<forall>z\<in>s. dist x z \<le> a" "\<forall>z\<in>t. dist y z \<le> b" |
|
4295 using assms [unfolded bounded_def] by auto |
|
4296 then have "\<forall>z\<in>s \<times> t. dist (x, y) z \<le> sqrt (a\<twosuperior> + b\<twosuperior>)" |
|
4297 by (auto simp add: dist_Pair_Pair real_sqrt_le_mono add_mono power_mono) |
|
4298 thus ?thesis unfolding bounded_any_center [where a="(x, y)"] by auto |
|
4299 qed |
|
4300 |
|
4301 lemma closed_pastecart: |
|
4302 fixes s :: "(real ^ 'a::finite) set" (* FIXME: generalize *) |
|
4303 assumes "closed s" "closed t" |
|
4304 shows "closed {pastecart x y | x y . x \<in> s \<and> y \<in> t}" |
|
4305 proof- |
|
4306 { 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" |
|
4307 { 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 |
|
4308 moreover |
|
4309 { fix e::real assume "e>0" |
|
4310 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 |
|
4311 { fix n::nat assume "n\<ge>N" |
|
4312 hence "dist (fstcart (x n)) (fstcart l) < e" "dist (sndcart (x n)) (sndcart l) < e" |
|
4313 using N[THEN spec[where x=n]] dist_fstcart[of "x n" l] dist_sndcart[of "x n" l] by auto } |
|
4314 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 } |
|
4315 ultimately have "fstcart l \<in> s" "sndcart l \<in> t" |
|
4316 using assms(1)[unfolded closed_sequential_limits, THEN spec[where x="\<lambda>n. fstcart (x n)"], THEN spec[where x="fstcart l"]] |
|
4317 using assms(2)[unfolded closed_sequential_limits, THEN spec[where x="\<lambda>n. sndcart (x n)"], THEN spec[where x="sndcart l"]] |
|
4318 unfolding Lim_sequentially by auto |
|
4319 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 } |
|
4320 thus ?thesis unfolding closed_sequential_limits by auto |
|
4321 qed |
|
4322 |
|
4323 lemma compact_pastecart: |
|
4324 fixes s t :: "(real ^ _) set" |
|
4325 shows "compact s \<Longrightarrow> compact t ==> compact {pastecart x y | x y . x \<in> s \<and> y \<in> t}" |
|
4326 unfolding compact_eq_bounded_closed using bounded_pastecart[of s t] closed_pastecart[of s t] by auto |
|
4327 |
|
4328 lemma mem_Times_iff: "x \<in> A \<times> B \<longleftrightarrow> fst x \<in> A \<and> snd x \<in> B" |
|
4329 by (induct x) simp |
|
4330 |
|
4331 lemma compact_Times: "compact s \<Longrightarrow> compact t \<Longrightarrow> compact (s \<times> t)" |
|
4332 unfolding compact_def |
|
4333 apply clarify |
|
4334 apply (drule_tac x="fst \<circ> f" in spec) |
|
4335 apply (drule mp, simp add: mem_Times_iff) |
|
4336 apply (clarify, rename_tac l1 r1) |
|
4337 apply (drule_tac x="snd \<circ> f \<circ> r1" in spec) |
|
4338 apply (drule mp, simp add: mem_Times_iff) |
|
4339 apply (clarify, rename_tac l2 r2) |
|
4340 apply (rule_tac x="(l1, l2)" in rev_bexI, simp) |
|
4341 apply (rule_tac x="r1 \<circ> r2" in exI) |
|
4342 apply (rule conjI, simp add: subseq_def) |
|
4343 apply (drule_tac r=r2 in lim_subseq [COMP swap_prems_rl], assumption) |
|
4344 apply (drule (1) tendsto_Pair) back |
|
4345 apply (simp add: o_def) |
|
4346 done |
|
4347 |
|
4348 text{* Hence some useful properties follow quite easily. *} |
|
4349 |
|
4350 lemma compact_scaling: |
|
4351 fixes s :: "'a::real_normed_vector set" |
|
4352 assumes "compact s" shows "compact ((\<lambda>x. c *\<^sub>R x) ` s)" |
|
4353 proof- |
|
4354 let ?f = "\<lambda>x. scaleR c x" |
|
4355 have *:"bounded_linear ?f" by (rule scaleR.bounded_linear_right) |
|
4356 show ?thesis using compact_continuous_image[of s ?f] continuous_at_imp_continuous_on[of s ?f] |
|
4357 using linear_continuous_at[OF *] assms by auto |
|
4358 qed |
|
4359 |
|
4360 lemma compact_negations: |
|
4361 fixes s :: "'a::real_normed_vector set" |
|
4362 assumes "compact s" shows "compact ((\<lambda>x. -x) ` s)" |
|
4363 using compact_scaling [OF assms, of "- 1"] by auto |
|
4364 |
|
4365 lemma compact_sums: |
|
4366 fixes s t :: "'a::real_normed_vector set" |
|
4367 assumes "compact s" "compact t" shows "compact {x + y | x y. x \<in> s \<and> y \<in> t}" |
|
4368 proof- |
|
4369 have *:"{x + y | x y. x \<in> s \<and> y \<in> t} = (\<lambda>z. fst z + snd z) ` (s \<times> t)" |
|
4370 apply auto unfolding image_iff apply(rule_tac x="(xa, y)" in bexI) by auto |
|
4371 have "continuous_on (s \<times> t) (\<lambda>z. fst z + snd z)" |
|
4372 unfolding continuous_on by (rule ballI) (intro tendsto_intros) |
|
4373 thus ?thesis unfolding * using compact_continuous_image compact_Times [OF assms] by auto |
|
4374 qed |
|
4375 |
|
4376 lemma compact_differences: |
|
4377 fixes s t :: "'a::real_normed_vector set" |
|
4378 assumes "compact s" "compact t" shows "compact {x - y | x y. x \<in> s \<and> y \<in> t}" |
|
4379 proof- |
|
4380 have "{x - y | x y. x\<in>s \<and> y \<in> t} = {x + y | x y. x \<in> s \<and> y \<in> (uminus ` t)}" |
|
4381 apply auto apply(rule_tac x= xa in exI) apply auto apply(rule_tac x=xa in exI) by auto |
|
4382 thus ?thesis using compact_sums[OF assms(1) compact_negations[OF assms(2)]] by auto |
|
4383 qed |
|
4384 |
|
4385 lemma compact_translation: |
|
4386 fixes s :: "'a::real_normed_vector set" |
|
4387 assumes "compact s" shows "compact ((\<lambda>x. a + x) ` s)" |
|
4388 proof- |
|
4389 have "{x + y |x y. x \<in> s \<and> y \<in> {a}} = (\<lambda>x. a + x) ` s" by auto |
|
4390 thus ?thesis using compact_sums[OF assms compact_sing[of a]] by auto |
|
4391 qed |
|
4392 |
|
4393 lemma compact_affinity: |
|
4394 fixes s :: "'a::real_normed_vector set" |
|
4395 assumes "compact s" shows "compact ((\<lambda>x. a + c *\<^sub>R x) ` s)" |
|
4396 proof- |
|
4397 have "op + a ` op *\<^sub>R c ` s = (\<lambda>x. a + c *\<^sub>R x) ` s" by auto |
|
4398 thus ?thesis using compact_translation[OF compact_scaling[OF assms], of a c] by auto |
|
4399 qed |
|
4400 |
|
4401 text{* Hence we get the following. *} |
|
4402 |
|
4403 lemma compact_sup_maxdistance: |
|
4404 fixes s :: "'a::real_normed_vector set" |
|
4405 assumes "compact s" "s \<noteq> {}" |
|
4406 shows "\<exists>x\<in>s. \<exists>y\<in>s. \<forall>u\<in>s. \<forall>v\<in>s. norm(u - v) \<le> norm(x - y)" |
|
4407 proof- |
|
4408 have "{x - y | x y . x\<in>s \<and> y\<in>s} \<noteq> {}" using `s \<noteq> {}` by auto |
|
4409 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" |
|
4410 using compact_differences[OF assms(1) assms(1)] |
|
4411 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) |
|
4412 from x(1) obtain a b where "a\<in>s" "b\<in>s" "x = a - b" by auto |
|
4413 thus ?thesis using x(2)[unfolded `x = a - b`] by blast |
|
4414 qed |
|
4415 |
|
4416 text{* We can state this in terms of diameter of a set. *} |
|
4417 |
|
4418 definition "diameter s = (if s = {} then 0::real else rsup {norm(x - y) | x y. x \<in> s \<and> y \<in> s})" |
|
4419 (* TODO: generalize to class metric_space *) |
|
4420 |
|
4421 lemma diameter_bounded: |
|
4422 assumes "bounded s" |
|
4423 shows "\<forall>x\<in>s. \<forall>y\<in>s. norm(x - y) \<le> diameter s" |
|
4424 "\<forall>d>0. d < diameter s --> (\<exists>x\<in>s. \<exists>y\<in>s. norm(x - y) > d)" |
|
4425 proof- |
|
4426 let ?D = "{norm (x - y) |x y. x \<in> s \<and> y \<in> s}" |
|
4427 obtain a where a:"\<forall>x\<in>s. norm x \<le> a" using assms[unfolded bounded_iff] by auto |
|
4428 { fix x y assume "x \<in> s" "y \<in> s" |
|
4429 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) } |
|
4430 note * = this |
|
4431 { fix x y assume "x\<in>s" "y\<in>s" hence "s \<noteq> {}" by auto |
|
4432 have lub:"isLub UNIV ?D (rsup ?D)" using * rsup[of ?D] using `s\<noteq>{}` unfolding setle_def by auto |
|
4433 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 } |
|
4434 moreover |
|
4435 { fix d::real assume "d>0" "d < diameter s" |
|
4436 hence "s\<noteq>{}" unfolding diameter_def by auto |
|
4437 hence lub:"isLub UNIV ?D (rsup ?D)" using * rsup[of ?D] unfolding setle_def by auto |
|
4438 have "\<exists>d' \<in> ?D. d' > d" |
|
4439 proof(rule ccontr) |
|
4440 assume "\<not> (\<exists>d'\<in>{norm (x - y) |x y. x \<in> s \<and> y \<in> s}. d < d')" |
|
4441 hence as:"\<forall>d'\<in>?D. d' \<le> d" apply auto apply(erule_tac x="norm (x - y)" in allE) by auto |
|
4442 hence "isUb UNIV ?D d" unfolding isUb_def unfolding setle_def by auto |
|
4443 thus False using `d < diameter s` `s\<noteq>{}` isLub_le_isUb[OF lub, of d] unfolding diameter_def by auto |
|
4444 qed |
|
4445 hence "\<exists>x\<in>s. \<exists>y\<in>s. norm(x - y) > d" by auto } |
|
4446 ultimately show "\<forall>x\<in>s. \<forall>y\<in>s. norm(x - y) \<le> diameter s" |
|
4447 "\<forall>d>0. d < diameter s --> (\<exists>x\<in>s. \<exists>y\<in>s. norm(x - y) > d)" by auto |
|
4448 qed |
|
4449 |
|
4450 lemma diameter_bounded_bound: |
|
4451 "bounded s \<Longrightarrow> x \<in> s \<Longrightarrow> y \<in> s ==> norm(x - y) \<le> diameter s" |
|
4452 using diameter_bounded by blast |
|
4453 |
|
4454 lemma diameter_compact_attained: |
|
4455 fixes s :: "'a::real_normed_vector set" |
|
4456 assumes "compact s" "s \<noteq> {}" |
|
4457 shows "\<exists>x\<in>s. \<exists>y\<in>s. (norm(x - y) = diameter s)" |
|
4458 proof- |
|
4459 have b:"bounded s" using assms(1) by (rule compact_imp_bounded) |
|
4460 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 |
|
4461 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)"] |
|
4462 unfolding setle_def and diameter_def by auto |
|
4463 thus ?thesis using diameter_bounded(1)[OF b, THEN bspec[where x=x], THEN bspec[where x=y], OF xys] and xys by auto |
|
4464 qed |
|
4465 |
|
4466 text{* Related results with closure as the conclusion. *} |
|
4467 |
|
4468 lemma closed_scaling: |
|
4469 fixes s :: "'a::real_normed_vector set" |
|
4470 assumes "closed s" shows "closed ((\<lambda>x. c *\<^sub>R x) ` s)" |
|
4471 proof(cases "s={}") |
|
4472 case True thus ?thesis by auto |
|
4473 next |
|
4474 case False |
|
4475 show ?thesis |
|
4476 proof(cases "c=0") |
|
4477 have *:"(\<lambda>x. 0) ` s = {0}" using `s\<noteq>{}` by auto |
|
4478 case True thus ?thesis apply auto unfolding * using closed_sing by auto |
|
4479 next |
|
4480 case False |
|
4481 { fix x l assume as:"\<forall>n::nat. x n \<in> scaleR c ` s" "(x ---> l) sequentially" |
|
4482 { fix n::nat have "scaleR (1 / c) (x n) \<in> s" |
|
4483 using as(1)[THEN spec[where x=n]] |
|
4484 using `c\<noteq>0` by (auto simp add: vector_smult_assoc) |
|
4485 } |
|
4486 moreover |
|
4487 { fix e::real assume "e>0" |
|
4488 hence "0 < e *\<bar>c\<bar>" using `c\<noteq>0` mult_pos_pos[of e "abs c"] by auto |
|
4489 then obtain N where "\<forall>n\<ge>N. dist (x n) l < e * \<bar>c\<bar>" |
|
4490 using as(2)[unfolded Lim_sequentially, THEN spec[where x="e * abs c"]] by auto |
|
4491 hence "\<exists>N. \<forall>n\<ge>N. dist (scaleR (1 / c) (x n)) (scaleR (1 / c) l) < e" |
|
4492 unfolding dist_norm unfolding scaleR_right_diff_distrib[THEN sym] |
|
4493 using mult_imp_div_pos_less[of "abs c" _ e] `c\<noteq>0` by auto } |
|
4494 hence "((\<lambda>n. scaleR (1 / c) (x n)) ---> scaleR (1 / c) l) sequentially" unfolding Lim_sequentially by auto |
|
4495 ultimately have "l \<in> scaleR c ` s" |
|
4496 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"]] |
|
4497 unfolding image_iff using `c\<noteq>0` apply(rule_tac x="scaleR (1 / c) l" in bexI) by auto } |
|
4498 thus ?thesis unfolding closed_sequential_limits by fast |
|
4499 qed |
|
4500 qed |
|
4501 |
|
4502 lemma closed_negations: |
|
4503 fixes s :: "'a::real_normed_vector set" |
|
4504 assumes "closed s" shows "closed ((\<lambda>x. -x) ` s)" |
|
4505 using closed_scaling[OF assms, of "- 1"] by simp |
|
4506 |
|
4507 lemma compact_closed_sums: |
|
4508 fixes s :: "'a::real_normed_vector set" |
|
4509 assumes "compact s" "closed t" shows "closed {x + y | x y. x \<in> s \<and> y \<in> t}" |
|
4510 proof- |
|
4511 let ?S = "{x + y |x y. x \<in> s \<and> y \<in> t}" |
|
4512 { fix x l assume as:"\<forall>n. x n \<in> ?S" "(x ---> l) sequentially" |
|
4513 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" |
|
4514 using choice[of "\<lambda>n y. x n = (fst y) + (snd y) \<and> fst y \<in> s \<and> snd y \<in> t"] by auto |
|
4515 obtain l' r where "l'\<in>s" and r:"subseq r" and lr:"(((\<lambda>n. fst (f n)) \<circ> r) ---> l') sequentially" |
|
4516 using assms(1)[unfolded compact_def, THEN spec[where x="\<lambda> n. fst (f n)"]] using f(2) by auto |
|
4517 have "((\<lambda>n. snd (f (r n))) ---> l - l') sequentially" |
|
4518 using Lim_sub[OF lim_subseq[OF r as(2)] lr] and f(1) unfolding o_def by auto |
|
4519 hence "l - l' \<in> t" |
|
4520 using assms(2)[unfolded closed_sequential_limits, THEN spec[where x="\<lambda> n. snd (f (r n))"], THEN spec[where x="l - l'"]] |
|
4521 using f(3) by auto |
|
4522 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 |
|
4523 } |
|
4524 thus ?thesis unfolding closed_sequential_limits by fast |
|
4525 qed |
|
4526 |
|
4527 lemma closed_compact_sums: |
|
4528 fixes s t :: "'a::real_normed_vector set" |
|
4529 assumes "closed s" "compact t" |
|
4530 shows "closed {x + y | x y. x \<in> s \<and> y \<in> t}" |
|
4531 proof- |
|
4532 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 |
|
4533 apply(rule_tac x=y in exI) apply auto apply(rule_tac x=y in exI) by auto |
|
4534 thus ?thesis using compact_closed_sums[OF assms(2,1)] by simp |
|
4535 qed |
|
4536 |
|
4537 lemma compact_closed_differences: |
|
4538 fixes s t :: "'a::real_normed_vector set" |
|
4539 assumes "compact s" "closed t" |
|
4540 shows "closed {x - y | x y. x \<in> s \<and> y \<in> t}" |
|
4541 proof- |
|
4542 have "{x + y |x y. x \<in> s \<and> y \<in> uminus ` t} = {x - y |x y. x \<in> s \<and> y \<in> t}" |
|
4543 apply auto apply(rule_tac x=xa in exI) apply auto apply(rule_tac x=xa in exI) by auto |
|
4544 thus ?thesis using compact_closed_sums[OF assms(1) closed_negations[OF assms(2)]] by auto |
|
4545 qed |
|
4546 |
|
4547 lemma closed_compact_differences: |
|
4548 fixes s t :: "'a::real_normed_vector set" |
|
4549 assumes "closed s" "compact t" |
|
4550 shows "closed {x - y | x y. x \<in> s \<and> y \<in> t}" |
|
4551 proof- |
|
4552 have "{x + y |x y. x \<in> s \<and> y \<in> uminus ` t} = {x - y |x y. x \<in> s \<and> y \<in> t}" |
|
4553 apply auto apply(rule_tac x=xa in exI) apply auto apply(rule_tac x=xa in exI) by auto |
|
4554 thus ?thesis using closed_compact_sums[OF assms(1) compact_negations[OF assms(2)]] by simp |
|
4555 qed |
|
4556 |
|
4557 lemma closed_translation: |
|
4558 fixes a :: "'a::real_normed_vector" |
|
4559 assumes "closed s" shows "closed ((\<lambda>x. a + x) ` s)" |
|
4560 proof- |
|
4561 have "{a + y |y. y \<in> s} = (op + a ` s)" by auto |
|
4562 thus ?thesis using compact_closed_sums[OF compact_sing[of a] assms] by auto |
|
4563 qed |
|
4564 |
|
4565 lemma translation_UNIV: |
|
4566 fixes a :: "'a::ab_group_add" shows "range (\<lambda>x. a + x) = UNIV" |
|
4567 apply (auto simp add: image_iff) apply(rule_tac x="x - a" in exI) by auto |
|
4568 |
|
4569 lemma translation_diff: |
|
4570 fixes a :: "'a::ab_group_add" |
|
4571 shows "(\<lambda>x. a + x) ` (s - t) = ((\<lambda>x. a + x) ` s) - ((\<lambda>x. a + x) ` t)" |
|
4572 by auto |
|
4573 |
|
4574 lemma closure_translation: |
|
4575 fixes a :: "'a::real_normed_vector" |
|
4576 shows "closure ((\<lambda>x. a + x) ` s) = (\<lambda>x. a + x) ` (closure s)" |
|
4577 proof- |
|
4578 have *:"op + a ` (UNIV - s) = UNIV - op + a ` s" |
|
4579 apply auto unfolding image_iff apply(rule_tac x="x - a" in bexI) by auto |
|
4580 show ?thesis unfolding closure_interior translation_diff translation_UNIV |
|
4581 using interior_translation[of a "UNIV - s"] unfolding * by auto |
|
4582 qed |
|
4583 |
|
4584 lemma frontier_translation: |
|
4585 fixes a :: "'a::real_normed_vector" |
|
4586 shows "frontier((\<lambda>x. a + x) ` s) = (\<lambda>x. a + x) ` (frontier s)" |
|
4587 unfolding frontier_def translation_diff interior_translation closure_translation by auto |
|
4588 |
|
4589 subsection{* Separation between points and sets. *} |
|
4590 |
|
4591 lemma separate_point_closed: |
|
4592 fixes s :: "'a::heine_borel set" |
|
4593 shows "closed s \<Longrightarrow> a \<notin> s ==> (\<exists>d>0. \<forall>x\<in>s. d \<le> dist a x)" |
|
4594 proof(cases "s = {}") |
|
4595 case True |
|
4596 thus ?thesis by(auto intro!: exI[where x=1]) |
|
4597 next |
|
4598 case False |
|
4599 assume "closed s" "a \<notin> s" |
|
4600 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 |
|
4601 with `x\<in>s` show ?thesis using dist_pos_lt[of a x] and`a \<notin> s` by blast |
|
4602 qed |
|
4603 |
|
4604 lemma separate_compact_closed: |
|
4605 fixes s t :: "'a::{heine_borel, real_normed_vector} set" |
|
4606 (* TODO: does this generalize to heine_borel? *) |
|
4607 assumes "compact s" and "closed t" and "s \<inter> t = {}" |
|
4608 shows "\<exists>d>0. \<forall>x\<in>s. \<forall>y\<in>t. d \<le> dist x y" |
|
4609 proof- |
|
4610 have "0 \<notin> {x - y |x y. x \<in> s \<and> y \<in> t}" using assms(3) by auto |
|
4611 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" |
|
4612 using separate_point_closed[OF compact_closed_differences[OF assms(1,2)], of 0] by auto |
|
4613 { fix x y assume "x\<in>s" "y\<in>t" |
|
4614 hence "x - y \<in> {x - y |x y. x \<in> s \<and> y \<in> t}" by auto |
|
4615 hence "d \<le> dist (x - y) 0" using d[THEN bspec[where x="x - y"]] using dist_commute |
|
4616 by (auto simp add: dist_commute) |
|
4617 hence "d \<le> dist x y" unfolding dist_norm by auto } |
|
4618 thus ?thesis using `d>0` by auto |
|
4619 qed |
|
4620 |
|
4621 lemma separate_closed_compact: |
|
4622 fixes s t :: "'a::{heine_borel, real_normed_vector} set" |
|
4623 assumes "closed s" and "compact t" and "s \<inter> t = {}" |
|
4624 shows "\<exists>d>0. \<forall>x\<in>s. \<forall>y\<in>t. d \<le> dist x y" |
|
4625 proof- |
|
4626 have *:"t \<inter> s = {}" using assms(3) by auto |
|
4627 show ?thesis using separate_compact_closed[OF assms(2,1) *] |
|
4628 apply auto apply(rule_tac x=d in exI) apply auto apply (erule_tac x=y in ballE) |
|
4629 by (auto simp add: dist_commute) |
|
4630 qed |
|
4631 |
|
4632 (* A cute way of denoting open and closed intervals using overloading. *) |
|
4633 |
|
4634 lemma interval: fixes a :: "'a::ord^'n::finite" shows |
|
4635 "{a <..< b} = {x::'a^'n. \<forall>i. a$i < x$i \<and> x$i < b$i}" and |
|
4636 "{a .. b} = {x::'a^'n. \<forall>i. a$i \<le> x$i \<and> x$i \<le> b$i}" |
|
4637 by (auto simp add: expand_set_eq vector_less_def vector_less_eq_def) |
|
4638 |
|
4639 lemma mem_interval: fixes a :: "'a::ord^'n::finite" shows |
|
4640 "x \<in> {a<..<b} \<longleftrightarrow> (\<forall>i. a$i < x$i \<and> x$i < b$i)" |
|
4641 "x \<in> {a .. b} \<longleftrightarrow> (\<forall>i. a$i \<le> x$i \<and> x$i \<le> b$i)" |
|
4642 using interval[of a b] by(auto simp add: expand_set_eq vector_less_def vector_less_eq_def) |
|
4643 |
|
4644 lemma mem_interval_1: fixes x :: "real^1" shows |
|
4645 "(x \<in> {a .. b} \<longleftrightarrow> dest_vec1 a \<le> dest_vec1 x \<and> dest_vec1 x \<le> dest_vec1 b)" |
|
4646 "(x \<in> {a<..<b} \<longleftrightarrow> dest_vec1 a < dest_vec1 x \<and> dest_vec1 x < dest_vec1 b)" |
|
4647 by(simp_all add: Cart_eq vector_less_def vector_less_eq_def dest_vec1_def forall_1) |
|
4648 |
|
4649 lemma interval_eq_empty: fixes a :: "real^'n::finite" shows |
|
4650 "({a <..< b} = {} \<longleftrightarrow> (\<exists>i. b$i \<le> a$i))" (is ?th1) and |
|
4651 "({a .. b} = {} \<longleftrightarrow> (\<exists>i. b$i < a$i))" (is ?th2) |
|
4652 proof- |
|
4653 { fix i x assume as:"b$i \<le> a$i" and x:"x\<in>{a <..< b}" |
|
4654 hence "a $ i < x $ i \<and> x $ i < b $ i" unfolding mem_interval by auto |
|
4655 hence "a$i < b$i" by auto |
|
4656 hence False using as by auto } |
|
4657 moreover |
|
4658 { assume as:"\<forall>i. \<not> (b$i \<le> a$i)" |
|
4659 let ?x = "(1/2) *\<^sub>R (a + b)" |
|
4660 { fix i |
|
4661 have "a$i < b$i" using as[THEN spec[where x=i]] by auto |
|
4662 hence "a$i < ((1/2) *\<^sub>R (a+b)) $ i" "((1/2) *\<^sub>R (a+b)) $ i < b$i" |
|
4663 unfolding vector_smult_component and vector_add_component |
|
4664 by (auto simp add: less_divide_eq_number_of1) } |
|
4665 hence "{a <..< b} \<noteq> {}" using mem_interval(1)[of "?x" a b] by auto } |
|
4666 ultimately show ?th1 by blast |
|
4667 |
|
4668 { fix i x assume as:"b$i < a$i" and x:"x\<in>{a .. b}" |
|
4669 hence "a $ i \<le> x $ i \<and> x $ i \<le> b $ i" unfolding mem_interval by auto |
|
4670 hence "a$i \<le> b$i" by auto |
|
4671 hence False using as by auto } |
|
4672 moreover |
|
4673 { assume as:"\<forall>i. \<not> (b$i < a$i)" |
|
4674 let ?x = "(1/2) *\<^sub>R (a + b)" |
|
4675 { fix i |
|
4676 have "a$i \<le> b$i" using as[THEN spec[where x=i]] by auto |
|
4677 hence "a$i \<le> ((1/2) *\<^sub>R (a+b)) $ i" "((1/2) *\<^sub>R (a+b)) $ i \<le> b$i" |
|
4678 unfolding vector_smult_component and vector_add_component |
|
4679 by (auto simp add: less_divide_eq_number_of1) } |
|
4680 hence "{a .. b} \<noteq> {}" using mem_interval(2)[of "?x" a b] by auto } |
|
4681 ultimately show ?th2 by blast |
|
4682 qed |
|
4683 |
|
4684 lemma interval_ne_empty: fixes a :: "real^'n::finite" shows |
|
4685 "{a .. b} \<noteq> {} \<longleftrightarrow> (\<forall>i. a$i \<le> b$i)" and |
|
4686 "{a <..< b} \<noteq> {} \<longleftrightarrow> (\<forall>i. a$i < b$i)" |
|
4687 unfolding interval_eq_empty[of a b] by (auto simp add: not_less not_le) (* BH: Why doesn't just "auto" work here? *) |
|
4688 |
|
4689 lemma subset_interval_imp: fixes a :: "real^'n::finite" shows |
|
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 < c$i \<and> d$i < b$i) \<Longrightarrow> {c .. d} \<subseteq> {a<..<b}" and |
|
4692 "(\<forall>i. a$i \<le> c$i \<and> d$i \<le> b$i) \<Longrightarrow> {c<..<d} \<subseteq> {a .. b}" and |
|
4693 "(\<forall>i. a$i \<le> c$i \<and> d$i \<le> b$i) \<Longrightarrow> {c<..<d} \<subseteq> {a<..<b}" |
|
4694 unfolding subset_eq[unfolded Ball_def] unfolding mem_interval |
|
4695 by (auto intro: order_trans less_le_trans le_less_trans less_imp_le) (* BH: Why doesn't just "auto" work here? *) |
|
4696 |
|
4697 lemma interval_sing: fixes a :: "'a::linorder^'n::finite" shows |
|
4698 "{a .. a} = {a} \<and> {a<..<a} = {}" |
|
4699 apply(auto simp add: expand_set_eq vector_less_def vector_less_eq_def Cart_eq) |
|
4700 apply (simp add: order_eq_iff) |
|
4701 apply (auto simp add: not_less less_imp_le) |
|
4702 done |
|
4703 |
|
4704 lemma interval_open_subset_closed: fixes a :: "'a::preorder^'n::finite" shows |
|
4705 "{a<..<b} \<subseteq> {a .. b}" |
|
4706 proof(simp add: subset_eq, rule) |
|
4707 fix x |
|
4708 assume x:"x \<in>{a<..<b}" |
|
4709 { fix i |
|
4710 have "a $ i \<le> x $ i" |
|
4711 using x order_less_imp_le[of "a$i" "x$i"] |
|
4712 by(simp add: expand_set_eq vector_less_def vector_less_eq_def Cart_eq) |
|
4713 } |
|
4714 moreover |
|
4715 { fix i |
|
4716 have "x $ i \<le> b $ i" |
|
4717 using x order_less_imp_le[of "x$i" "b$i"] |
|
4718 by(simp add: expand_set_eq vector_less_def vector_less_eq_def Cart_eq) |
|
4719 } |
|
4720 ultimately |
|
4721 show "a \<le> x \<and> x \<le> b" |
|
4722 by(simp add: expand_set_eq vector_less_def vector_less_eq_def Cart_eq) |
|
4723 qed |
|
4724 |
|
4725 lemma subset_interval: fixes a :: "real^'n::finite" shows |
|
4726 "{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 |
|
4727 "{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 |
|
4728 "{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 |
|
4729 "{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) |
|
4730 proof- |
|
4731 show ?th1 unfolding subset_eq and Ball_def and mem_interval by (auto intro: order_trans) |
|
4732 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) |
|
4733 { assume as: "{c<..<d} \<subseteq> {a .. b}" "\<forall>i. c$i < d$i" |
|
4734 hence "{c<..<d} \<noteq> {}" unfolding interval_eq_empty by (auto, drule_tac x=i in spec, simp) (* BH: Why doesn't just "auto" work? *) |
|
4735 fix i |
|
4736 (** TODO combine the following two parts as done in the HOL_light version. **) |
|
4737 { let ?x = "(\<chi> j. (if j=i then ((min (a$j) (d$j))+c$j)/2 else (c$j+d$j)/2))::real^'n" |
|
4738 assume as2: "a$i > c$i" |
|
4739 { fix j |
|
4740 have "c $ j < ?x $ j \<and> ?x $ j < d $ j" unfolding Cart_lambda_beta |
|
4741 apply(cases "j=i") using as(2)[THEN spec[where x=j]] |
|
4742 by (auto simp add: less_divide_eq_number_of1 as2) } |
|
4743 hence "?x\<in>{c<..<d}" unfolding mem_interval by auto |
|
4744 moreover |
|
4745 have "?x\<notin>{a .. b}" |
|
4746 unfolding mem_interval apply auto apply(rule_tac x=i in exI) |
|
4747 using as(2)[THEN spec[where x=i]] and as2 |
|
4748 by (auto simp add: less_divide_eq_number_of1) |
|
4749 ultimately have False using as by auto } |
|
4750 hence "a$i \<le> c$i" by(rule ccontr)auto |
|
4751 moreover |
|
4752 { let ?x = "(\<chi> j. (if j=i then ((max (b$j) (c$j))+d$j)/2 else (c$j+d$j)/2))::real^'n" |
|
4753 assume as2: "b$i < d$i" |
|
4754 { fix j |
|
4755 have "d $ j > ?x $ j \<and> ?x $ j > c $ j" unfolding Cart_lambda_beta |
|
4756 apply(cases "j=i") using as(2)[THEN spec[where x=j]] |
|
4757 by (auto simp add: less_divide_eq_number_of1 as2) } |
|
4758 hence "?x\<in>{c<..<d}" unfolding mem_interval by auto |
|
4759 moreover |
|
4760 have "?x\<notin>{a .. b}" |
|
4761 unfolding mem_interval apply auto apply(rule_tac x=i in exI) |
|
4762 using as(2)[THEN spec[where x=i]] and as2 |
|
4763 by (auto simp add: less_divide_eq_number_of1) |
|
4764 ultimately have False using as by auto } |
|
4765 hence "b$i \<ge> d$i" by(rule ccontr)auto |
|
4766 ultimately |
|
4767 have "a$i \<le> c$i \<and> d$i \<le> b$i" by auto |
|
4768 } note part1 = this |
|
4769 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)+ |
|
4770 { assume as:"{c<..<d} \<subseteq> {a<..<b}" "\<forall>i. c$i < d$i" |
|
4771 fix i |
|
4772 from as(1) have "{c<..<d} \<subseteq> {a..b}" using interval_open_subset_closed[of a b] by auto |
|
4773 hence "a$i \<le> c$i \<and> d$i \<le> b$i" using part1 and as(2) by auto } note * = this |
|
4774 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)+ |
|
4775 qed |
|
4776 |
|
4777 lemma disjoint_interval: fixes a::"real^'n::finite" shows |
|
4778 "{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 |
|
4779 "{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 |
|
4780 "{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 |
|
4781 "{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) |
|
4782 proof- |
|
4783 let ?z = "(\<chi> i. ((max (a$i) (c$i)) + (min (b$i) (d$i))) / 2)::real^'n" |
|
4784 show ?th1 ?th2 ?th3 ?th4 |
|
4785 unfolding expand_set_eq and Int_iff and empty_iff and mem_interval and all_conj_distrib[THEN sym] and eq_False |
|
4786 apply (auto elim!: allE[where x="?z"]) |
|
4787 apply ((rule_tac x=x in exI, force) | (rule_tac x=i in exI, force))+ |
|
4788 done |
|
4789 qed |
|
4790 |
|
4791 lemma inter_interval: fixes a :: "'a::linorder^'n::finite" shows |
|
4792 "{a .. b} \<inter> {c .. d} = {(\<chi> i. max (a$i) (c$i)) .. (\<chi> i. min (b$i) (d$i))}" |
|
4793 unfolding expand_set_eq and Int_iff and mem_interval |
|
4794 by (auto simp add: less_divide_eq_number_of1 intro!: bexI) |
|
4795 |
|
4796 (* Moved interval_open_subset_closed a bit upwards *) |
|
4797 |
|
4798 lemma open_interval_lemma: fixes x :: "real" shows |
|
4799 "a < x \<Longrightarrow> x < b ==> (\<exists>d>0. \<forall>x'. abs(x' - x) < d --> a < x' \<and> x' < b)" |
|
4800 by(rule_tac x="min (x - a) (b - x)" in exI, auto) |
|
4801 |
|
4802 lemma open_interval: fixes a :: "real^'n::finite" shows "open {a<..<b}" |
|
4803 proof- |
|
4804 { fix x assume x:"x\<in>{a<..<b}" |
|
4805 { fix i |
|
4806 have "\<exists>d>0. \<forall>x'. abs (x' - (x$i)) < d \<longrightarrow> a$i < x' \<and> x' < b$i" |
|
4807 using x[unfolded mem_interval, THEN spec[where x=i]] |
|
4808 using open_interval_lemma[of "a$i" "x$i" "b$i"] by auto } |
|
4809 |
|
4810 hence "\<forall>i. \<exists>d>0. \<forall>x'. abs (x' - (x$i)) < d \<longrightarrow> a$i < x' \<and> x' < b$i" by auto |
|
4811 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)" |
|
4812 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 |
|
4813 |
|
4814 let ?d = "Min (range d)" |
|
4815 have **:"finite (range d)" "range d \<noteq> {}" by auto |
|
4816 have "?d>0" unfolding Min_gr_iff[OF **] using d by auto |
|
4817 moreover |
|
4818 { fix x' assume as:"dist x' x < ?d" |
|
4819 { fix i |
|
4820 have "\<bar>x'$i - x $ i\<bar> < d i" |
|
4821 using norm_bound_component_lt[OF as[unfolded dist_norm], of i] |
|
4822 unfolding vector_minus_component and Min_gr_iff[OF **] by auto |
|
4823 hence "a $ i < x' $ i" "x' $ i < b $ i" using d[THEN spec[where x=i]] by auto } |
|
4824 hence "a < x' \<and> x' < b" unfolding vector_less_def by auto } |
|
4825 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) |
|
4826 } |
|
4827 thus ?thesis unfolding open_dist using open_interval_lemma by auto |
|
4828 qed |
|
4829 |
|
4830 lemma closed_interval: fixes a :: "real^'n::finite" shows "closed {a .. b}" |
|
4831 proof- |
|
4832 { 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"*) |
|
4833 { assume xa:"a$i > x$i" |
|
4834 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 |
|
4835 hence False unfolding mem_interval and dist_norm |
|
4836 using component_le_norm[of "y-x" i, unfolded vector_minus_component] and xa by(auto elim!: allE[where x=i]) |
|
4837 } hence "a$i \<le> x$i" by(rule ccontr)auto |
|
4838 moreover |
|
4839 { assume xb:"b$i < x$i" |
|
4840 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 |
|
4841 hence False unfolding mem_interval and dist_norm |
|
4842 using component_le_norm[of "y-x" i, unfolded vector_minus_component] and xb by(auto elim!: allE[where x=i]) |
|
4843 } hence "x$i \<le> b$i" by(rule ccontr)auto |
|
4844 ultimately |
|
4845 have "a $ i \<le> x $ i \<and> x $ i \<le> b $ i" by auto } |
|
4846 thus ?thesis unfolding closed_limpt islimpt_approachable mem_interval by auto |
|
4847 qed |
|
4848 |
|
4849 lemma interior_closed_interval: fixes a :: "real^'n::finite" shows |
|
4850 "interior {a .. b} = {a<..<b}" (is "?L = ?R") |
|
4851 proof(rule subset_antisym) |
|
4852 show "?R \<subseteq> ?L" using interior_maximal[OF interval_open_subset_closed open_interval] by auto |
|
4853 next |
|
4854 { fix x assume "\<exists>T. open T \<and> x \<in> T \<and> T \<subseteq> {a..b}" |
|
4855 then obtain s where s:"open s" "x \<in> s" "s \<subseteq> {a..b}" by auto |
|
4856 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 |
|
4857 { fix i |
|
4858 have "dist (x - (e / 2) *\<^sub>R basis i) x < e" |
|
4859 "dist (x + (e / 2) *\<^sub>R basis i) x < e" |
|
4860 unfolding dist_norm apply auto |
|
4861 unfolding norm_minus_cancel using norm_basis[of i] and `e>0` by auto |
|
4862 hence "a $ i \<le> (x - (e / 2) *\<^sub>R basis i) $ i" |
|
4863 "(x + (e / 2) *\<^sub>R basis i) $ i \<le> b $ i" |
|
4864 using e[THEN spec[where x="x - (e/2) *\<^sub>R basis i"]] |
|
4865 and e[THEN spec[where x="x + (e/2) *\<^sub>R basis i"]] |
|
4866 unfolding mem_interval by (auto elim!: allE[where x=i]) |
|
4867 hence "a $ i < x $ i" and "x $ i < b $ i" |
|
4868 unfolding vector_minus_component and vector_add_component |
|
4869 unfolding vector_smult_component and basis_component using `e>0` by auto } |
|
4870 hence "x \<in> {a<..<b}" unfolding mem_interval by auto } |
|
4871 thus "?L \<subseteq> ?R" unfolding interior_def and subset_eq by auto |
|
4872 qed |
|
4873 |
|
4874 lemma bounded_closed_interval: fixes a :: "real^'n::finite" shows |
|
4875 "bounded {a .. b}" |
|
4876 proof- |
|
4877 let ?b = "\<Sum>i\<in>UNIV. \<bar>a$i\<bar> + \<bar>b$i\<bar>" |
|
4878 { fix x::"real^'n" assume x:"\<forall>i. a $ i \<le> x $ i \<and> x $ i \<le> b $ i" |
|
4879 { fix i |
|
4880 have "\<bar>x$i\<bar> \<le> \<bar>a$i\<bar> + \<bar>b$i\<bar>" using x[THEN spec[where x=i]] by auto } |
|
4881 hence "(\<Sum>i\<in>UNIV. \<bar>x $ i\<bar>) \<le> ?b" by(rule setsum_mono) |
|
4882 hence "norm x \<le> ?b" using norm_le_l1[of x] by auto } |
|
4883 thus ?thesis unfolding interval and bounded_iff by auto |
|
4884 qed |
|
4885 |
|
4886 lemma bounded_interval: fixes a :: "real^'n::finite" shows |
|
4887 "bounded {a .. b} \<and> bounded {a<..<b}" |
|
4888 using bounded_closed_interval[of a b] |
|
4889 using interval_open_subset_closed[of a b] |
|
4890 using bounded_subset[of "{a..b}" "{a<..<b}"] |
|
4891 by simp |
|
4892 |
|
4893 lemma not_interval_univ: fixes a :: "real^'n::finite" shows |
|
4894 "({a .. b} \<noteq> UNIV) \<and> ({a<..<b} \<noteq> UNIV)" |
|
4895 using bounded_interval[of a b] |
|
4896 by auto |
|
4897 |
|
4898 lemma compact_interval: fixes a :: "real^'n::finite" shows |
|
4899 "compact {a .. b}" |
|
4900 using bounded_closed_imp_compact using bounded_interval[of a b] using closed_interval[of a b] by auto |
|
4901 |
|
4902 lemma open_interval_midpoint: fixes a :: "real^'n::finite" |
|
4903 assumes "{a<..<b} \<noteq> {}" shows "((1/2) *\<^sub>R (a + b)) \<in> {a<..<b}" |
|
4904 proof- |
|
4905 { fix i |
|
4906 have "a $ i < ((1 / 2) *\<^sub>R (a + b)) $ i \<and> ((1 / 2) *\<^sub>R (a + b)) $ i < b $ i" |
|
4907 using assms[unfolded interval_ne_empty, THEN spec[where x=i]] |
|
4908 unfolding vector_smult_component and vector_add_component |
|
4909 by(auto simp add: less_divide_eq_number_of1) } |
|
4910 thus ?thesis unfolding mem_interval by auto |
|
4911 qed |
|
4912 |
|
4913 lemma open_closed_interval_convex: fixes x :: "real^'n::finite" |
|
4914 assumes x:"x \<in> {a<..<b}" and y:"y \<in> {a .. b}" and e:"0 < e" "e \<le> 1" |
|
4915 shows "(e *\<^sub>R x + (1 - e) *\<^sub>R y) \<in> {a<..<b}" |
|
4916 proof- |
|
4917 { fix i |
|
4918 have "a $ i = e * a$i + (1 - e) * a$i" unfolding left_diff_distrib by simp |
|
4919 also have "\<dots> < e * x $ i + (1 - e) * y $ i" apply(rule add_less_le_mono) |
|
4920 using e unfolding mult_less_cancel_left and mult_le_cancel_left apply simp_all |
|
4921 using x unfolding mem_interval apply simp |
|
4922 using y unfolding mem_interval apply simp |
|
4923 done |
|
4924 finally have "a $ i < (e *\<^sub>R x + (1 - e) *\<^sub>R y) $ i" by auto |
|
4925 moreover { |
|
4926 have "b $ i = e * b$i + (1 - e) * b$i" unfolding left_diff_distrib by simp |
|
4927 also have "\<dots> > e * x $ i + (1 - e) * y $ i" apply(rule add_less_le_mono) |
|
4928 using e unfolding mult_less_cancel_left and mult_le_cancel_left apply simp_all |
|
4929 using x unfolding mem_interval apply simp |
|
4930 using y unfolding mem_interval apply simp |
|
4931 done |
|
4932 finally have "(e *\<^sub>R x + (1 - e) *\<^sub>R y) $ i < b $ i" by auto |
|
4933 } 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 } |
|
4934 thus ?thesis unfolding mem_interval by auto |
|
4935 qed |
|
4936 |
|
4937 lemma closure_open_interval: fixes a :: "real^'n::finite" |
|
4938 assumes "{a<..<b} \<noteq> {}" |
|
4939 shows "closure {a<..<b} = {a .. b}" |
|
4940 proof- |
|
4941 have ab:"a < b" using assms[unfolded interval_ne_empty] unfolding vector_less_def by auto |
|
4942 let ?c = "(1 / 2) *\<^sub>R (a + b)" |
|
4943 { fix x assume as:"x \<in> {a .. b}" |
|
4944 def f == "\<lambda>n::nat. x + (inverse (real n + 1)) *\<^sub>R (?c - x)" |
|
4945 { fix n assume fn:"f n < b \<longrightarrow> a < f n \<longrightarrow> f n = x" and xc:"x \<noteq> ?c" |
|
4946 have *:"0 < inverse (real n + 1)" "inverse (real n + 1) \<le> 1" unfolding inverse_le_1_iff by auto |
|
4947 have "(inverse (real n + 1)) *\<^sub>R ((1 / 2) *\<^sub>R (a + b)) + (1 - inverse (real n + 1)) *\<^sub>R x = |
|
4948 x + (inverse (real n + 1)) *\<^sub>R (((1 / 2) *\<^sub>R (a + b)) - x)" |
|
4949 by (auto simp add: algebra_simps) |
|
4950 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 |
|
4951 hence False using fn unfolding f_def using xc by(auto simp add: vector_mul_lcancel vector_ssub_ldistrib) } |
|
4952 moreover |
|
4953 { assume "\<not> (f ---> x) sequentially" |
|
4954 { fix e::real assume "e>0" |
|
4955 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 |
|
4956 then obtain N::nat where "inverse (real (N + 1)) < e" by auto |
|
4957 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) |
|
4958 hence "\<exists>N::nat. \<forall>n\<ge>N. inverse (real n + 1) < e" by auto } |
|
4959 hence "((\<lambda>n. inverse (real n + 1)) ---> 0) sequentially" |
|
4960 unfolding Lim_sequentially by(auto simp add: dist_norm) |
|
4961 hence "(f ---> x) sequentially" unfolding f_def |
|
4962 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] |
|
4963 using Lim_vmul[of "\<lambda>n::nat. inverse (real n + 1)" 0 sequentially "((1 / 2) *\<^sub>R (a + b) - x)"] by auto } |
|
4964 ultimately have "x \<in> closure {a<..<b}" |
|
4965 using as and open_interval_midpoint[OF assms] unfolding closure_def unfolding islimpt_sequential by(cases "x=?c")auto } |
|
4966 thus ?thesis using closure_minimal[OF interval_open_subset_closed closed_interval, of a b] by blast |
|
4967 qed |
|
4968 |
|
4969 lemma bounded_subset_open_interval_symmetric: fixes s::"(real^'n::finite) set" |
|
4970 assumes "bounded s" shows "\<exists>a. s \<subseteq> {-a<..<a}" |
|
4971 proof- |
|
4972 obtain b where "b>0" and b:"\<forall>x\<in>s. norm x \<le> b" using assms[unfolded bounded_pos] by auto |
|
4973 def a \<equiv> "(\<chi> i. b+1)::real^'n" |
|
4974 { fix x assume "x\<in>s" |
|
4975 fix i |
|
4976 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] |
|
4977 unfolding vector_uminus_component and a_def and Cart_lambda_beta by auto |
|
4978 } |
|
4979 thus ?thesis by(auto intro: exI[where x=a] simp add: vector_less_def) |
|
4980 qed |
|
4981 |
|
4982 lemma bounded_subset_open_interval: |
|
4983 fixes s :: "(real ^ 'n::finite) set" |
|
4984 shows "bounded s ==> (\<exists>a b. s \<subseteq> {a<..<b})" |
|
4985 by (auto dest!: bounded_subset_open_interval_symmetric) |
|
4986 |
|
4987 lemma bounded_subset_closed_interval_symmetric: |
|
4988 fixes s :: "(real ^ 'n::finite) set" |
|
4989 assumes "bounded s" shows "\<exists>a. s \<subseteq> {-a .. a}" |
|
4990 proof- |
|
4991 obtain a where "s \<subseteq> {- a<..<a}" using bounded_subset_open_interval_symmetric[OF assms] by auto |
|
4992 thus ?thesis using interval_open_subset_closed[of "-a" a] by auto |
|
4993 qed |
|
4994 |
|
4995 lemma bounded_subset_closed_interval: |
|
4996 fixes s :: "(real ^ 'n::finite) set" |
|
4997 shows "bounded s ==> (\<exists>a b. s \<subseteq> {a .. b})" |
|
4998 using bounded_subset_closed_interval_symmetric[of s] by auto |
|
4999 |
|
5000 lemma frontier_closed_interval: |
|
5001 fixes a b :: "real ^ _" |
|
5002 shows "frontier {a .. b} = {a .. b} - {a<..<b}" |
|
5003 unfolding frontier_def unfolding interior_closed_interval and closure_closed[OF closed_interval] .. |
|
5004 |
|
5005 lemma frontier_open_interval: |
|
5006 fixes a b :: "real ^ _" |
|
5007 shows "frontier {a<..<b} = (if {a<..<b} = {} then {} else {a .. b} - {a<..<b})" |
|
5008 proof(cases "{a<..<b} = {}") |
|
5009 case True thus ?thesis using frontier_empty by auto |
|
5010 next |
|
5011 case False thus ?thesis unfolding frontier_def and closure_open_interval[OF False] and interior_open[OF open_interval] by auto |
|
5012 qed |
|
5013 |
|
5014 lemma inter_interval_mixed_eq_empty: fixes a :: "real^'n::finite" |
|
5015 assumes "{c<..<d} \<noteq> {}" shows "{a<..<b} \<inter> {c .. d} = {} \<longleftrightarrow> {a<..<b} \<inter> {c<..<d} = {}" |
|
5016 unfolding closure_open_interval[OF assms, THEN sym] unfolding open_inter_closure_eq_empty[OF open_interval] .. |
|
5017 |
|
5018 |
|
5019 (* Some special cases for intervals in R^1. *) |
|
5020 |
|
5021 lemma all_1: "(\<forall>x::1. P x) \<longleftrightarrow> P 1" |
|
5022 by (metis num1_eq_iff) |
|
5023 |
|
5024 lemma ex_1: "(\<exists>x::1. P x) \<longleftrightarrow> P 1" |
|
5025 by auto (metis num1_eq_iff) |
|
5026 |
|
5027 lemma interval_cases_1: fixes x :: "real^1" shows |
|
5028 "x \<in> {a .. b} ==> x \<in> {a<..<b} \<or> (x = a) \<or> (x = b)" |
|
5029 by(simp add: Cart_eq vector_less_def vector_less_eq_def all_1, auto) |
|
5030 |
|
5031 lemma in_interval_1: fixes x :: "real^1" shows |
|
5032 "(x \<in> {a .. b} \<longleftrightarrow> dest_vec1 a \<le> dest_vec1 x \<and> dest_vec1 x \<le> dest_vec1 b) \<and> |
|
5033 (x \<in> {a<..<b} \<longleftrightarrow> dest_vec1 a < dest_vec1 x \<and> dest_vec1 x < dest_vec1 b)" |
|
5034 by(simp add: Cart_eq vector_less_def vector_less_eq_def all_1 dest_vec1_def) |
|
5035 |
|
5036 lemma interval_eq_empty_1: fixes a :: "real^1" shows |
|
5037 "{a .. b} = {} \<longleftrightarrow> dest_vec1 b < dest_vec1 a" |
|
5038 "{a<..<b} = {} \<longleftrightarrow> dest_vec1 b \<le> dest_vec1 a" |
|
5039 unfolding interval_eq_empty and ex_1 and dest_vec1_def by auto |
|
5040 |
|
5041 lemma subset_interval_1: fixes a :: "real^1" shows |
|
5042 "({a .. b} \<subseteq> {c .. d} \<longleftrightarrow> dest_vec1 b < dest_vec1 a \<or> |
|
5043 dest_vec1 c \<le> dest_vec1 a \<and> dest_vec1 a \<le> dest_vec1 b \<and> dest_vec1 b \<le> dest_vec1 d)" |
|
5044 "({a .. b} \<subseteq> {c<..<d} \<longleftrightarrow> dest_vec1 b < dest_vec1 a \<or> |
|
5045 dest_vec1 c < dest_vec1 a \<and> dest_vec1 a \<le> dest_vec1 b \<and> dest_vec1 b < 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 "({a<..<b} \<subseteq> {c<..<d} \<longleftrightarrow> dest_vec1 b \<le> dest_vec1 a \<or> |
|
5049 dest_vec1 c \<le> dest_vec1 a \<and> dest_vec1 a < dest_vec1 b \<and> dest_vec1 b \<le> dest_vec1 d)" |
|
5050 unfolding subset_interval[of a b c d] unfolding all_1 and dest_vec1_def by auto |
|
5051 |
|
5052 lemma eq_interval_1: fixes a :: "real^1" shows |
|
5053 "{a .. b} = {c .. d} \<longleftrightarrow> |
|
5054 dest_vec1 b < dest_vec1 a \<and> dest_vec1 d < dest_vec1 c \<or> |
|
5055 dest_vec1 a = dest_vec1 c \<and> dest_vec1 b = dest_vec1 d" |
|
5056 using set_eq_subset[of "{a .. b}" "{c .. d}"] |
|
5057 using subset_interval_1(1)[of a b c d] |
|
5058 using subset_interval_1(1)[of c d a b] |
|
5059 by auto (* FIXME: slow *) |
|
5060 |
|
5061 lemma disjoint_interval_1: fixes a :: "real^1" shows |
|
5062 "{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" |
|
5063 "{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" |
|
5064 "{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" |
|
5065 "{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" |
|
5066 unfolding disjoint_interval and dest_vec1_def ex_1 by auto |
|
5067 |
|
5068 lemma open_closed_interval_1: fixes a :: "real^1" shows |
|
5069 "{a<..<b} = {a .. b} - {a, b}" |
|
5070 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 |
|
5071 |
|
5072 lemma closed_open_interval_1: "dest_vec1 (a::real^1) \<le> dest_vec1 b ==> {a .. b} = {a<..<b} \<union> {a,b}" |
|
5073 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 |
|
5074 |
|
5075 (* Some stuff for half-infinite intervals too; FIXME: notation? *) |
|
5076 |
|
5077 lemma closed_interval_left: fixes b::"real^'n::finite" |
|
5078 shows "closed {x::real^'n. \<forall>i. x$i \<le> b$i}" |
|
5079 proof- |
|
5080 { fix i |
|
5081 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" |
|
5082 { assume "x$i > b$i" |
|
5083 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 |
|
5084 hence False using component_le_norm[of "y - x" i] unfolding dist_norm and vector_minus_component by auto } |
|
5085 hence "x$i \<le> b$i" by(rule ccontr)auto } |
|
5086 thus ?thesis unfolding closed_limpt unfolding islimpt_approachable by blast |
|
5087 qed |
|
5088 |
|
5089 lemma closed_interval_right: fixes a::"real^'n::finite" |
|
5090 shows "closed {x::real^'n. \<forall>i. a$i \<le> x$i}" |
|
5091 proof- |
|
5092 { fix i |
|
5093 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" |
|
5094 { assume "a$i > x$i" |
|
5095 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 |
|
5096 hence False using component_le_norm[of "y - x" i] unfolding dist_norm and vector_minus_component by auto } |
|
5097 hence "a$i \<le> x$i" by(rule ccontr)auto } |
|
5098 thus ?thesis unfolding closed_limpt unfolding islimpt_approachable by blast |
|
5099 qed |
|
5100 |
|
5101 subsection{* Intervals in general, including infinite and mixtures of open and closed. *} |
|
5102 |
|
5103 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)" |
|
5104 |
|
5105 lemma is_interval_interval: "is_interval {a .. b::real^'n::finite}" (is ?th1) "is_interval {a<..<b}" (is ?th2) proof - |
|
5106 have *:"\<And>x y z::real. x < y \<Longrightarrow> y < z \<Longrightarrow> x < z" by auto |
|
5107 show ?th1 ?th2 unfolding is_interval_def mem_interval Ball_def atLeastAtMost_iff |
|
5108 by(meson real_le_trans le_less_trans less_le_trans *)+ qed |
|
5109 |
|
5110 lemma is_interval_empty: |
|
5111 "is_interval {}" |
|
5112 unfolding is_interval_def |
|
5113 by simp |
|
5114 |
|
5115 lemma is_interval_univ: |
|
5116 "is_interval UNIV" |
|
5117 unfolding is_interval_def |
|
5118 by simp |
|
5119 |
|
5120 subsection{* Closure of halfspaces and hyperplanes. *} |
|
5121 |
|
5122 lemma Lim_inner: |
|
5123 assumes "(f ---> l) net" shows "((\<lambda>y. inner a (f y)) ---> inner a l) net" |
|
5124 by (intro tendsto_intros assms) |
|
5125 |
|
5126 lemma continuous_at_inner: "continuous (at x) (inner a)" |
|
5127 unfolding continuous_at by (intro tendsto_intros) |
|
5128 |
|
5129 lemma continuous_on_inner: |
|
5130 fixes s :: "'a::real_inner set" |
|
5131 shows "continuous_on s (inner a)" |
|
5132 unfolding continuous_on by (rule ballI) (intro tendsto_intros) |
|
5133 |
|
5134 lemma closed_halfspace_le: "closed {x. inner a x \<le> b}" |
|
5135 proof- |
|
5136 have "\<forall>x. continuous (at x) (inner a)" |
|
5137 unfolding continuous_at by (rule allI) (intro tendsto_intros) |
|
5138 hence "closed (inner a -` {..b})" |
|
5139 using closed_real_atMost by (rule continuous_closed_vimage) |
|
5140 moreover have "{x. inner a x \<le> b} = inner a -` {..b}" by auto |
|
5141 ultimately show ?thesis by simp |
|
5142 qed |
|
5143 |
|
5144 lemma closed_halfspace_ge: "closed {x. inner a x \<ge> b}" |
|
5145 using closed_halfspace_le[of "-a" "-b"] unfolding inner_minus_left by auto |
|
5146 |
|
5147 lemma closed_hyperplane: "closed {x. inner a x = b}" |
|
5148 proof- |
|
5149 have "{x. inner a x = b} = {x. inner a x \<ge> b} \<inter> {x. inner a x \<le> b}" by auto |
|
5150 thus ?thesis using closed_halfspace_le[of a b] and closed_halfspace_ge[of b a] using closed_Int by auto |
|
5151 qed |
|
5152 |
|
5153 lemma closed_halfspace_component_le: |
|
5154 shows "closed {x::real^'n::finite. x$i \<le> a}" |
|
5155 using closed_halfspace_le[of "(basis i)::real^'n" a] unfolding inner_basis[OF assms] by auto |
|
5156 |
|
5157 lemma closed_halfspace_component_ge: |
|
5158 shows "closed {x::real^'n::finite. x$i \<ge> a}" |
|
5159 using closed_halfspace_ge[of a "(basis i)::real^'n"] unfolding inner_basis[OF assms] by auto |
|
5160 |
|
5161 text{* Openness of halfspaces. *} |
|
5162 |
|
5163 lemma open_halfspace_lt: "open {x. inner a x < b}" |
|
5164 proof- |
|
5165 have "UNIV - {x. b \<le> inner a x} = {x. inner a x < b}" by auto |
|
5166 thus ?thesis using closed_halfspace_ge[unfolded closed_def Compl_eq_Diff_UNIV, of b a] by auto |
|
5167 qed |
|
5168 |
|
5169 lemma open_halfspace_gt: "open {x. inner a x > b}" |
|
5170 proof- |
|
5171 have "UNIV - {x. b \<ge> inner a x} = {x. inner a x > b}" by auto |
|
5172 thus ?thesis using closed_halfspace_le[unfolded closed_def Compl_eq_Diff_UNIV, of a b] by auto |
|
5173 qed |
|
5174 |
|
5175 lemma open_halfspace_component_lt: |
|
5176 shows "open {x::real^'n::finite. x$i < a}" |
|
5177 using open_halfspace_lt[of "(basis i)::real^'n" a] unfolding inner_basis[OF assms] by auto |
|
5178 |
|
5179 lemma open_halfspace_component_gt: |
|
5180 shows "open {x::real^'n::finite. x$i > a}" |
|
5181 using open_halfspace_gt[of a "(basis i)::real^'n"] unfolding inner_basis[OF assms] by auto |
|
5182 |
|
5183 text{* This gives a simple derivation of limit component bounds. *} |
|
5184 |
|
5185 lemma Lim_component_le: fixes f :: "'a \<Rightarrow> real^'n::finite" |
|
5186 assumes "(f ---> l) net" "\<not> (trivial_limit net)" "eventually (\<lambda>x. f(x)$i \<le> b) net" |
|
5187 shows "l$i \<le> b" |
|
5188 proof- |
|
5189 { 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 |
|
5190 show ?thesis using Lim_in_closed_set[of "{x. inner (basis i) x \<le> b}" f net l] unfolding * |
|
5191 using closed_halfspace_le[of "(basis i)::real^'n" b] and assms(1,2,3) by auto |
|
5192 qed |
|
5193 |
|
5194 lemma Lim_component_ge: fixes f :: "'a \<Rightarrow> real^'n::finite" |
|
5195 assumes "(f ---> l) net" "\<not> (trivial_limit net)" "eventually (\<lambda>x. b \<le> (f x)$i) net" |
|
5196 shows "b \<le> l$i" |
|
5197 proof- |
|
5198 { 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 |
|
5199 show ?thesis using Lim_in_closed_set[of "{x. inner (basis i) x \<ge> b}" f net l] unfolding * |
|
5200 using closed_halfspace_ge[of b "(basis i)::real^'n"] and assms(1,2,3) by auto |
|
5201 qed |
|
5202 |
|
5203 lemma Lim_component_eq: fixes f :: "'a \<Rightarrow> real^'n::finite" |
|
5204 assumes net:"(f ---> l) net" "~(trivial_limit net)" and ev:"eventually (\<lambda>x. f(x)$i = b) net" |
|
5205 shows "l$i = b" |
|
5206 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 |
|
5207 |
|
5208 lemma Lim_drop_le: fixes f :: "'a \<Rightarrow> real^1" shows |
|
5209 "(f ---> l) net \<Longrightarrow> ~(trivial_limit net) \<Longrightarrow> eventually (\<lambda>x. dest_vec1 (f x) \<le> b) net ==> dest_vec1 l \<le> b" |
|
5210 using Lim_component_le[of f l net 1 b] unfolding dest_vec1_def by auto |
|
5211 |
|
5212 lemma Lim_drop_ge: fixes f :: "'a \<Rightarrow> real^1" shows |
|
5213 "(f ---> l) net \<Longrightarrow> ~(trivial_limit net) \<Longrightarrow> eventually (\<lambda>x. b \<le> dest_vec1 (f x)) net ==> b \<le> dest_vec1 l" |
|
5214 using Lim_component_ge[of f l net b 1] unfolding dest_vec1_def by auto |
|
5215 |
|
5216 text{* Limits relative to a union. *} |
|
5217 |
|
5218 lemma eventually_within_Un: |
|
5219 "eventually P (net within (s \<union> t)) \<longleftrightarrow> |
|
5220 eventually P (net within s) \<and> eventually P (net within t)" |
|
5221 unfolding Limits.eventually_within |
|
5222 by (auto elim!: eventually_rev_mp) |
|
5223 |
|
5224 lemma Lim_within_union: |
|
5225 "(f ---> l) (net within (s \<union> t)) \<longleftrightarrow> |
|
5226 (f ---> l) (net within s) \<and> (f ---> l) (net within t)" |
|
5227 unfolding tendsto_def |
|
5228 by (auto simp add: eventually_within_Un) |
|
5229 |
|
5230 lemma continuous_on_union: |
|
5231 assumes "closed s" "closed t" "continuous_on s f" "continuous_on t f" |
|
5232 shows "continuous_on (s \<union> t) f" |
|
5233 using assms unfolding continuous_on unfolding Lim_within_union |
|
5234 unfolding Lim unfolding trivial_limit_within unfolding closed_limpt by auto |
|
5235 |
|
5236 lemma continuous_on_cases: |
|
5237 assumes "closed s" "closed t" "continuous_on s f" "continuous_on t g" |
|
5238 "\<forall>x. (x\<in>s \<and> \<not> P x) \<or> (x \<in> t \<and> P x) \<longrightarrow> f x = g x" |
|
5239 shows "continuous_on (s \<union> t) (\<lambda>x. if P x then f x else g x)" |
|
5240 proof- |
|
5241 let ?h = "(\<lambda>x. if P x then f x else g x)" |
|
5242 have "\<forall>x\<in>s. f x = (if P x then f x else g x)" using assms(5) by auto |
|
5243 hence "continuous_on s ?h" using continuous_on_eq[of s f ?h] using assms(3) by auto |
|
5244 moreover |
|
5245 have "\<forall>x\<in>t. g x = (if P x then f x else g x)" using assms(5) by auto |
|
5246 hence "continuous_on t ?h" using continuous_on_eq[of t g ?h] using assms(4) by auto |
|
5247 ultimately show ?thesis using continuous_on_union[OF assms(1,2), of ?h] by auto |
|
5248 qed |
|
5249 |
|
5250 |
|
5251 text{* Some more convenient intermediate-value theorem formulations. *} |
|
5252 |
|
5253 lemma connected_ivt_hyperplane: |
|
5254 assumes "connected s" "x \<in> s" "y \<in> s" "inner a x \<le> b" "b \<le> inner a y" |
|
5255 shows "\<exists>z \<in> s. inner a z = b" |
|
5256 proof(rule ccontr) |
|
5257 assume as:"\<not> (\<exists>z\<in>s. inner a z = b)" |
|
5258 let ?A = "{x. inner a x < b}" |
|
5259 let ?B = "{x. inner a x > b}" |
|
5260 have "open ?A" "open ?B" using open_halfspace_lt and open_halfspace_gt by auto |
|
5261 moreover have "?A \<inter> ?B = {}" by auto |
|
5262 moreover have "s \<subseteq> ?A \<union> ?B" using as by auto |
|
5263 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 |
|
5264 qed |
|
5265 |
|
5266 lemma connected_ivt_component: fixes x::"real^'n::finite" shows |
|
5267 "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)" |
|
5268 using connected_ivt_hyperplane[of s x y "(basis k)::real^'n" a] by (auto simp add: inner_basis) |
|
5269 |
|
5270 text{* Also more convenient formulations of monotone convergence. *} |
|
5271 |
|
5272 lemma bounded_increasing_convergent: fixes s::"nat \<Rightarrow> real^1" |
|
5273 assumes "bounded {s n| n::nat. True}" "\<forall>n. dest_vec1(s n) \<le> dest_vec1(s(Suc n))" |
|
5274 shows "\<exists>l. (s ---> l) sequentially" |
|
5275 proof- |
|
5276 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 |
|
5277 { fix m::nat |
|
5278 have "\<And> n. n\<ge>m \<longrightarrow> dest_vec1 (s m) \<le> dest_vec1 (s n)" |
|
5279 apply(induct_tac n) apply simp using assms(2) apply(erule_tac x="na" in allE) by(auto simp add: not_less_eq_eq) } |
|
5280 hence "\<forall>m n. m \<le> n \<longrightarrow> dest_vec1 (s m) \<le> dest_vec1 (s n)" by auto |
|
5281 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 |
|
5282 thus ?thesis unfolding Lim_sequentially apply(rule_tac x="vec1 l" in exI) |
|
5283 unfolding dist_norm unfolding abs_dest_vec1 and dest_vec1_sub by auto |
|
5284 qed |
|
5285 |
|
5286 subsection{* Basic homeomorphism definitions. *} |
|
5287 |
|
5288 definition "homeomorphism s t f g \<equiv> |
|
5289 (\<forall>x\<in>s. (g(f x) = x)) \<and> (f ` s = t) \<and> continuous_on s f \<and> |
|
5290 (\<forall>y\<in>t. (f(g y) = y)) \<and> (g ` t = s) \<and> continuous_on t g" |
|
5291 |
|
5292 definition |
|
5293 homeomorphic :: "'a::metric_space set \<Rightarrow> 'b::metric_space set \<Rightarrow> bool" |
|
5294 (infixr "homeomorphic" 60) where |
|
5295 homeomorphic_def: "s homeomorphic t \<equiv> (\<exists>f g. homeomorphism s t f g)" |
|
5296 |
|
5297 lemma homeomorphic_refl: "s homeomorphic s" |
|
5298 unfolding homeomorphic_def |
|
5299 unfolding homeomorphism_def |
|
5300 using continuous_on_id |
|
5301 apply(rule_tac x = "(\<lambda>x. x)" in exI) |
|
5302 apply(rule_tac x = "(\<lambda>x. x)" in exI) |
|
5303 by blast |
|
5304 |
|
5305 lemma homeomorphic_sym: |
|
5306 "s homeomorphic t \<longleftrightarrow> t homeomorphic s" |
|
5307 unfolding homeomorphic_def |
|
5308 unfolding homeomorphism_def |
|
5309 by blast (* FIXME: slow *) |
|
5310 |
|
5311 lemma homeomorphic_trans: |
|
5312 assumes "s homeomorphic t" "t homeomorphic u" shows "s homeomorphic u" |
|
5313 proof- |
|
5314 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" |
|
5315 using assms(1) unfolding homeomorphic_def homeomorphism_def by auto |
|
5316 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" |
|
5317 using assms(2) unfolding homeomorphic_def homeomorphism_def by auto |
|
5318 |
|
5319 { 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 } |
|
5320 moreover have "(f2 \<circ> f1) ` s = u" using fg1(2) fg2(2) by auto |
|
5321 moreover have "continuous_on s (f2 \<circ> f1)" using continuous_on_compose[OF fg1(3)] and fg2(3) unfolding fg1(2) by auto |
|
5322 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 } |
|
5323 moreover have "(g1 \<circ> g2) ` u = s" using fg1(5) fg2(5) by auto |
|
5324 moreover have "continuous_on u (g1 \<circ> g2)" using continuous_on_compose[OF fg2(6)] and fg1(6) unfolding fg2(5) by auto |
|
5325 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 |
|
5326 qed |
|
5327 |
|
5328 lemma homeomorphic_minimal: |
|
5329 "s homeomorphic t \<longleftrightarrow> |
|
5330 (\<exists>f g. (\<forall>x\<in>s. f(x) \<in> t \<and> (g(f(x)) = x)) \<and> |
|
5331 (\<forall>y\<in>t. g(y) \<in> s \<and> (f(g(y)) = y)) \<and> |
|
5332 continuous_on s f \<and> continuous_on t g)" |
|
5333 unfolding homeomorphic_def homeomorphism_def |
|
5334 apply auto apply (rule_tac x=f in exI) apply (rule_tac x=g in exI) |
|
5335 apply auto apply (rule_tac x=f in exI) apply (rule_tac x=g in exI) apply auto |
|
5336 unfolding image_iff |
|
5337 apply(erule_tac x="g x" in ballE) apply(erule_tac x="x" in ballE) |
|
5338 apply auto apply(rule_tac x="g x" in bexI) apply auto |
|
5339 apply(erule_tac x="f x" in ballE) apply(erule_tac x="x" in ballE) |
|
5340 apply auto apply(rule_tac x="f x" in bexI) by auto |
|
5341 |
|
5342 subsection{* Relatively weak hypotheses if a set is compact. *} |
|
5343 |
|
5344 definition "inv_on f s = (\<lambda>x. SOME y. y\<in>s \<and> f y = x)" |
|
5345 |
|
5346 lemma assumes "inj_on f s" "x\<in>s" |
|
5347 shows "inv_on f s (f x) = x" |
|
5348 using assms unfolding inj_on_def inv_on_def by auto |
|
5349 |
|
5350 lemma homeomorphism_compact: |
|
5351 fixes f :: "'a::heine_borel \<Rightarrow> 'b::heine_borel" |
|
5352 (* class constraint due to continuous_on_inverse *) |
|
5353 assumes "compact s" "continuous_on s f" "f ` s = t" "inj_on f s" |
|
5354 shows "\<exists>g. homeomorphism s t f g" |
|
5355 proof- |
|
5356 def g \<equiv> "\<lambda>x. SOME y. y\<in>s \<and> f y = x" |
|
5357 have g:"\<forall>x\<in>s. g (f x) = x" using assms(3) assms(4)[unfolded inj_on_def] unfolding g_def by auto |
|
5358 { fix y assume "y\<in>t" |
|
5359 then obtain x where x:"f x = y" "x\<in>s" using assms(3) by auto |
|
5360 hence "g (f x) = x" using g by auto |
|
5361 hence "f (g y) = y" unfolding x(1)[THEN sym] by auto } |
|
5362 hence g':"\<forall>x\<in>t. f (g x) = x" by auto |
|
5363 moreover |
|
5364 { fix x |
|
5365 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"]) |
|
5366 moreover |
|
5367 { assume "x\<in>g ` t" |
|
5368 then obtain y where y:"y\<in>t" "g y = x" by auto |
|
5369 then obtain x' where x':"x'\<in>s" "f x' = y" using assms(3) by auto |
|
5370 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 } |
|
5371 ultimately have "x\<in>s \<longleftrightarrow> x \<in> g ` t" by auto } |
|
5372 hence "g ` t = s" by auto |
|
5373 ultimately |
|
5374 show ?thesis unfolding homeomorphism_def homeomorphic_def |
|
5375 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 |
|
5376 qed |
|
5377 |
|
5378 lemma homeomorphic_compact: |
|
5379 fixes f :: "'a::heine_borel \<Rightarrow> 'b::heine_borel" |
|
5380 (* class constraint due to continuous_on_inverse *) |
|
5381 shows "compact s \<Longrightarrow> continuous_on s f \<Longrightarrow> (f ` s = t) \<Longrightarrow> inj_on f s |
|
5382 \<Longrightarrow> s homeomorphic t" |
|
5383 unfolding homeomorphic_def by(metis homeomorphism_compact) |
|
5384 |
|
5385 text{* Preservation of topological properties. *} |
|
5386 |
|
5387 lemma homeomorphic_compactness: |
|
5388 "s homeomorphic t ==> (compact s \<longleftrightarrow> compact t)" |
|
5389 unfolding homeomorphic_def homeomorphism_def |
|
5390 by (metis compact_continuous_image) |
|
5391 |
|
5392 text{* Results on translation, scaling etc. *} |
|
5393 |
|
5394 lemma homeomorphic_scaling: |
|
5395 fixes s :: "'a::real_normed_vector set" |
|
5396 assumes "c \<noteq> 0" shows "s homeomorphic ((\<lambda>x. c *\<^sub>R x) ` s)" |
|
5397 unfolding homeomorphic_minimal |
|
5398 apply(rule_tac x="\<lambda>x. c *\<^sub>R x" in exI) |
|
5399 apply(rule_tac x="\<lambda>x. (1 / c) *\<^sub>R x" in exI) |
|
5400 using assms apply auto |
|
5401 using continuous_on_cmul[OF continuous_on_id] by auto |
|
5402 |
|
5403 lemma homeomorphic_translation: |
|
5404 fixes s :: "'a::real_normed_vector set" |
|
5405 shows "s homeomorphic ((\<lambda>x. a + x) ` s)" |
|
5406 unfolding homeomorphic_minimal |
|
5407 apply(rule_tac x="\<lambda>x. a + x" in exI) |
|
5408 apply(rule_tac x="\<lambda>x. -a + x" in exI) |
|
5409 using continuous_on_add[OF continuous_on_const continuous_on_id] by auto |
|
5410 |
|
5411 lemma homeomorphic_affinity: |
|
5412 fixes s :: "'a::real_normed_vector set" |
|
5413 assumes "c \<noteq> 0" shows "s homeomorphic ((\<lambda>x. a + c *\<^sub>R x) ` s)" |
|
5414 proof- |
|
5415 have *:"op + a ` op *\<^sub>R c ` s = (\<lambda>x. a + c *\<^sub>R x) ` s" by auto |
|
5416 show ?thesis |
|
5417 using homeomorphic_trans |
|
5418 using homeomorphic_scaling[OF assms, of s] |
|
5419 using homeomorphic_translation[of "(\<lambda>x. c *\<^sub>R x) ` s" a] unfolding * by auto |
|
5420 qed |
|
5421 |
|
5422 lemma homeomorphic_balls: |
|
5423 fixes a b ::"'a::real_normed_vector" (* FIXME: generalize to metric_space *) |
|
5424 assumes "0 < d" "0 < e" |
|
5425 shows "(ball a d) homeomorphic (ball b e)" (is ?th) |
|
5426 "(cball a d) homeomorphic (cball b e)" (is ?cth) |
|
5427 proof- |
|
5428 have *:"\<bar>e / d\<bar> > 0" "\<bar>d / e\<bar> >0" using assms using divide_pos_pos by auto |
|
5429 show ?th unfolding homeomorphic_minimal |
|
5430 apply(rule_tac x="\<lambda>x. b + (e/d) *\<^sub>R (x - a)" in exI) |
|
5431 apply(rule_tac x="\<lambda>x. a + (d/e) *\<^sub>R (x - b)" in exI) |
|
5432 using assms apply (auto simp add: dist_commute) |
|
5433 unfolding dist_norm |
|
5434 apply (auto simp add: pos_divide_less_eq mult_strict_left_mono) |
|
5435 unfolding continuous_on |
|
5436 by (intro ballI tendsto_intros, simp, assumption)+ |
|
5437 next |
|
5438 have *:"\<bar>e / d\<bar> > 0" "\<bar>d / e\<bar> >0" using assms using divide_pos_pos by auto |
|
5439 show ?cth unfolding homeomorphic_minimal |
|
5440 apply(rule_tac x="\<lambda>x. b + (e/d) *\<^sub>R (x - a)" in exI) |
|
5441 apply(rule_tac x="\<lambda>x. a + (d/e) *\<^sub>R (x - b)" in exI) |
|
5442 using assms apply (auto simp add: dist_commute) |
|
5443 unfolding dist_norm |
|
5444 apply (auto simp add: pos_divide_le_eq) |
|
5445 unfolding continuous_on |
|
5446 by (intro ballI tendsto_intros, simp, assumption)+ |
|
5447 qed |
|
5448 |
|
5449 text{* "Isometry" (up to constant bounds) of injective linear map etc. *} |
|
5450 |
|
5451 lemma cauchy_isometric: |
|
5452 fixes x :: "nat \<Rightarrow> real ^ 'n::finite" |
|
5453 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)" |
|
5454 shows "Cauchy x" |
|
5455 proof- |
|
5456 interpret f: bounded_linear f by fact |
|
5457 { fix d::real assume "d>0" |
|
5458 then obtain N where N:"\<forall>n\<ge>N. norm (f (x n) - f (x N)) < e * d" |
|
5459 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 |
|
5460 { fix n assume "n\<ge>N" |
|
5461 hence "norm (f (x n - x N)) < e * d" using N[THEN spec[where x=n]] unfolding f.diff[THEN sym] by auto |
|
5462 moreover have "e * norm (x n - x N) \<le> norm (f (x n - x N))" |
|
5463 using subspace_sub[OF s, of "x n" "x N"] using xs[THEN spec[where x=N]] and xs[THEN spec[where x=n]] |
|
5464 using normf[THEN bspec[where x="x n - x N"]] by auto |
|
5465 ultimately have "norm (x n - x N) < d" using `e>0` |
|
5466 using mult_left_less_imp_less[of e "norm (x n - x N)" d] by auto } |
|
5467 hence "\<exists>N. \<forall>n\<ge>N. norm (x n - x N) < d" by auto } |
|
5468 thus ?thesis unfolding cauchy and dist_norm by auto |
|
5469 qed |
|
5470 |
|
5471 lemma complete_isometric_image: |
|
5472 fixes f :: "real ^ _ \<Rightarrow> real ^ _" |
|
5473 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" |
|
5474 shows "complete(f ` s)" |
|
5475 proof- |
|
5476 { fix g assume as:"\<forall>n::nat. g n \<in> f ` s" and cfg:"Cauchy g" |
|
5477 then obtain x where "\<forall>n. x n \<in> s \<and> g n = f (x n)" unfolding image_iff and Bex_def |
|
5478 using choice[of "\<lambda> n xa. xa \<in> s \<and> g n = f xa"] by auto |
|
5479 hence x:"\<forall>n. x n \<in> s" "\<forall>n. g n = f (x n)" by auto |
|
5480 hence "f \<circ> x = g" unfolding expand_fun_eq by auto |
|
5481 then obtain l where "l\<in>s" and l:"(x ---> l) sequentially" |
|
5482 using cs[unfolded complete_def, THEN spec[where x="x"]] |
|
5483 using cauchy_isometric[OF `0<e` s f normf] and cfg and x(1) by auto |
|
5484 hence "\<exists>l\<in>f ` s. (g ---> l) sequentially" |
|
5485 using linear_continuous_at[OF f, unfolded continuous_at_sequentially, THEN spec[where x=x], of l] |
|
5486 unfolding `f \<circ> x = g` by auto } |
|
5487 thus ?thesis unfolding complete_def by auto |
|
5488 qed |
|
5489 |
|
5490 lemma dist_0_norm: |
|
5491 fixes x :: "'a::real_normed_vector" |
|
5492 shows "dist 0 x = norm x" |
|
5493 unfolding dist_norm by simp |
|
5494 |
|
5495 lemma injective_imp_isometric: fixes f::"real^'m::finite \<Rightarrow> real^'n::finite" |
|
5496 assumes s:"closed s" "subspace s" and f:"bounded_linear f" "\<forall>x\<in>s. (f x = 0) \<longrightarrow> (x = 0)" |
|
5497 shows "\<exists>e>0. \<forall>x\<in>s. norm (f x) \<ge> e * norm(x)" |
|
5498 proof(cases "s \<subseteq> {0::real^'m}") |
|
5499 case True |
|
5500 { fix x assume "x \<in> s" |
|
5501 hence "x = 0" using True by auto |
|
5502 hence "norm x \<le> norm (f x)" by auto } |
|
5503 thus ?thesis by(auto intro!: exI[where x=1]) |
|
5504 next |
|
5505 interpret f: bounded_linear f by fact |
|
5506 case False |
|
5507 then obtain a where a:"a\<noteq>0" "a\<in>s" by auto |
|
5508 from False have "s \<noteq> {}" by auto |
|
5509 let ?S = "{f x| x. (x \<in> s \<and> norm x = norm a)}" |
|
5510 let ?S' = "{x::real^'m. x\<in>s \<and> norm x = norm a}" |
|
5511 let ?S'' = "{x::real^'m. norm x = norm a}" |
|
5512 |
|
5513 have "?S'' = frontier(cball 0 (norm a))" unfolding frontier_cball and dist_norm by (auto simp add: norm_minus_cancel) |
|
5514 hence "compact ?S''" using compact_frontier[OF compact_cball, of 0 "norm a"] by auto |
|
5515 moreover have "?S' = s \<inter> ?S''" by auto |
|
5516 ultimately have "compact ?S'" using closed_inter_compact[of s ?S''] using s(1) by auto |
|
5517 moreover have *:"f ` ?S' = ?S" by auto |
|
5518 ultimately have "compact ?S" using compact_continuous_image[OF linear_continuous_on[OF f(1)], of ?S'] by auto |
|
5519 hence "closed ?S" using compact_imp_closed by auto |
|
5520 moreover have "?S \<noteq> {}" using a by auto |
|
5521 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 |
|
5522 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 |
|
5523 |
|
5524 let ?e = "norm (f b) / norm b" |
|
5525 have "norm b > 0" using ba and a and norm_ge_zero by auto |
|
5526 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 |
|
5527 ultimately have "0 < norm (f b) / norm b" by(simp only: divide_pos_pos) |
|
5528 moreover |
|
5529 { fix x assume "x\<in>s" |
|
5530 hence "norm (f b) / norm b * norm x \<le> norm (f x)" |
|
5531 proof(cases "x=0") |
|
5532 case True thus "norm (f b) / norm b * norm x \<le> norm (f x)" by auto |
|
5533 next |
|
5534 case False |
|
5535 hence *:"0 < norm a / norm x" using `a\<noteq>0` unfolding zero_less_norm_iff[THEN sym] by(simp only: divide_pos_pos) |
|
5536 have "\<forall>c. \<forall>x\<in>s. c *\<^sub>R x \<in> s" using s[unfolded subspace_def smult_conv_scaleR] by auto |
|
5537 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 |
|
5538 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"]] |
|
5539 unfolding f.scaleR and ba using `x\<noteq>0` `a\<noteq>0` |
|
5540 by (auto simp add: real_mult_commute pos_le_divide_eq pos_divide_le_eq) |
|
5541 qed } |
|
5542 ultimately |
|
5543 show ?thesis by auto |
|
5544 qed |
|
5545 |
|
5546 lemma closed_injective_image_subspace: |
|
5547 fixes f :: "real ^ _ \<Rightarrow> real ^ _" |
|
5548 assumes "subspace s" "bounded_linear f" "\<forall>x\<in>s. f x = 0 --> x = 0" "closed s" |
|
5549 shows "closed(f ` s)" |
|
5550 proof- |
|
5551 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 |
|
5552 show ?thesis using complete_isometric_image[OF `e>0` assms(1,2) e] and assms(4) |
|
5553 unfolding complete_eq_closed[THEN sym] by auto |
|
5554 qed |
|
5555 |
|
5556 subsection{* Some properties of a canonical subspace. *} |
|
5557 |
|
5558 lemma subspace_substandard: |
|
5559 "subspace {x::real^'n. (\<forall>i. P i \<longrightarrow> x$i = 0)}" |
|
5560 unfolding subspace_def by(auto simp add: vector_add_component vector_smult_component elim!: ballE) |
|
5561 |
|
5562 lemma closed_substandard: |
|
5563 "closed {x::real^'n::finite. \<forall>i. P i --> x$i = 0}" (is "closed ?A") |
|
5564 proof- |
|
5565 let ?D = "{i. P i}" |
|
5566 let ?Bs = "{{x::real^'n. inner (basis i) x = 0}| i. i \<in> ?D}" |
|
5567 { fix x |
|
5568 { assume "x\<in>?A" |
|
5569 hence x:"\<forall>i\<in>?D. x $ i = 0" by auto |
|
5570 hence "x\<in> \<Inter> ?Bs" by(auto simp add: inner_basis x) } |
|
5571 moreover |
|
5572 { assume x:"x\<in>\<Inter>?Bs" |
|
5573 { fix i assume i:"i \<in> ?D" |
|
5574 then obtain B where BB:"B \<in> ?Bs" and B:"B = {x::real^'n. inner (basis i) x = 0}" by auto |
|
5575 hence "x $ i = 0" unfolding B using x unfolding inner_basis by auto } |
|
5576 hence "x\<in>?A" by auto } |
|
5577 ultimately have "x\<in>?A \<longleftrightarrow> x\<in> \<Inter>?Bs" by auto } |
|
5578 hence "?A = \<Inter> ?Bs" by auto |
|
5579 thus ?thesis by(auto simp add: closed_Inter closed_hyperplane) |
|
5580 qed |
|
5581 |
|
5582 lemma dim_substandard: |
|
5583 shows "dim {x::real^'n::finite. \<forall>i. i \<notin> d \<longrightarrow> x$i = 0} = card d" (is "dim ?A = _") |
|
5584 proof- |
|
5585 let ?D = "UNIV::'n set" |
|
5586 let ?B = "(basis::'n\<Rightarrow>real^'n) ` d" |
|
5587 |
|
5588 let ?bas = "basis::'n \<Rightarrow> real^'n" |
|
5589 |
|
5590 have "?B \<subseteq> ?A" by auto |
|
5591 |
|
5592 moreover |
|
5593 { fix x::"real^'n" assume "x\<in>?A" |
|
5594 with finite[of d] |
|
5595 have "x\<in> span ?B" |
|
5596 proof(induct d arbitrary: x) |
|
5597 case empty hence "x=0" unfolding Cart_eq by auto |
|
5598 thus ?case using subspace_0[OF subspace_span[of "{}"]] by auto |
|
5599 next |
|
5600 case (insert k F) |
|
5601 hence *:"\<forall>i. i \<notin> insert k F \<longrightarrow> x $ i = 0" by auto |
|
5602 have **:"F \<subseteq> insert k F" by auto |
|
5603 def y \<equiv> "x - x$k *\<^sub>R basis k" |
|
5604 have y:"x = y + (x$k) *\<^sub>R basis k" unfolding y_def by auto |
|
5605 { fix i assume i':"i \<notin> F" |
|
5606 hence "y $ i = 0" unfolding y_def unfolding vector_minus_component |
|
5607 and vector_smult_component and basis_component |
|
5608 using *[THEN spec[where x=i]] by auto } |
|
5609 hence "y \<in> span (basis ` (insert k F))" using insert(3) |
|
5610 using span_mono[of "?bas ` F" "?bas ` (insert k F)"] |
|
5611 using image_mono[OF **, of basis] by auto |
|
5612 moreover |
|
5613 have "basis k \<in> span (?bas ` (insert k F))" by(rule span_superset, auto) |
|
5614 hence "x$k *\<^sub>R basis k \<in> span (?bas ` (insert k F))" |
|
5615 using span_mul [where 'a=real, unfolded smult_conv_scaleR] by auto |
|
5616 ultimately |
|
5617 have "y + x$k *\<^sub>R basis k \<in> span (?bas ` (insert k F))" |
|
5618 using span_add by auto |
|
5619 thus ?case using y by auto |
|
5620 qed |
|
5621 } |
|
5622 hence "?A \<subseteq> span ?B" by auto |
|
5623 |
|
5624 moreover |
|
5625 { fix x assume "x \<in> ?B" |
|
5626 hence "x\<in>{(basis i)::real^'n |i. i \<in> ?D}" using assms by auto } |
|
5627 hence "independent ?B" using independent_mono[OF independent_stdbasis, of ?B] and assms by auto |
|
5628 |
|
5629 moreover |
|
5630 have "d \<subseteq> ?D" unfolding subset_eq using assms by auto |
|
5631 hence *:"inj_on (basis::'n\<Rightarrow>real^'n) d" using subset_inj_on[OF basis_inj, of "d"] by auto |
|
5632 have "?B hassize (card d)" unfolding hassize_def and card_image[OF *] by auto |
|
5633 |
|
5634 ultimately show ?thesis using dim_unique[of "basis ` d" ?A] by auto |
|
5635 qed |
|
5636 |
|
5637 text{* Hence closure and completeness of all subspaces. *} |
|
5638 |
|
5639 lemma closed_subspace_lemma: "n \<le> card (UNIV::'n::finite set) \<Longrightarrow> \<exists>A::'n set. card A = n" |
|
5640 apply (induct n) |
|
5641 apply (rule_tac x="{}" in exI, simp) |
|
5642 apply clarsimp |
|
5643 apply (subgoal_tac "\<exists>x. x \<notin> A") |
|
5644 apply (erule exE) |
|
5645 apply (rule_tac x="insert x A" in exI, simp) |
|
5646 apply (subgoal_tac "A \<noteq> UNIV", auto) |
|
5647 done |
|
5648 |
|
5649 lemma closed_subspace: fixes s::"(real^'n::finite) set" |
|
5650 assumes "subspace s" shows "closed s" |
|
5651 proof- |
|
5652 have "dim s \<le> card (UNIV :: 'n set)" using dim_subset_univ by auto |
|
5653 then obtain d::"'n set" where t: "card d = dim s" |
|
5654 using closed_subspace_lemma by auto |
|
5655 let ?t = "{x::real^'n. \<forall>i. i \<notin> d \<longrightarrow> x$i = 0}" |
|
5656 obtain f where f:"bounded_linear f" "f ` ?t = s" "inj_on f ?t" |
|
5657 using subspace_isomorphism[unfolded linear_conv_bounded_linear, OF subspace_substandard[of "\<lambda>i. i \<notin> d"] assms] |
|
5658 using dim_substandard[of d] and t by auto |
|
5659 interpret f: bounded_linear f by fact |
|
5660 have "\<forall>x\<in>?t. f x = 0 \<longrightarrow> x = 0" using f.zero using f(3)[unfolded inj_on_def] |
|
5661 by(erule_tac x=0 in ballE) auto |
|
5662 moreover have "closed ?t" using closed_substandard . |
|
5663 moreover have "subspace ?t" using subspace_substandard . |
|
5664 ultimately show ?thesis using closed_injective_image_subspace[of ?t f] |
|
5665 unfolding f(2) using f(1) by auto |
|
5666 qed |
|
5667 |
|
5668 lemma complete_subspace: |
|
5669 fixes s :: "(real ^ _) set" shows "subspace s ==> complete s" |
|
5670 using complete_eq_closed closed_subspace |
|
5671 by auto |
|
5672 |
|
5673 lemma dim_closure: |
|
5674 fixes s :: "(real ^ _) set" |
|
5675 shows "dim(closure s) = dim s" (is "?dc = ?d") |
|
5676 proof- |
|
5677 have "?dc \<le> ?d" using closure_minimal[OF span_inc, of s] |
|
5678 using closed_subspace[OF subspace_span, of s] |
|
5679 using dim_subset[of "closure s" "span s"] unfolding dim_span by auto |
|
5680 thus ?thesis using dim_subset[OF closure_subset, of s] by auto |
|
5681 qed |
|
5682 |
|
5683 text{* Affine transformations of intervals. *} |
|
5684 |
|
5685 lemma affinity_inverses: |
|
5686 assumes m0: "m \<noteq> (0::'a::field)" |
|
5687 shows "(\<lambda>x. m *s x + c) o (\<lambda>x. inverse(m) *s x + (-(inverse(m) *s c))) = id" |
|
5688 "(\<lambda>x. inverse(m) *s x + (-(inverse(m) *s c))) o (\<lambda>x. m *s x + c) = id" |
|
5689 using m0 |
|
5690 apply (auto simp add: expand_fun_eq vector_add_ldistrib vector_smult_assoc) |
|
5691 by (simp add: vector_smult_lneg[symmetric] vector_smult_assoc vector_sneg_minus1[symmetric]) |
|
5692 |
|
5693 lemma real_affinity_le: |
|
5694 "0 < (m::'a::ordered_field) ==> (m * x + c \<le> y \<longleftrightarrow> x \<le> inverse(m) * y + -(c / m))" |
|
5695 by (simp add: field_simps inverse_eq_divide) |
|
5696 |
|
5697 lemma real_le_affinity: |
|
5698 "0 < (m::'a::ordered_field) ==> (y \<le> m * x + c \<longleftrightarrow> inverse(m) * y + -(c / m) \<le> x)" |
|
5699 by (simp add: field_simps inverse_eq_divide) |
|
5700 |
|
5701 lemma real_affinity_lt: |
|
5702 "0 < (m::'a::ordered_field) ==> (m * x + c < y \<longleftrightarrow> x < inverse(m) * y + -(c / m))" |
|
5703 by (simp add: field_simps inverse_eq_divide) |
|
5704 |
|
5705 lemma real_lt_affinity: |
|
5706 "0 < (m::'a::ordered_field) ==> (y < m * x + c \<longleftrightarrow> inverse(m) * y + -(c / m) < x)" |
|
5707 by (simp add: field_simps inverse_eq_divide) |
|
5708 |
|
5709 lemma real_affinity_eq: |
|
5710 "(m::'a::ordered_field) \<noteq> 0 ==> (m * x + c = y \<longleftrightarrow> x = inverse(m) * y + -(c / m))" |
|
5711 by (simp add: field_simps inverse_eq_divide) |
|
5712 |
|
5713 lemma real_eq_affinity: |
|
5714 "(m::'a::ordered_field) \<noteq> 0 ==> (y = m * x + c \<longleftrightarrow> inverse(m) * y + -(c / m) = x)" |
|
5715 by (simp add: field_simps inverse_eq_divide) |
|
5716 |
|
5717 lemma vector_affinity_eq: |
|
5718 assumes m0: "(m::'a::field) \<noteq> 0" |
|
5719 shows "m *s x + c = y \<longleftrightarrow> x = inverse m *s y + -(inverse m *s c)" |
|
5720 proof |
|
5721 assume h: "m *s x + c = y" |
|
5722 hence "m *s x = y - c" by (simp add: ring_simps) |
|
5723 hence "inverse m *s (m *s x) = inverse m *s (y - c)" by simp |
|
5724 then show "x = inverse m *s y + - (inverse m *s c)" |
|
5725 using m0 by (simp add: vector_smult_assoc vector_ssub_ldistrib) |
|
5726 next |
|
5727 assume h: "x = inverse m *s y + - (inverse m *s c)" |
|
5728 show "m *s x + c = y" unfolding h diff_minus[symmetric] |
|
5729 using m0 by (simp add: vector_smult_assoc vector_ssub_ldistrib) |
|
5730 qed |
|
5731 |
|
5732 lemma vector_eq_affinity: |
|
5733 "(m::'a::field) \<noteq> 0 ==> (y = m *s x + c \<longleftrightarrow> inverse(m) *s y + -(inverse(m) *s c) = x)" |
|
5734 using vector_affinity_eq[where m=m and x=x and y=y and c=c] |
|
5735 by metis |
|
5736 |
|
5737 lemma image_affinity_interval: fixes m::real |
|
5738 fixes a b c :: "real^'n::finite" |
|
5739 shows "(\<lambda>x. m *\<^sub>R x + c) ` {a .. b} = |
|
5740 (if {a .. b} = {} then {} |
|
5741 else (if 0 \<le> m then {m *\<^sub>R a + c .. m *\<^sub>R b + c} |
|
5742 else {m *\<^sub>R b + c .. m *\<^sub>R a + c}))" |
|
5743 proof(cases "m=0") |
|
5744 { fix x assume "x \<le> c" "c \<le> x" |
|
5745 hence "x=c" unfolding vector_less_eq_def and Cart_eq by (auto intro: order_antisym) } |
|
5746 moreover case True |
|
5747 moreover have "c \<in> {m *\<^sub>R a + c..m *\<^sub>R b + c}" unfolding True by(auto simp add: vector_less_eq_def) |
|
5748 ultimately show ?thesis by auto |
|
5749 next |
|
5750 case False |
|
5751 { fix y assume "a \<le> y" "y \<le> b" "m > 0" |
|
5752 hence "m *\<^sub>R a + c \<le> m *\<^sub>R y + c" "m *\<^sub>R y + c \<le> m *\<^sub>R b + c" |
|
5753 unfolding vector_less_eq_def by(auto simp add: vector_smult_component vector_add_component) |
|
5754 } moreover |
|
5755 { fix y assume "a \<le> y" "y \<le> b" "m < 0" |
|
5756 hence "m *\<^sub>R b + c \<le> m *\<^sub>R y + c" "m *\<^sub>R y + c \<le> m *\<^sub>R a + c" |
|
5757 unfolding vector_less_eq_def by(auto simp add: vector_smult_component vector_add_component mult_left_mono_neg elim!:ballE) |
|
5758 } moreover |
|
5759 { fix y assume "m > 0" "m *\<^sub>R a + c \<le> y" "y \<le> m *\<^sub>R b + c" |
|
5760 hence "y \<in> (\<lambda>x. m *\<^sub>R x + c) ` {a..b}" |
|
5761 unfolding image_iff Bex_def mem_interval vector_less_eq_def |
|
5762 apply(auto simp add: vector_smult_component vector_add_component vector_minus_component vector_smult_assoc pth_3[symmetric] |
|
5763 intro!: exI[where x="(1 / m) *\<^sub>R (y - c)"]) |
|
5764 by(auto simp add: pos_le_divide_eq pos_divide_le_eq real_mult_commute diff_le_iff) |
|
5765 } moreover |
|
5766 { fix y assume "m *\<^sub>R b + c \<le> y" "y \<le> m *\<^sub>R a + c" "m < 0" |
|
5767 hence "y \<in> (\<lambda>x. m *\<^sub>R x + c) ` {a..b}" |
|
5768 unfolding image_iff Bex_def mem_interval vector_less_eq_def |
|
5769 apply(auto simp add: vector_smult_component vector_add_component vector_minus_component vector_smult_assoc pth_3[symmetric] |
|
5770 intro!: exI[where x="(1 / m) *\<^sub>R (y - c)"]) |
|
5771 by(auto simp add: neg_le_divide_eq neg_divide_le_eq real_mult_commute diff_le_iff) |
|
5772 } |
|
5773 ultimately show ?thesis using False by auto |
|
5774 qed |
|
5775 |
|
5776 lemma image_smult_interval:"(\<lambda>x. m *\<^sub>R (x::real^'n::finite)) ` {a..b} = |
|
5777 (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})" |
|
5778 using image_affinity_interval[of m 0 a b] by auto |
|
5779 |
|
5780 subsection{* Banach fixed point theorem (not really topological...) *} |
|
5781 |
|
5782 lemma banach_fix: |
|
5783 assumes s:"complete s" "s \<noteq> {}" and c:"0 \<le> c" "c < 1" and f:"(f ` s) \<subseteq> s" and |
|
5784 lipschitz:"\<forall>x\<in>s. \<forall>y\<in>s. dist (f x) (f y) \<le> c * dist x y" |
|
5785 shows "\<exists>! x\<in>s. (f x = x)" |
|
5786 proof- |
|
5787 have "1 - c > 0" using c by auto |
|
5788 |
|
5789 from s(2) obtain z0 where "z0 \<in> s" by auto |
|
5790 def z \<equiv> "\<lambda>n. (f ^^ n) z0" |
|
5791 { fix n::nat |
|
5792 have "z n \<in> s" unfolding z_def |
|
5793 proof(induct n) case 0 thus ?case using `z0 \<in>s` by auto |
|
5794 next case Suc thus ?case using f by auto qed } |
|
5795 note z_in_s = this |
|
5796 |
|
5797 def d \<equiv> "dist (z 0) (z 1)" |
|
5798 |
|
5799 have fzn:"\<And>n. f (z n) = z (Suc n)" unfolding z_def by auto |
|
5800 { fix n::nat |
|
5801 have "dist (z n) (z (Suc n)) \<le> (c ^ n) * d" |
|
5802 proof(induct n) |
|
5803 case 0 thus ?case unfolding d_def by auto |
|
5804 next |
|
5805 case (Suc m) |
|
5806 hence "c * dist (z m) (z (Suc m)) \<le> c ^ Suc m * d" |
|
5807 using `0 \<le> c` using mult_mono1_class.mult_mono1[of "dist (z m) (z (Suc m))" "c ^ m * d" c] by auto |
|
5808 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] |
|
5809 unfolding fzn and mult_le_cancel_left by auto |
|
5810 qed |
|
5811 } note cf_z = this |
|
5812 |
|
5813 { fix n m::nat |
|
5814 have "(1 - c) * dist (z m) (z (m+n)) \<le> (c ^ m) * d * (1 - c ^ n)" |
|
5815 proof(induct n) |
|
5816 case 0 show ?case by auto |
|
5817 next |
|
5818 case (Suc k) |
|
5819 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))))" |
|
5820 using dist_triangle and c by(auto simp add: dist_triangle) |
|
5821 also have "\<dots> \<le> (1 - c) * (dist (z m) (z (m + k)) + c ^ (m + k) * d)" |
|
5822 using cf_z[of "m + k"] and c by auto |
|
5823 also have "\<dots> \<le> c ^ m * d * (1 - c ^ k) + (1 - c) * c ^ (m + k) * d" |
|
5824 using Suc by (auto simp add: ring_simps) |
|
5825 also have "\<dots> = (c ^ m) * (d * (1 - c ^ k) + (1 - c) * c ^ k * d)" |
|
5826 unfolding power_add by (auto simp add: ring_simps) |
|
5827 also have "\<dots> \<le> (c ^ m) * d * (1 - c ^ Suc k)" |
|
5828 using c by (auto simp add: ring_simps) |
|
5829 finally show ?case by auto |
|
5830 qed |
|
5831 } note cf_z2 = this |
|
5832 { fix e::real assume "e>0" |
|
5833 hence "\<exists>N. \<forall>m n. N \<le> m \<and> N \<le> n \<longrightarrow> dist (z m) (z n) < e" |
|
5834 proof(cases "d = 0") |
|
5835 case True |
|
5836 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`]) |
|
5837 thus ?thesis using `e>0` by auto |
|
5838 next |
|
5839 case False hence "d>0" unfolding d_def using zero_le_dist[of "z 0" "z 1"] |
|
5840 by (metis False d_def real_less_def) |
|
5841 hence "0 < e * (1 - c) / d" using `e>0` and `1-c>0` |
|
5842 using divide_pos_pos[of "e * (1 - c)" d] and mult_pos_pos[of e "1 - c"] by auto |
|
5843 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 |
|
5844 { fix m n::nat assume "m>n" and as:"m\<ge>N" "n\<ge>N" |
|
5845 have *:"c ^ n \<le> c ^ N" using `n\<ge>N` and c using power_decreasing[OF `n\<ge>N`, of c] by auto |
|
5846 have "1 - c ^ (m - n) > 0" using c and power_strict_mono[of c 1 "m - n"] using `m>n` by auto |
|
5847 hence **:"d * (1 - c ^ (m - n)) / (1 - c) > 0" |
|
5848 using real_mult_order[OF `d>0`, of "1 - c ^ (m - n)"] |
|
5849 using divide_pos_pos[of "d * (1 - c ^ (m - n))" "1 - c"] |
|
5850 using `0 < 1 - c` by auto |
|
5851 |
|
5852 have "dist (z m) (z n) \<le> c ^ n * d * (1 - c ^ (m - n)) / (1 - c)" |
|
5853 using cf_z2[of n "m - n"] and `m>n` unfolding pos_le_divide_eq[OF `1-c>0`] |
|
5854 by (auto simp add: real_mult_commute dist_commute) |
|
5855 also have "\<dots> \<le> c ^ N * d * (1 - c ^ (m - n)) / (1 - c)" |
|
5856 using mult_right_mono[OF * order_less_imp_le[OF **]] |
|
5857 unfolding real_mult_assoc by auto |
|
5858 also have "\<dots> < (e * (1 - c) / d) * d * (1 - c ^ (m - n)) / (1 - c)" |
|
5859 using mult_strict_right_mono[OF N **] unfolding real_mult_assoc by auto |
|
5860 also have "\<dots> = e * (1 - c ^ (m - n))" using c and `d>0` and `1 - c > 0` by auto |
|
5861 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 |
|
5862 finally have "dist (z m) (z n) < e" by auto |
|
5863 } note * = this |
|
5864 { fix m n::nat assume as:"N\<le>m" "N\<le>n" |
|
5865 hence "dist (z n) (z m) < e" |
|
5866 proof(cases "n = m") |
|
5867 case True thus ?thesis using `e>0` by auto |
|
5868 next |
|
5869 case False thus ?thesis using as and *[of n m] *[of m n] unfolding nat_neq_iff by (auto simp add: dist_commute) |
|
5870 qed } |
|
5871 thus ?thesis by auto |
|
5872 qed |
|
5873 } |
|
5874 hence "Cauchy z" unfolding cauchy_def by auto |
|
5875 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 |
|
5876 |
|
5877 def e \<equiv> "dist (f x) x" |
|
5878 have "e = 0" proof(rule ccontr) |
|
5879 assume "e \<noteq> 0" hence "e>0" unfolding e_def using zero_le_dist[of "f x" x] |
|
5880 by (metis dist_eq_0_iff dist_nz e_def) |
|
5881 then obtain N where N:"\<forall>n\<ge>N. dist (z n) x < e / 2" |
|
5882 using x[unfolded Lim_sequentially, THEN spec[where x="e/2"]] by auto |
|
5883 hence N':"dist (z N) x < e / 2" by auto |
|
5884 |
|
5885 have *:"c * dist (z N) x \<le> dist (z N) x" unfolding mult_le_cancel_right2 |
|
5886 using zero_le_dist[of "z N" x] and c |
|
5887 by (metis dist_eq_0_iff dist_nz order_less_asym real_less_def) |
|
5888 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]] |
|
5889 using z_in_s[of N] `x\<in>s` using c by auto |
|
5890 also have "\<dots> < e / 2" using N' and c using * by auto |
|
5891 finally show False unfolding fzn |
|
5892 using N[THEN spec[where x="Suc N"]] and dist_triangle_half_r[of "z (Suc N)" "f x" e x] |
|
5893 unfolding e_def by auto |
|
5894 qed |
|
5895 hence "f x = x" unfolding e_def by auto |
|
5896 moreover |
|
5897 { fix y assume "f y = y" "y\<in>s" |
|
5898 hence "dist x y \<le> c * dist x y" using lipschitz[THEN bspec[where x=x], THEN bspec[where x=y]] |
|
5899 using `x\<in>s` and `f x = x` by auto |
|
5900 hence "dist x y = 0" unfolding mult_le_cancel_right1 |
|
5901 using c and zero_le_dist[of x y] by auto |
|
5902 hence "y = x" by auto |
|
5903 } |
|
5904 ultimately show ?thesis unfolding Bex1_def using `x\<in>s` by blast+ |
|
5905 qed |
|
5906 |
|
5907 subsection{* Edelstein fixed point theorem. *} |
|
5908 |
|
5909 lemma edelstein_fix: |
|
5910 fixes s :: "'a::real_normed_vector set" |
|
5911 assumes s:"compact s" "s \<noteq> {}" and gs:"(g ` s) \<subseteq> s" |
|
5912 and dist:"\<forall>x\<in>s. \<forall>y\<in>s. x \<noteq> y \<longrightarrow> dist (g x) (g y) < dist x y" |
|
5913 shows "\<exists>! x\<in>s. g x = x" |
|
5914 proof(cases "\<exists>x\<in>s. g x \<noteq> x") |
|
5915 obtain x where "x\<in>s" using s(2) by auto |
|
5916 case False hence g:"\<forall>x\<in>s. g x = x" by auto |
|
5917 { fix y assume "y\<in>s" |
|
5918 hence "x = y" using `x\<in>s` and dist[THEN bspec[where x=x], THEN bspec[where x=y]] |
|
5919 unfolding g[THEN bspec[where x=x], OF `x\<in>s`] |
|
5920 unfolding g[THEN bspec[where x=y], OF `y\<in>s`] by auto } |
|
5921 thus ?thesis unfolding Bex1_def using `x\<in>s` and g by blast+ |
|
5922 next |
|
5923 case True |
|
5924 then obtain x where [simp]:"x\<in>s" and "g x \<noteq> x" by auto |
|
5925 { fix x y assume "x \<in> s" "y \<in> s" |
|
5926 hence "dist (g x) (g y) \<le> dist x y" |
|
5927 using dist[THEN bspec[where x=x], THEN bspec[where x=y]] by auto } note dist' = this |
|
5928 def y \<equiv> "g x" |
|
5929 have [simp]:"y\<in>s" unfolding y_def using gs[unfolded image_subset_iff] and `x\<in>s` by blast |
|
5930 def f \<equiv> "\<lambda>n. g ^^ n" |
|
5931 have [simp]:"\<And>n z. g (f n z) = f (Suc n) z" unfolding f_def by auto |
|
5932 have [simp]:"\<And>z. f 0 z = z" unfolding f_def by auto |
|
5933 { fix n::nat and z assume "z\<in>s" |
|
5934 have "f n z \<in> s" unfolding f_def |
|
5935 proof(induct n) |
|
5936 case 0 thus ?case using `z\<in>s` by simp |
|
5937 next |
|
5938 case (Suc n) thus ?case using gs[unfolded image_subset_iff] by auto |
|
5939 qed } note fs = this |
|
5940 { fix m n ::nat assume "m\<le>n" |
|
5941 fix w z assume "w\<in>s" "z\<in>s" |
|
5942 have "dist (f n w) (f n z) \<le> dist (f m w) (f m z)" using `m\<le>n` |
|
5943 proof(induct n) |
|
5944 case 0 thus ?case by auto |
|
5945 next |
|
5946 case (Suc n) |
|
5947 thus ?case proof(cases "m\<le>n") |
|
5948 case True thus ?thesis using Suc(1) |
|
5949 using dist'[OF fs fs, OF `w\<in>s` `z\<in>s`, of n n] by auto |
|
5950 next |
|
5951 case False hence mn:"m = Suc n" using Suc(2) by simp |
|
5952 show ?thesis unfolding mn by auto |
|
5953 qed |
|
5954 qed } note distf = this |
|
5955 |
|
5956 def h \<equiv> "\<lambda>n. (f n x, f n y)" |
|
5957 let ?s2 = "s \<times> s" |
|
5958 obtain l r where "l\<in>?s2" and r:"subseq r" and lr:"((h \<circ> r) ---> l) sequentially" |
|
5959 using compact_Times [OF s(1) s(1), unfolded compact_def, THEN spec[where x=h]] unfolding h_def |
|
5960 using fs[OF `x\<in>s`] and fs[OF `y\<in>s`] by blast |
|
5961 def a \<equiv> "fst l" def b \<equiv> "snd l" |
|
5962 have lab:"l = (a, b)" unfolding a_def b_def by simp |
|
5963 have [simp]:"a\<in>s" "b\<in>s" unfolding a_def b_def using `l\<in>?s2` by auto |
|
5964 |
|
5965 have lima:"((fst \<circ> (h \<circ> r)) ---> a) sequentially" |
|
5966 and limb:"((snd \<circ> (h \<circ> r)) ---> b) sequentially" |
|
5967 using lr |
|
5968 unfolding o_def a_def b_def by (simp_all add: tendsto_intros) |
|
5969 |
|
5970 { fix n::nat |
|
5971 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 |
|
5972 { fix x y :: 'a |
|
5973 have "dist (-x) (-y) = dist x y" unfolding dist_norm |
|
5974 using norm_minus_cancel[of "x - y"] by (auto simp add: uminus_add_conv_diff) } note ** = this |
|
5975 |
|
5976 { assume as:"dist a b > dist (f n x) (f n y)" |
|
5977 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" |
|
5978 and "\<forall>m\<ge>Nb. dist (f (r m) y) b < (dist a b - dist (f n x) (f n y)) / 2" |
|
5979 using lima limb unfolding h_def Lim_sequentially by (fastsimp simp del: less_divide_eq_number_of1) |
|
5980 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)" |
|
5981 apply(erule_tac x="Na+Nb+n" in allE) |
|
5982 apply(erule_tac x="Na+Nb+n" in allE) apply simp |
|
5983 using dist_triangle_add_half[of a "f (r (Na + Nb + n)) x" "dist a b - dist (f n x) (f n y)" |
|
5984 "-b" "- f (r (Na + Nb + n)) y"] |
|
5985 unfolding ** unfolding group_simps(12) by (auto simp add: dist_commute) |
|
5986 moreover |
|
5987 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)" |
|
5988 using distf[of n "r (Na+Nb+n)", OF _ `x\<in>s` `y\<in>s`] |
|
5989 using subseq_bigger[OF r, of "Na+Nb+n"] |
|
5990 using *[of "f (r (Na + Nb + n)) x" "f (r (Na + Nb + n)) y" "f n x" "f n y"] by auto |
|
5991 ultimately have False by simp |
|
5992 } |
|
5993 hence "dist a b \<le> dist (f n x) (f n y)" by(rule ccontr)auto } |
|
5994 note ab_fn = this |
|
5995 |
|
5996 have [simp]:"a = b" proof(rule ccontr) |
|
5997 def e \<equiv> "dist a b - dist (g a) (g b)" |
|
5998 assume "a\<noteq>b" hence "e > 0" unfolding e_def using dist by fastsimp |
|
5999 hence "\<exists>n. dist (f n x) a < e/2 \<and> dist (f n y) b < e/2" |
|
6000 using lima limb unfolding Lim_sequentially |
|
6001 apply (auto elim!: allE[where x="e/2"]) apply(rule_tac x="r (max N Na)" in exI) unfolding h_def by fastsimp |
|
6002 then obtain n where n:"dist (f n x) a < e/2 \<and> dist (f n y) b < e/2" by auto |
|
6003 have "dist (f (Suc n) x) (g a) \<le> dist (f n x) a" |
|
6004 using dist[THEN bspec[where x="f n x"], THEN bspec[where x="a"]] and fs by auto |
|
6005 moreover have "dist (f (Suc n) y) (g b) \<le> dist (f n y) b" |
|
6006 using dist[THEN bspec[where x="f n y"], THEN bspec[where x="b"]] and fs by auto |
|
6007 ultimately have "dist (f (Suc n) x) (g a) + dist (f (Suc n) y) (g b) < e" using n by auto |
|
6008 thus False unfolding e_def using ab_fn[of "Suc n"] by norm |
|
6009 qed |
|
6010 |
|
6011 have [simp]:"\<And>n. f (Suc n) x = f n y" unfolding f_def y_def by(induct_tac n)auto |
|
6012 { fix x y assume "x\<in>s" "y\<in>s" moreover |
|
6013 fix e::real assume "e>0" ultimately |
|
6014 have "dist y x < e \<longrightarrow> dist (g y) (g x) < e" using dist by fastsimp } |
|
6015 hence "continuous_on s g" unfolding continuous_on_def by auto |
|
6016 |
|
6017 hence "((snd \<circ> h \<circ> r) ---> g a) sequentially" unfolding continuous_on_sequentially |
|
6018 apply (rule allE[where x="\<lambda>n. (fst \<circ> h \<circ> r) n"]) apply (erule ballE[where x=a]) |
|
6019 using lima unfolding h_def o_def using fs[OF `x\<in>s`] by (auto simp add: y_def) |
|
6020 hence "g a = a" using Lim_unique[OF trivial_limit_sequentially limb, of "g a"] |
|
6021 unfolding `a=b` and o_assoc by auto |
|
6022 moreover |
|
6023 { fix x assume "x\<in>s" "g x = x" "x\<noteq>a" |
|
6024 hence "False" using dist[THEN bspec[where x=a], THEN bspec[where x=x]] |
|
6025 using `g a = a` and `a\<in>s` by auto } |
|
6026 ultimately show "\<exists>!x\<in>s. g x = x" unfolding Bex1_def using `a\<in>s` by blast |
|
6027 qed |
|
6028 |
|
6029 end |
|