author | huffman |
Mon, 09 Apr 2007 04:51:28 +0200 | |
changeset 22615 | d650e51b5970 |
parent 22614 | 17644bc9cee4 |
child 22628 | 0e5ac9503d7e |
permissions | -rw-r--r-- |
10751 | 1 |
(* Title : SEQ.thy |
2 |
Author : Jacques D. Fleuriot |
|
3 |
Copyright : 1998 University of Cambridge |
|
4 |
Description : Convergence of sequences and series |
|
15082 | 5 |
Conversion to Isar and new proofs by Lawrence C Paulson, 2004 |
22608 | 6 |
Additional contributions by Jeremy Avigad and Brian Huffman |
15082 | 7 |
*) |
10751 | 8 |
|
17439 | 9 |
header {* Sequences and Series *} |
10 |
||
15131 | 11 |
theory SEQ |
15236
f289e8ba2bb3
Proofs needed to be updated because induction now preserves name of
nipkow
parents:
15229
diff
changeset
|
12 |
imports NatStar |
15131 | 13 |
begin |
10751 | 14 |
|
19765 | 15 |
definition |
22608 | 16 |
Zseq :: "[nat \<Rightarrow> 'a::real_normed_vector] \<Rightarrow> bool" where |
17 |
--{*Standard definition of sequence converging to zero*} |
|
18 |
"Zseq X = (\<forall>r>0. \<exists>no. \<forall>n\<ge>no. norm (X n) < r)" |
|
19 |
||
20 |
definition |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
21 |
LIMSEQ :: "[nat => 'a::real_normed_vector, 'a] => bool" |
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
22 |
("((_)/ ----> (_))" [60, 60] 60) where |
15082 | 23 |
--{*Standard definition of convergence of sequence*} |
20563 | 24 |
"X ----> L = (\<forall>r. 0 < r --> (\<exists>no. \<forall>n. no \<le> n --> norm (X n - L) < r))" |
10751 | 25 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
26 |
definition |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
27 |
NSLIMSEQ :: "[nat => 'a::real_normed_vector, 'a] => bool" |
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
28 |
("((_)/ ----NS> (_))" [60, 60] 60) where |
15082 | 29 |
--{*Nonstandard definition of convergence of sequence*} |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
30 |
"X ----NS> L = (\<forall>N \<in> HNatInfinite. ( *f* X) N \<approx> star_of L)" |
15082 | 31 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
32 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
33 |
lim :: "(nat => 'a::real_normed_vector) => 'a" where |
15082 | 34 |
--{*Standard definition of limit using choice operator*} |
20682 | 35 |
"lim X = (THE L. X ----> L)" |
10751 | 36 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
37 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
38 |
nslim :: "(nat => 'a::real_normed_vector) => 'a" where |
15082 | 39 |
--{*Nonstandard definition of limit using choice operator*} |
20682 | 40 |
"nslim X = (THE L. X ----NS> L)" |
10751 | 41 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
42 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
43 |
convergent :: "(nat => 'a::real_normed_vector) => bool" where |
15082 | 44 |
--{*Standard definition of convergence*} |
20682 | 45 |
"convergent X = (\<exists>L. X ----> L)" |
10751 | 46 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
47 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
48 |
NSconvergent :: "(nat => 'a::real_normed_vector) => bool" where |
15082 | 49 |
--{*Nonstandard definition of convergence*} |
20682 | 50 |
"NSconvergent X = (\<exists>L. X ----NS> L)" |
15082 | 51 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
52 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
53 |
Bseq :: "(nat => 'a::real_normed_vector) => bool" where |
15082 | 54 |
--{*Standard definition for bounded sequence*} |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
55 |
"Bseq X = (\<exists>K>0.\<forall>n. norm (X n) \<le> K)" |
10751 | 56 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
57 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
58 |
NSBseq :: "(nat => 'a::real_normed_vector) => bool" where |
15082 | 59 |
--{*Nonstandard definition for bounded sequence*} |
19765 | 60 |
"NSBseq X = (\<forall>N \<in> HNatInfinite. ( *f* X) N : HFinite)" |
15082 | 61 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
62 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
63 |
monoseq :: "(nat=>real)=>bool" where |
15082 | 64 |
--{*Definition for monotonicity*} |
19765 | 65 |
"monoseq X = ((\<forall>m. \<forall>n\<ge>m. X m \<le> X n) | (\<forall>m. \<forall>n\<ge>m. X n \<le> X m))" |
10751 | 66 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
67 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
68 |
subseq :: "(nat => nat) => bool" where |
15082 | 69 |
--{*Definition of subsequence*} |
19765 | 70 |
"subseq f = (\<forall>m. \<forall>n>m. (f m) < (f n))" |
10751 | 71 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
72 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
73 |
Cauchy :: "(nat => 'a::real_normed_vector) => bool" where |
15082 | 74 |
--{*Standard definition of the Cauchy condition*} |
20563 | 75 |
"Cauchy X = (\<forall>e>0. \<exists>M. \<forall>m \<ge> M. \<forall>n \<ge> M. norm (X m - X n) < e)" |
10751 | 76 |
|
21404
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
77 |
definition |
eb85850d3eb7
more robust syntax for definition/abbreviation/notation;
wenzelm
parents:
21139
diff
changeset
|
78 |
NSCauchy :: "(nat => 'a::real_normed_vector) => bool" where |
15082 | 79 |
--{*Nonstandard definition*} |
19765 | 80 |
"NSCauchy X = (\<forall>M \<in> HNatInfinite. \<forall>N \<in> HNatInfinite. ( *f* X) M \<approx> ( *f* X) N)" |
15082 | 81 |
|
82 |
||
22608 | 83 |
subsection {* Bounded Sequences *} |
84 |
||
85 |
lemma BseqI: assumes K: "\<And>n. norm (X n) \<le> K" shows "Bseq X" |
|
86 |
unfolding Bseq_def |
|
87 |
proof (intro exI conjI allI) |
|
88 |
show "0 < max K 1" by simp |
|
89 |
next |
|
90 |
fix n::nat |
|
91 |
have "norm (X n) \<le> K" by (rule K) |
|
92 |
thus "norm (X n) \<le> max K 1" by simp |
|
93 |
qed |
|
94 |
||
95 |
lemma BseqD: "Bseq X \<Longrightarrow> \<exists>K>0. \<forall>n. norm (X n) \<le> K" |
|
96 |
unfolding Bseq_def by simp |
|
97 |
||
98 |
lemma BseqE: "\<lbrakk>Bseq X; \<And>K. \<lbrakk>0 < K; \<forall>n. norm (X n) \<le> K\<rbrakk> \<Longrightarrow> Q\<rbrakk> \<Longrightarrow> Q" |
|
99 |
unfolding Bseq_def by auto |
|
100 |
||
101 |
lemma BseqI2: assumes K: "\<forall>n\<ge>N. norm (X n) \<le> K" shows "Bseq X" |
|
102 |
proof (rule BseqI) |
|
103 |
let ?A = "norm ` X ` {..N}" |
|
104 |
have 1: "finite ?A" by simp |
|
105 |
have 2: "?A \<noteq> {}" by auto |
|
106 |
fix n::nat |
|
107 |
show "norm (X n) \<le> max K (Max ?A)" |
|
108 |
proof (cases rule: linorder_le_cases) |
|
109 |
assume "n \<ge> N" |
|
110 |
hence "norm (X n) \<le> K" using K by simp |
|
111 |
thus "norm (X n) \<le> max K (Max ?A)" by simp |
|
112 |
next |
|
113 |
assume "n \<le> N" |
|
114 |
hence "norm (X n) \<in> ?A" by simp |
|
115 |
with 1 2 have "norm (X n) \<le> Max ?A" by (rule Max_ge) |
|
116 |
thus "norm (X n) \<le> max K (Max ?A)" by simp |
|
117 |
qed |
|
118 |
qed |
|
119 |
||
120 |
lemma Bseq_ignore_initial_segment: "Bseq X \<Longrightarrow> Bseq (\<lambda>n. X (n + k))" |
|
121 |
unfolding Bseq_def by auto |
|
122 |
||
123 |
lemma Bseq_offset: "Bseq (\<lambda>n. X (n + k)) \<Longrightarrow> Bseq X" |
|
124 |
apply (erule BseqE) |
|
125 |
apply (rule_tac N="k" and K="K" in BseqI2) |
|
126 |
apply clarify |
|
127 |
apply (drule_tac x="n - k" in spec, simp) |
|
128 |
done |
|
129 |
||
130 |
||
131 |
subsection {* Sequences That Converge to Zero *} |
|
132 |
||
133 |
lemma ZseqI: |
|
134 |
"(\<And>r. 0 < r \<Longrightarrow> \<exists>no. \<forall>n\<ge>no. norm (X n) < r) \<Longrightarrow> Zseq X" |
|
135 |
unfolding Zseq_def by simp |
|
136 |
||
137 |
lemma ZseqD: |
|
138 |
"\<lbrakk>Zseq X; 0 < r\<rbrakk> \<Longrightarrow> \<exists>no. \<forall>n\<ge>no. norm (X n) < r" |
|
139 |
unfolding Zseq_def by simp |
|
140 |
||
141 |
lemma Zseq_zero: "Zseq (\<lambda>n. 0)" |
|
142 |
unfolding Zseq_def by simp |
|
143 |
||
144 |
lemma Zseq_const_iff: "Zseq (\<lambda>n. k) = (k = 0)" |
|
145 |
unfolding Zseq_def by force |
|
146 |
||
147 |
lemma Zseq_norm_iff: "Zseq (\<lambda>n. norm (X n)) = Zseq (\<lambda>n. X n)" |
|
148 |
unfolding Zseq_def by simp |
|
149 |
||
150 |
lemma Zseq_imp_Zseq: |
|
151 |
assumes X: "Zseq X" |
|
152 |
assumes Y: "\<And>n. norm (Y n) \<le> norm (X n) * K" |
|
153 |
shows "Zseq (\<lambda>n. Y n)" |
|
154 |
proof (cases) |
|
155 |
assume K: "0 < K" |
|
156 |
show ?thesis |
|
157 |
proof (rule ZseqI) |
|
158 |
fix r::real assume "0 < r" |
|
159 |
hence "0 < r / K" |
|
160 |
using K by (rule divide_pos_pos) |
|
161 |
then obtain N where "\<forall>n\<ge>N. norm (X n) < r / K" |
|
162 |
using ZseqD [OF X] by fast |
|
163 |
hence "\<forall>n\<ge>N. norm (X n) * K < r" |
|
164 |
by (simp add: pos_less_divide_eq K) |
|
165 |
hence "\<forall>n\<ge>N. norm (Y n) < r" |
|
166 |
by (simp add: order_le_less_trans [OF Y]) |
|
167 |
thus "\<exists>N. \<forall>n\<ge>N. norm (Y n) < r" .. |
|
168 |
qed |
|
169 |
next |
|
170 |
assume "\<not> 0 < K" |
|
171 |
hence K: "K \<le> 0" by (simp only: linorder_not_less) |
|
172 |
{ |
|
173 |
fix n::nat |
|
174 |
have "norm (Y n) \<le> norm (X n) * K" by (rule Y) |
|
175 |
also have "\<dots> \<le> norm (X n) * 0" |
|
176 |
using K norm_ge_zero by (rule mult_left_mono) |
|
177 |
finally have "norm (Y n) = 0" by simp |
|
178 |
} |
|
179 |
thus ?thesis by (simp add: Zseq_zero) |
|
180 |
qed |
|
181 |
||
182 |
lemma Zseq_le: "\<lbrakk>Zseq Y; \<forall>n. norm (X n) \<le> norm (Y n)\<rbrakk> \<Longrightarrow> Zseq X" |
|
183 |
by (erule_tac K="1" in Zseq_imp_Zseq, simp) |
|
184 |
||
185 |
lemma Zseq_add: |
|
186 |
assumes X: "Zseq X" |
|
187 |
assumes Y: "Zseq Y" |
|
188 |
shows "Zseq (\<lambda>n. X n + Y n)" |
|
189 |
proof (rule ZseqI) |
|
190 |
fix r::real assume "0 < r" |
|
191 |
hence r: "0 < r / 2" by simp |
|
192 |
obtain M where M: "\<forall>n\<ge>M. norm (X n) < r/2" |
|
193 |
using ZseqD [OF X r] by fast |
|
194 |
obtain N where N: "\<forall>n\<ge>N. norm (Y n) < r/2" |
|
195 |
using ZseqD [OF Y r] by fast |
|
196 |
show "\<exists>N. \<forall>n\<ge>N. norm (X n + Y n) < r" |
|
197 |
proof (intro exI allI impI) |
|
198 |
fix n assume n: "max M N \<le> n" |
|
199 |
have "norm (X n + Y n) \<le> norm (X n) + norm (Y n)" |
|
200 |
by (rule norm_triangle_ineq) |
|
201 |
also have "\<dots> < r/2 + r/2" |
|
202 |
proof (rule add_strict_mono) |
|
203 |
from M n show "norm (X n) < r/2" by simp |
|
204 |
from N n show "norm (Y n) < r/2" by simp |
|
205 |
qed |
|
206 |
finally show "norm (X n + Y n) < r" by simp |
|
207 |
qed |
|
208 |
qed |
|
209 |
||
210 |
lemma Zseq_minus: "Zseq X \<Longrightarrow> Zseq (\<lambda>n. - X n)" |
|
211 |
unfolding Zseq_def by simp |
|
212 |
||
213 |
lemma Zseq_diff: "\<lbrakk>Zseq X; Zseq Y\<rbrakk> \<Longrightarrow> Zseq (\<lambda>n. X n - Y n)" |
|
214 |
by (simp only: diff_minus Zseq_add Zseq_minus) |
|
215 |
||
216 |
lemma (in bounded_linear) Zseq: |
|
217 |
assumes X: "Zseq X" |
|
218 |
shows "Zseq (\<lambda>n. f (X n))" |
|
219 |
proof - |
|
220 |
obtain K where "\<And>x. norm (f x) \<le> norm x * K" |
|
221 |
using bounded by fast |
|
222 |
with X show ?thesis |
|
223 |
by (rule Zseq_imp_Zseq) |
|
224 |
qed |
|
225 |
||
226 |
lemma (in bounded_bilinear) Zseq_prod: |
|
227 |
assumes X: "Zseq X" |
|
228 |
assumes Y: "Zseq Y" |
|
229 |
shows "Zseq (\<lambda>n. X n ** Y n)" |
|
230 |
proof (rule ZseqI) |
|
231 |
fix r::real assume r: "0 < r" |
|
232 |
obtain K where K: "0 < K" |
|
233 |
and norm_le: "\<And>x y. norm (x ** y) \<le> norm x * norm y * K" |
|
234 |
using pos_bounded by fast |
|
235 |
from K have K': "0 < inverse K" |
|
236 |
by (rule positive_imp_inverse_positive) |
|
237 |
obtain M where M: "\<forall>n\<ge>M. norm (X n) < r" |
|
238 |
using ZseqD [OF X r] by fast |
|
239 |
obtain N where N: "\<forall>n\<ge>N. norm (Y n) < inverse K" |
|
240 |
using ZseqD [OF Y K'] by fast |
|
241 |
show "\<exists>N. \<forall>n\<ge>N. norm (X n ** Y n) < r" |
|
242 |
proof (intro exI allI impI) |
|
243 |
fix n assume n: "max M N \<le> n" |
|
244 |
have "norm (X n ** Y n) \<le> norm (X n) * norm (Y n) * K" |
|
245 |
by (rule norm_le) |
|
246 |
also have "norm (X n) * norm (Y n) * K < r * inverse K * K" |
|
247 |
proof (intro mult_strict_right_mono mult_strict_mono' norm_ge_zero K) |
|
248 |
from M n show Xn: "norm (X n) < r" by simp |
|
249 |
from N n show Yn: "norm (Y n) < inverse K" by simp |
|
250 |
qed |
|
251 |
also from K have "r * inverse K * K = r" by simp |
|
252 |
finally show "norm (X n ** Y n) < r" . |
|
253 |
qed |
|
254 |
qed |
|
255 |
||
256 |
lemma (in bounded_bilinear) Zseq_prod_Bseq: |
|
257 |
assumes X: "Zseq X" |
|
258 |
assumes Y: "Bseq Y" |
|
259 |
shows "Zseq (\<lambda>n. X n ** Y n)" |
|
260 |
proof - |
|
261 |
obtain K where K: "0 \<le> K" |
|
262 |
and norm_le: "\<And>x y. norm (x ** y) \<le> norm x * norm y * K" |
|
263 |
using nonneg_bounded by fast |
|
264 |
obtain B where B: "0 < B" |
|
265 |
and norm_Y: "\<And>n. norm (Y n) \<le> B" |
|
266 |
using Y [unfolded Bseq_def] by fast |
|
267 |
from X show ?thesis |
|
268 |
proof (rule Zseq_imp_Zseq) |
|
269 |
fix n::nat |
|
270 |
have "norm (X n ** Y n) \<le> norm (X n) * norm (Y n) * K" |
|
271 |
by (rule norm_le) |
|
272 |
also have "\<dots> \<le> norm (X n) * B * K" |
|
273 |
by (intro mult_mono' order_refl norm_Y norm_ge_zero |
|
274 |
mult_nonneg_nonneg K) |
|
275 |
also have "\<dots> = norm (X n) * (B * K)" |
|
276 |
by (rule mult_assoc) |
|
277 |
finally show "norm (X n ** Y n) \<le> norm (X n) * (B * K)" . |
|
278 |
qed |
|
279 |
qed |
|
280 |
||
281 |
lemma (in bounded_bilinear) Bseq_prod_Zseq: |
|
282 |
assumes X: "Bseq X" |
|
283 |
assumes Y: "Zseq Y" |
|
284 |
shows "Zseq (\<lambda>n. X n ** Y n)" |
|
285 |
proof - |
|
286 |
obtain K where K: "0 \<le> K" |
|
287 |
and norm_le: "\<And>x y. norm (x ** y) \<le> norm x * norm y * K" |
|
288 |
using nonneg_bounded by fast |
|
289 |
obtain B where B: "0 < B" |
|
290 |
and norm_X: "\<And>n. norm (X n) \<le> B" |
|
291 |
using X [unfolded Bseq_def] by fast |
|
292 |
from Y show ?thesis |
|
293 |
proof (rule Zseq_imp_Zseq) |
|
294 |
fix n::nat |
|
295 |
have "norm (X n ** Y n) \<le> norm (X n) * norm (Y n) * K" |
|
296 |
by (rule norm_le) |
|
297 |
also have "\<dots> \<le> B * norm (Y n) * K" |
|
298 |
by (intro mult_mono' order_refl norm_X norm_ge_zero |
|
299 |
mult_nonneg_nonneg K) |
|
300 |
also have "\<dots> = norm (Y n) * (B * K)" |
|
301 |
by (simp only: mult_ac) |
|
302 |
finally show "norm (X n ** Y n) \<le> norm (Y n) * (B * K)" . |
|
303 |
qed |
|
304 |
qed |
|
305 |
||
306 |
lemma (in bounded_bilinear) Zseq_prod_left: |
|
307 |
"Zseq X \<Longrightarrow> Zseq (\<lambda>n. X n ** a)" |
|
308 |
by (rule bounded_linear_left [THEN bounded_linear.Zseq]) |
|
309 |
||
310 |
lemma (in bounded_bilinear) Zseq_prod_right: |
|
311 |
"Zseq X \<Longrightarrow> Zseq (\<lambda>n. a ** X n)" |
|
312 |
by (rule bounded_linear_right [THEN bounded_linear.Zseq]) |
|
313 |
||
314 |
lemmas Zseq_mult = bounded_bilinear_mult.Zseq_prod |
|
315 |
lemmas Zseq_mult_right = bounded_bilinear_mult.Zseq_prod_right |
|
316 |
lemmas Zseq_mult_left = bounded_bilinear_mult.Zseq_prod_left |
|
317 |
||
318 |
||
20696 | 319 |
subsection {* Limits of Sequences *} |
320 |
||
321 |
subsubsection {* Purely standard proofs *} |
|
15082 | 322 |
|
323 |
lemma LIMSEQ_iff: |
|
20563 | 324 |
"(X ----> L) = (\<forall>r>0. \<exists>no. \<forall>n \<ge> no. norm (X n - L) < r)" |
22608 | 325 |
by (rule LIMSEQ_def) |
326 |
||
327 |
lemma LIMSEQ_Zseq_iff: "((\<lambda>n. X n) ----> L) = Zseq (\<lambda>n. X n - L)" |
|
328 |
by (simp only: LIMSEQ_def Zseq_def) |
|
15082 | 329 |
|
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
330 |
lemma LIMSEQ_I: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
331 |
"(\<And>r. 0 < r \<Longrightarrow> \<exists>no. \<forall>n\<ge>no. norm (X n - L) < r) \<Longrightarrow> X ----> L" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
332 |
by (simp add: LIMSEQ_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
333 |
|
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
334 |
lemma LIMSEQ_D: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
335 |
"\<lbrakk>X ----> L; 0 < r\<rbrakk> \<Longrightarrow> \<exists>no. \<forall>n\<ge>no. norm (X n - L) < r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
336 |
by (simp add: LIMSEQ_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
337 |
|
22608 | 338 |
lemma LIMSEQ_const: "(\<lambda>n. k) ----> k" |
20696 | 339 |
by (simp add: LIMSEQ_def) |
340 |
||
22608 | 341 |
lemma LIMSEQ_const_iff: "(\<lambda>n. k) ----> l = (k = l)" |
342 |
by (simp add: LIMSEQ_Zseq_iff Zseq_const_iff) |
|
343 |
||
20696 | 344 |
lemma LIMSEQ_norm: "X ----> a \<Longrightarrow> (\<lambda>n. norm (X n)) ----> norm a" |
345 |
apply (simp add: LIMSEQ_def, safe) |
|
346 |
apply (drule_tac x="r" in spec, safe) |
|
347 |
apply (rule_tac x="no" in exI, safe) |
|
348 |
apply (drule_tac x="n" in spec, safe) |
|
349 |
apply (erule order_le_less_trans [OF norm_triangle_ineq3]) |
|
350 |
done |
|
351 |
||
22615 | 352 |
lemma LIMSEQ_ignore_initial_segment: |
353 |
"f ----> a \<Longrightarrow> (\<lambda>n. f (n + k)) ----> a" |
|
354 |
apply (rule LIMSEQ_I) |
|
355 |
apply (drule (1) LIMSEQ_D) |
|
356 |
apply (erule exE, rename_tac N) |
|
357 |
apply (rule_tac x=N in exI) |
|
358 |
apply simp |
|
359 |
done |
|
20696 | 360 |
|
22615 | 361 |
lemma LIMSEQ_offset: |
362 |
"(\<lambda>n. f (n + k)) ----> a \<Longrightarrow> f ----> a" |
|
363 |
apply (rule LIMSEQ_I) |
|
364 |
apply (drule (1) LIMSEQ_D) |
|
365 |
apply (erule exE, rename_tac N) |
|
366 |
apply (rule_tac x="N + k" in exI) |
|
367 |
apply clarify |
|
368 |
apply (drule_tac x="n - k" in spec) |
|
369 |
apply (simp add: le_diff_conv2) |
|
20696 | 370 |
done |
371 |
||
22615 | 372 |
lemma LIMSEQ_Suc: "f ----> l \<Longrightarrow> (\<lambda>n. f (Suc n)) ----> l" |
373 |
by (drule_tac k="1" in LIMSEQ_ignore_initial_segment, simp) |
|
374 |
||
375 |
lemma LIMSEQ_imp_Suc: "(\<lambda>n. f (Suc n)) ----> l \<Longrightarrow> f ----> l" |
|
376 |
by (rule_tac k="1" in LIMSEQ_offset, simp) |
|
377 |
||
378 |
lemma LIMSEQ_Suc_iff: "(\<lambda>n. f (Suc n)) ----> l = f ----> l" |
|
379 |
by (blast intro: LIMSEQ_imp_Suc LIMSEQ_Suc) |
|
380 |
||
22608 | 381 |
lemma add_diff_add: |
382 |
fixes a b c d :: "'a::ab_group_add" |
|
383 |
shows "(a + c) - (b + d) = (a - b) + (c - d)" |
|
384 |
by simp |
|
385 |
||
386 |
lemma minus_diff_minus: |
|
387 |
fixes a b :: "'a::ab_group_add" |
|
388 |
shows "(- a) - (- b) = - (a - b)" |
|
389 |
by simp |
|
390 |
||
391 |
lemma LIMSEQ_add: "\<lbrakk>X ----> a; Y ----> b\<rbrakk> \<Longrightarrow> (\<lambda>n. X n + Y n) ----> a + b" |
|
392 |
by (simp only: LIMSEQ_Zseq_iff add_diff_add Zseq_add) |
|
393 |
||
394 |
lemma LIMSEQ_minus: "X ----> a \<Longrightarrow> (\<lambda>n. - X n) ----> - a" |
|
395 |
by (simp only: LIMSEQ_Zseq_iff minus_diff_minus Zseq_minus) |
|
396 |
||
397 |
lemma LIMSEQ_minus_cancel: "(\<lambda>n. - X n) ----> - a \<Longrightarrow> X ----> a" |
|
398 |
by (drule LIMSEQ_minus, simp) |
|
399 |
||
400 |
lemma LIMSEQ_diff: "\<lbrakk>X ----> a; Y ----> b\<rbrakk> \<Longrightarrow> (\<lambda>n. X n - Y n) ----> a - b" |
|
401 |
by (simp add: diff_minus LIMSEQ_add LIMSEQ_minus) |
|
402 |
||
403 |
lemma LIMSEQ_unique: "\<lbrakk>X ----> a; X ----> b\<rbrakk> \<Longrightarrow> a = b" |
|
404 |
by (drule (1) LIMSEQ_diff, simp add: LIMSEQ_const_iff) |
|
405 |
||
406 |
lemma (in bounded_linear) LIMSEQ: |
|
407 |
"X ----> a \<Longrightarrow> (\<lambda>n. f (X n)) ----> f a" |
|
408 |
by (simp only: LIMSEQ_Zseq_iff diff [symmetric] Zseq) |
|
409 |
||
410 |
lemma (in bounded_bilinear) LIMSEQ: |
|
411 |
"\<lbrakk>X ----> a; Y ----> b\<rbrakk> \<Longrightarrow> (\<lambda>n. X n ** Y n) ----> a ** b" |
|
412 |
by (simp only: LIMSEQ_Zseq_iff prod_diff_prod |
|
413 |
Zseq_add Zseq_prod Zseq_prod_left Zseq_prod_right) |
|
414 |
||
415 |
lemma LIMSEQ_mult: |
|
416 |
fixes a b :: "'a::real_normed_algebra" |
|
417 |
shows "[| X ----> a; Y ----> b |] ==> (%n. X n * Y n) ----> a * b" |
|
418 |
by (rule bounded_bilinear_mult.LIMSEQ) |
|
419 |
||
420 |
lemma inverse_diff_inverse: |
|
421 |
"\<lbrakk>(a::'a::division_ring) \<noteq> 0; b \<noteq> 0\<rbrakk> |
|
422 |
\<Longrightarrow> inverse a - inverse b = - (inverse a * (a - b) * inverse b)" |
|
423 |
by (simp add: right_diff_distrib left_diff_distrib mult_assoc) |
|
424 |
||
425 |
lemma Bseq_inverse_lemma: |
|
426 |
fixes x :: "'a::real_normed_div_algebra" |
|
427 |
shows "\<lbrakk>r \<le> norm x; 0 < r\<rbrakk> \<Longrightarrow> norm (inverse x) \<le> inverse r" |
|
428 |
apply (subst nonzero_norm_inverse, clarsimp) |
|
429 |
apply (erule (1) le_imp_inverse_le) |
|
430 |
done |
|
431 |
||
432 |
lemma Bseq_inverse: |
|
433 |
fixes a :: "'a::real_normed_div_algebra" |
|
434 |
assumes X: "X ----> a" |
|
435 |
assumes a: "a \<noteq> 0" |
|
436 |
shows "Bseq (\<lambda>n. inverse (X n))" |
|
437 |
proof - |
|
438 |
from a have "0 < norm a" by simp |
|
439 |
hence "\<exists>r>0. r < norm a" by (rule dense) |
|
440 |
then obtain r where r1: "0 < r" and r2: "r < norm a" by fast |
|
441 |
obtain N where N: "\<And>n. N \<le> n \<Longrightarrow> norm (X n - a) < r" |
|
442 |
using LIMSEQ_D [OF X r1] by fast |
|
443 |
show ?thesis |
|
444 |
proof (rule BseqI2 [rule_format]) |
|
445 |
fix n assume n: "N \<le> n" |
|
446 |
hence 1: "norm (X n - a) < r" by (rule N) |
|
447 |
hence 2: "X n \<noteq> 0" using r2 by auto |
|
448 |
hence "norm (inverse (X n)) = inverse (norm (X n))" |
|
449 |
by (rule nonzero_norm_inverse) |
|
450 |
also have "\<dots> \<le> inverse (norm a - r)" |
|
451 |
proof (rule le_imp_inverse_le) |
|
452 |
show "0 < norm a - r" using r2 by simp |
|
453 |
next |
|
454 |
have "norm a - norm (X n) \<le> norm (a - X n)" |
|
455 |
by (rule norm_triangle_ineq2) |
|
456 |
also have "\<dots> = norm (X n - a)" |
|
457 |
by (rule norm_minus_commute) |
|
458 |
also have "\<dots> < r" using 1 . |
|
459 |
finally show "norm a - r \<le> norm (X n)" by simp |
|
460 |
qed |
|
461 |
finally show "norm (inverse (X n)) \<le> inverse (norm a - r)" . |
|
462 |
qed |
|
463 |
qed |
|
464 |
||
465 |
lemma LIMSEQ_inverse_lemma: |
|
466 |
fixes a :: "'a::real_normed_div_algebra" |
|
467 |
shows "\<lbrakk>X ----> a; a \<noteq> 0; \<forall>n. X n \<noteq> 0\<rbrakk> |
|
468 |
\<Longrightarrow> (\<lambda>n. inverse (X n)) ----> inverse a" |
|
469 |
apply (subst LIMSEQ_Zseq_iff) |
|
470 |
apply (simp add: inverse_diff_inverse nonzero_imp_inverse_nonzero) |
|
471 |
apply (rule Zseq_minus) |
|
472 |
apply (rule Zseq_mult_left) |
|
473 |
apply (rule bounded_bilinear_mult.Bseq_prod_Zseq) |
|
474 |
apply (erule (1) Bseq_inverse) |
|
475 |
apply (simp add: LIMSEQ_Zseq_iff) |
|
476 |
done |
|
477 |
||
478 |
lemma LIMSEQ_inverse: |
|
479 |
fixes a :: "'a::real_normed_div_algebra" |
|
480 |
assumes X: "X ----> a" |
|
481 |
assumes a: "a \<noteq> 0" |
|
482 |
shows "(\<lambda>n. inverse (X n)) ----> inverse a" |
|
483 |
proof - |
|
484 |
from a have "0 < norm a" by simp |
|
485 |
then obtain k where "\<forall>n\<ge>k. norm (X n - a) < norm a" |
|
486 |
using LIMSEQ_D [OF X] by fast |
|
487 |
hence "\<forall>n\<ge>k. X n \<noteq> 0" by auto |
|
488 |
hence k: "\<forall>n. X (n + k) \<noteq> 0" by simp |
|
489 |
||
490 |
from X have "(\<lambda>n. X (n + k)) ----> a" |
|
491 |
by (rule LIMSEQ_ignore_initial_segment) |
|
492 |
hence "(\<lambda>n. inverse (X (n + k))) ----> inverse a" |
|
493 |
using a k by (rule LIMSEQ_inverse_lemma) |
|
494 |
thus "(\<lambda>n. inverse (X n)) ----> inverse a" |
|
495 |
by (rule LIMSEQ_offset) |
|
496 |
qed |
|
497 |
||
498 |
lemma LIMSEQ_divide: |
|
499 |
fixes a b :: "'a::real_normed_field" |
|
500 |
shows "\<lbrakk>X ----> a; Y ----> b; b \<noteq> 0\<rbrakk> \<Longrightarrow> (\<lambda>n. X n / Y n) ----> a / b" |
|
501 |
by (simp add: LIMSEQ_mult LIMSEQ_inverse divide_inverse) |
|
502 |
||
503 |
lemma LIMSEQ_pow: |
|
504 |
fixes a :: "'a::{real_normed_algebra,recpower}" |
|
505 |
shows "X ----> a \<Longrightarrow> (\<lambda>n. (X n) ^ m) ----> a ^ m" |
|
506 |
by (induct m) (simp_all add: power_Suc LIMSEQ_const LIMSEQ_mult) |
|
507 |
||
508 |
lemma LIMSEQ_setsum: |
|
509 |
assumes n: "\<And>n. n \<in> S \<Longrightarrow> X n ----> L n" |
|
510 |
shows "(\<lambda>m. \<Sum>n\<in>S. X n m) ----> (\<Sum>n\<in>S. L n)" |
|
511 |
proof (cases "finite S") |
|
512 |
case True |
|
513 |
thus ?thesis using n |
|
514 |
proof (induct) |
|
515 |
case empty |
|
516 |
show ?case |
|
517 |
by (simp add: LIMSEQ_const) |
|
518 |
next |
|
519 |
case insert |
|
520 |
thus ?case |
|
521 |
by (simp add: LIMSEQ_add) |
|
522 |
qed |
|
523 |
next |
|
524 |
case False |
|
525 |
thus ?thesis |
|
526 |
by (simp add: LIMSEQ_const) |
|
527 |
qed |
|
528 |
||
529 |
lemma LIMSEQ_setprod: |
|
530 |
fixes L :: "'a \<Rightarrow> 'b::{real_normed_algebra,comm_ring_1}" |
|
531 |
assumes n: "\<And>n. n \<in> S \<Longrightarrow> X n ----> L n" |
|
532 |
shows "(\<lambda>m. \<Prod>n\<in>S. X n m) ----> (\<Prod>n\<in>S. L n)" |
|
533 |
proof (cases "finite S") |
|
534 |
case True |
|
535 |
thus ?thesis using n |
|
536 |
proof (induct) |
|
537 |
case empty |
|
538 |
show ?case |
|
539 |
by (simp add: LIMSEQ_const) |
|
540 |
next |
|
541 |
case insert |
|
542 |
thus ?case |
|
543 |
by (simp add: LIMSEQ_mult) |
|
544 |
qed |
|
545 |
next |
|
546 |
case False |
|
547 |
thus ?thesis |
|
548 |
by (simp add: setprod_def LIMSEQ_const) |
|
549 |
qed |
|
550 |
||
22614 | 551 |
lemma LIMSEQ_add_const: "f ----> a ==> (%n.(f n + b)) ----> a + b" |
552 |
by (simp add: LIMSEQ_add LIMSEQ_const) |
|
553 |
||
554 |
(* FIXME: delete *) |
|
555 |
lemma LIMSEQ_add_minus: |
|
556 |
"[| X ----> a; Y ----> b |] ==> (%n. X n + -Y n) ----> a + -b" |
|
557 |
by (simp only: LIMSEQ_add LIMSEQ_minus) |
|
558 |
||
559 |
lemma LIMSEQ_diff_const: "f ----> a ==> (%n.(f n - b)) ----> a - b" |
|
560 |
by (simp add: LIMSEQ_diff LIMSEQ_const) |
|
561 |
||
562 |
lemma LIMSEQ_diff_approach_zero: |
|
563 |
"g ----> L ==> (%x. f x - g x) ----> 0 ==> |
|
564 |
f ----> L" |
|
565 |
apply (drule LIMSEQ_add) |
|
566 |
apply assumption |
|
567 |
apply simp |
|
568 |
done |
|
569 |
||
570 |
lemma LIMSEQ_diff_approach_zero2: |
|
571 |
"f ----> L ==> (%x. f x - g x) ----> 0 ==> |
|
572 |
g ----> L"; |
|
573 |
apply (drule LIMSEQ_diff) |
|
574 |
apply assumption |
|
575 |
apply simp |
|
576 |
done |
|
577 |
||
578 |
text{*A sequence tends to zero iff its abs does*} |
|
579 |
lemma LIMSEQ_norm_zero: "((\<lambda>n. norm (X n)) ----> 0) = (X ----> 0)" |
|
580 |
by (simp add: LIMSEQ_def) |
|
581 |
||
582 |
lemma LIMSEQ_rabs_zero: "((%n. \<bar>f n\<bar>) ----> 0) = (f ----> (0::real))" |
|
583 |
by (simp add: LIMSEQ_def) |
|
584 |
||
585 |
lemma LIMSEQ_imp_rabs: "f ----> (l::real) ==> (%n. \<bar>f n\<bar>) ----> \<bar>l\<bar>" |
|
586 |
by (drule LIMSEQ_norm, simp) |
|
587 |
||
588 |
text{*An unbounded sequence's inverse tends to 0*} |
|
589 |
||
590 |
text{* standard proof seems easier *} |
|
591 |
lemma LIMSEQ_inverse_zero: |
|
592 |
"\<forall>y::real. \<exists>N. \<forall>n \<ge> N. y < f(n) ==> (%n. inverse(f n)) ----> 0" |
|
593 |
apply (simp add: LIMSEQ_def, safe) |
|
594 |
apply (drule_tac x = "inverse r" in spec, safe) |
|
595 |
apply (rule_tac x = N in exI, safe) |
|
596 |
apply (drule spec, auto) |
|
597 |
apply (frule positive_imp_inverse_positive) |
|
598 |
apply (frule order_less_trans, assumption) |
|
599 |
apply (frule_tac a = "f n" in positive_imp_inverse_positive) |
|
600 |
apply (simp add: abs_if) |
|
601 |
apply (rule_tac t = r in inverse_inverse_eq [THEN subst]) |
|
602 |
apply (auto intro: inverse_less_iff_less [THEN iffD2] |
|
603 |
simp del: inverse_inverse_eq) |
|
604 |
done |
|
605 |
||
606 |
text{*The sequence @{term "1/n"} tends to 0 as @{term n} tends to infinity*} |
|
607 |
||
608 |
lemma LIMSEQ_inverse_real_of_nat: "(%n. inverse(real(Suc n))) ----> 0" |
|
609 |
apply (rule LIMSEQ_inverse_zero, safe) |
|
610 |
apply (cut_tac x = y in reals_Archimedean2) |
|
611 |
apply (safe, rule_tac x = n in exI) |
|
612 |
apply (auto simp add: real_of_nat_Suc) |
|
613 |
done |
|
614 |
||
615 |
text{*The sequence @{term "r + 1/n"} tends to @{term r} as @{term n} tends to |
|
616 |
infinity is now easily proved*} |
|
617 |
||
618 |
lemma LIMSEQ_inverse_real_of_nat_add: |
|
619 |
"(%n. r + inverse(real(Suc n))) ----> r" |
|
620 |
by (cut_tac LIMSEQ_add [OF LIMSEQ_const LIMSEQ_inverse_real_of_nat], auto) |
|
621 |
||
622 |
lemma LIMSEQ_inverse_real_of_nat_add_minus: |
|
623 |
"(%n. r + -inverse(real(Suc n))) ----> r" |
|
624 |
by (cut_tac LIMSEQ_add_minus [OF LIMSEQ_const LIMSEQ_inverse_real_of_nat], auto) |
|
625 |
||
626 |
lemma LIMSEQ_inverse_real_of_nat_add_minus_mult: |
|
627 |
"(%n. r*( 1 + -inverse(real(Suc n)))) ----> r" |
|
628 |
by (cut_tac b=1 in |
|
629 |
LIMSEQ_mult [OF LIMSEQ_const LIMSEQ_inverse_real_of_nat_add_minus], auto) |
|
630 |
||
22615 | 631 |
lemma LIMSEQ_le_const: |
632 |
"\<lbrakk>X ----> (x::real); \<exists>N. \<forall>n\<ge>N. a \<le> X n\<rbrakk> \<Longrightarrow> a \<le> x" |
|
633 |
apply (rule ccontr, simp only: linorder_not_le) |
|
634 |
apply (drule_tac r="a - x" in LIMSEQ_D, simp) |
|
635 |
apply clarsimp |
|
636 |
apply (drule_tac x="max N no" in spec, drule mp, rule le_maxI1) |
|
637 |
apply (drule_tac x="max N no" in spec, drule mp, rule le_maxI2) |
|
638 |
apply simp |
|
639 |
done |
|
640 |
||
641 |
lemma LIMSEQ_le_const2: |
|
642 |
"\<lbrakk>X ----> (x::real); \<exists>N. \<forall>n\<ge>N. X n \<le> a\<rbrakk> \<Longrightarrow> x \<le> a" |
|
643 |
apply (subgoal_tac "- a \<le> - x", simp) |
|
644 |
apply (rule LIMSEQ_le_const) |
|
645 |
apply (erule LIMSEQ_minus) |
|
646 |
apply simp |
|
647 |
done |
|
648 |
||
649 |
lemma LIMSEQ_le: |
|
650 |
"\<lbrakk>X ----> x; Y ----> y; \<exists>N. \<forall>n\<ge>N. X n \<le> Y n\<rbrakk> \<Longrightarrow> x \<le> (y::real)" |
|
651 |
apply (subgoal_tac "0 \<le> y - x", simp) |
|
652 |
apply (rule LIMSEQ_le_const) |
|
653 |
apply (erule (1) LIMSEQ_diff) |
|
654 |
apply (simp add: le_diff_eq) |
|
655 |
done |
|
656 |
||
20696 | 657 |
subsubsection {* Purely nonstandard proofs *} |
658 |
||
15082 | 659 |
lemma NSLIMSEQ_iff: |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
660 |
"(X ----NS> L) = (\<forall>N \<in> HNatInfinite. ( *f* X) N \<approx> star_of L)" |
15082 | 661 |
by (simp add: NSLIMSEQ_def) |
662 |
||
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
663 |
lemma NSLIMSEQ_I: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
664 |
"(\<And>N. N \<in> HNatInfinite \<Longrightarrow> starfun X N \<approx> star_of L) \<Longrightarrow> X ----NS> L" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
665 |
by (simp add: NSLIMSEQ_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
666 |
|
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
667 |
lemma NSLIMSEQ_D: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
668 |
"\<lbrakk>X ----NS> L; N \<in> HNatInfinite\<rbrakk> \<Longrightarrow> starfun X N \<approx> star_of L" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
669 |
by (simp add: NSLIMSEQ_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
670 |
|
20696 | 671 |
lemma NSLIMSEQ_const: "(%n. k) ----NS> k" |
672 |
by (simp add: NSLIMSEQ_def) |
|
673 |
||
674 |
lemma NSLIMSEQ_add: |
|
675 |
"[| X ----NS> a; Y ----NS> b |] ==> (%n. X n + Y n) ----NS> a + b" |
|
676 |
by (auto intro: approx_add simp add: NSLIMSEQ_def starfun_add [symmetric]) |
|
677 |
||
678 |
lemma NSLIMSEQ_add_const: "f ----NS> a ==> (%n.(f n + b)) ----NS> a + b" |
|
679 |
by (simp only: NSLIMSEQ_add NSLIMSEQ_const) |
|
680 |
||
681 |
lemma NSLIMSEQ_mult: |
|
682 |
fixes a b :: "'a::real_normed_algebra" |
|
683 |
shows "[| X ----NS> a; Y ----NS> b |] ==> (%n. X n * Y n) ----NS> a * b" |
|
684 |
by (auto intro!: approx_mult_HFinite simp add: NSLIMSEQ_def) |
|
685 |
||
686 |
lemma NSLIMSEQ_minus: "X ----NS> a ==> (%n. -(X n)) ----NS> -a" |
|
687 |
by (auto simp add: NSLIMSEQ_def) |
|
688 |
||
689 |
lemma NSLIMSEQ_minus_cancel: "(%n. -(X n)) ----NS> -a ==> X ----NS> a" |
|
690 |
by (drule NSLIMSEQ_minus, simp) |
|
691 |
||
692 |
(* FIXME: delete *) |
|
693 |
lemma NSLIMSEQ_add_minus: |
|
694 |
"[| X ----NS> a; Y ----NS> b |] ==> (%n. X n + -Y n) ----NS> a + -b" |
|
695 |
by (simp add: NSLIMSEQ_add NSLIMSEQ_minus) |
|
696 |
||
697 |
lemma NSLIMSEQ_diff: |
|
698 |
"[| X ----NS> a; Y ----NS> b |] ==> (%n. X n - Y n) ----NS> a - b" |
|
699 |
by (simp add: diff_minus NSLIMSEQ_add NSLIMSEQ_minus) |
|
700 |
||
701 |
lemma NSLIMSEQ_diff_const: "f ----NS> a ==> (%n.(f n - b)) ----NS> a - b" |
|
702 |
by (simp add: NSLIMSEQ_diff NSLIMSEQ_const) |
|
703 |
||
704 |
lemma NSLIMSEQ_inverse: |
|
705 |
fixes a :: "'a::real_normed_div_algebra" |
|
706 |
shows "[| X ----NS> a; a ~= 0 |] ==> (%n. inverse(X n)) ----NS> inverse(a)" |
|
707 |
by (simp add: NSLIMSEQ_def star_of_approx_inverse) |
|
708 |
||
709 |
lemma NSLIMSEQ_mult_inverse: |
|
710 |
fixes a b :: "'a::real_normed_field" |
|
711 |
shows |
|
712 |
"[| X ----NS> a; Y ----NS> b; b ~= 0 |] ==> (%n. X n / Y n) ----NS> a/b" |
|
713 |
by (simp add: NSLIMSEQ_mult NSLIMSEQ_inverse divide_inverse) |
|
714 |
||
715 |
lemma starfun_hnorm: "\<And>x. hnorm (( *f* f) x) = ( *f* (\<lambda>x. norm (f x))) x" |
|
716 |
by transfer simp |
|
717 |
||
718 |
lemma NSLIMSEQ_norm: "X ----NS> a \<Longrightarrow> (\<lambda>n. norm (X n)) ----NS> norm a" |
|
719 |
by (simp add: NSLIMSEQ_def starfun_hnorm [symmetric] approx_hnorm) |
|
720 |
||
721 |
text{*Uniqueness of limit*} |
|
722 |
lemma NSLIMSEQ_unique: "[| X ----NS> a; X ----NS> b |] ==> a = b" |
|
723 |
apply (simp add: NSLIMSEQ_def) |
|
724 |
apply (drule HNatInfinite_whn [THEN [2] bspec])+ |
|
725 |
apply (auto dest: approx_trans3) |
|
726 |
done |
|
727 |
||
728 |
lemma NSLIMSEQ_pow [rule_format]: |
|
729 |
fixes a :: "'a::{real_normed_algebra,recpower}" |
|
730 |
shows "(X ----NS> a) --> ((%n. (X n) ^ m) ----NS> a ^ m)" |
|
731 |
apply (induct "m") |
|
732 |
apply (auto simp add: power_Suc intro: NSLIMSEQ_mult NSLIMSEQ_const) |
|
733 |
done |
|
734 |
||
22614 | 735 |
text{*We can now try and derive a few properties of sequences, |
736 |
starting with the limit comparison property for sequences.*} |
|
737 |
||
738 |
lemma NSLIMSEQ_le: |
|
739 |
"[| f ----NS> l; g ----NS> m; |
|
740 |
\<exists>N. \<forall>n \<ge> N. f(n) \<le> g(n) |
|
741 |
|] ==> l \<le> (m::real)" |
|
742 |
apply (simp add: NSLIMSEQ_def, safe) |
|
743 |
apply (drule starfun_le_mono) |
|
744 |
apply (drule HNatInfinite_whn [THEN [2] bspec])+ |
|
745 |
apply (drule_tac x = whn in spec) |
|
746 |
apply (drule bex_Infinitesimal_iff2 [THEN iffD2])+ |
|
747 |
apply clarify |
|
748 |
apply (auto intro: hypreal_of_real_le_add_Infininitesimal_cancel2) |
|
749 |
done |
|
750 |
||
751 |
lemma NSLIMSEQ_le_const: "[| X ----NS> (r::real); \<forall>n. a \<le> X n |] ==> a \<le> r" |
|
752 |
by (erule NSLIMSEQ_le [OF NSLIMSEQ_const], auto) |
|
753 |
||
754 |
lemma NSLIMSEQ_le_const2: "[| X ----NS> (r::real); \<forall>n. X n \<le> a |] ==> r \<le> a" |
|
755 |
by (erule NSLIMSEQ_le [OF _ NSLIMSEQ_const], auto) |
|
756 |
||
757 |
text{*Shift a convergent series by 1: |
|
758 |
By the equivalence between Cauchiness and convergence and because |
|
759 |
the successor of an infinite hypernatural is also infinite.*} |
|
760 |
||
761 |
lemma NSLIMSEQ_Suc: "f ----NS> l ==> (%n. f(Suc n)) ----NS> l" |
|
762 |
apply (unfold NSLIMSEQ_def, safe) |
|
763 |
apply (drule_tac x="N + 1" in bspec) |
|
764 |
apply (erule HNatInfinite_add) |
|
765 |
apply (simp add: starfun_shift_one) |
|
766 |
done |
|
767 |
||
768 |
lemma NSLIMSEQ_imp_Suc: "(%n. f(Suc n)) ----NS> l ==> f ----NS> l" |
|
769 |
apply (unfold NSLIMSEQ_def, safe) |
|
770 |
apply (drule_tac x="N - 1" in bspec) |
|
771 |
apply (erule Nats_1 [THEN [2] HNatInfinite_diff]) |
|
772 |
apply (simp add: starfun_shift_one one_le_HNatInfinite) |
|
773 |
done |
|
774 |
||
775 |
lemma NSLIMSEQ_Suc_iff: "((%n. f(Suc n)) ----NS> l) = (f ----NS> l)" |
|
776 |
by (blast intro: NSLIMSEQ_imp_Suc NSLIMSEQ_Suc) |
|
777 |
||
20696 | 778 |
subsubsection {* Equivalence of @{term LIMSEQ} and @{term NSLIMSEQ} *} |
15082 | 779 |
|
780 |
lemma LIMSEQ_NSLIMSEQ: |
|
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
781 |
assumes X: "X ----> L" shows "X ----NS> L" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
782 |
proof (rule NSLIMSEQ_I) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
783 |
fix N assume N: "N \<in> HNatInfinite" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
784 |
have "starfun X N - star_of L \<in> Infinitesimal" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
785 |
proof (rule InfinitesimalI2) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
786 |
fix r::real assume r: "0 < r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
787 |
from LIMSEQ_D [OF X r] |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
788 |
obtain no where "\<forall>n\<ge>no. norm (X n - L) < r" .. |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
789 |
hence "\<forall>n\<ge>star_of no. hnorm (starfun X n - star_of L) < star_of r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
790 |
by transfer |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
791 |
thus "hnorm (starfun X N - star_of L) < star_of r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
792 |
using N by (simp add: star_of_le_HNatInfinite) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
793 |
qed |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
794 |
thus "starfun X N \<approx> star_of L" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
795 |
by (unfold approx_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
796 |
qed |
15082 | 797 |
|
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
798 |
lemma NSLIMSEQ_LIMSEQ: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
799 |
assumes X: "X ----NS> L" shows "X ----> L" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
800 |
proof (rule LIMSEQ_I) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
801 |
fix r::real assume r: "0 < r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
802 |
have "\<exists>no. \<forall>n\<ge>no. hnorm (starfun X n - star_of L) < star_of r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
803 |
proof (intro exI allI impI) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
804 |
fix n assume "whn \<le> n" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
805 |
with HNatInfinite_whn have "n \<in> HNatInfinite" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
806 |
by (rule HNatInfinite_upward_closed) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
807 |
with X have "starfun X n \<approx> star_of L" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
808 |
by (rule NSLIMSEQ_D) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
809 |
hence "starfun X n - star_of L \<in> Infinitesimal" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
810 |
by (unfold approx_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
811 |
thus "hnorm (starfun X n - star_of L) < star_of r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
812 |
using r by (rule InfinitesimalD2) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
813 |
qed |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
814 |
thus "\<exists>no. \<forall>n\<ge>no. norm (X n - L) < r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
815 |
by transfer |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
816 |
qed |
15082 | 817 |
|
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
818 |
theorem LIMSEQ_NSLIMSEQ_iff: "(f ----> L) = (f ----NS> L)" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
819 |
by (blast intro: LIMSEQ_NSLIMSEQ NSLIMSEQ_LIMSEQ) |
15082 | 820 |
|
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
821 |
(* Used once by Integration/Rats.thy in AFP *) |
15082 | 822 |
lemma NSLIMSEQ_finite_set: |
823 |
"!!(f::nat=>nat). \<forall>n. n \<le> f n ==> finite {n. f n \<le> u}" |
|
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
824 |
by (rule_tac B="{..u}" in finite_subset, auto intro: order_trans) |
15082 | 825 |
|
22615 | 826 |
subsubsection {* Derived theorems about @{term NSLIMSEQ} *} |
22614 | 827 |
|
828 |
text{*We prove the NS version from the standard one, since the NS proof |
|
829 |
seems more complicated than the standard one above!*} |
|
830 |
lemma NSLIMSEQ_norm_zero: "((\<lambda>n. norm (X n)) ----NS> 0) = (X ----NS> 0)" |
|
831 |
by (simp add: LIMSEQ_NSLIMSEQ_iff [symmetric] LIMSEQ_norm_zero) |
|
832 |
||
833 |
lemma NSLIMSEQ_rabs_zero: "((%n. \<bar>f n\<bar>) ----NS> 0) = (f ----NS> (0::real))" |
|
834 |
by (simp add: LIMSEQ_NSLIMSEQ_iff [symmetric] LIMSEQ_rabs_zero) |
|
835 |
||
836 |
text{*Generalization to other limits*} |
|
837 |
lemma NSLIMSEQ_imp_rabs: "f ----NS> (l::real) ==> (%n. \<bar>f n\<bar>) ----NS> \<bar>l\<bar>" |
|
838 |
apply (simp add: NSLIMSEQ_def) |
|
839 |
apply (auto intro: approx_hrabs |
|
840 |
simp add: starfun_abs) |
|
16819 | 841 |
done |
842 |
||
22614 | 843 |
lemma NSLIMSEQ_inverse_zero: |
844 |
"\<forall>y::real. \<exists>N. \<forall>n \<ge> N. y < f(n) |
|
845 |
==> (%n. inverse(f n)) ----NS> 0" |
|
846 |
by (simp add: LIMSEQ_NSLIMSEQ_iff [symmetric] LIMSEQ_inverse_zero) |
|
847 |
||
848 |
lemma NSLIMSEQ_inverse_real_of_nat: "(%n. inverse(real(Suc n))) ----NS> 0" |
|
849 |
by (simp add: LIMSEQ_NSLIMSEQ_iff [symmetric] LIMSEQ_inverse_real_of_nat) |
|
850 |
||
851 |
lemma NSLIMSEQ_inverse_real_of_nat_add: |
|
852 |
"(%n. r + inverse(real(Suc n))) ----NS> r" |
|
853 |
by (simp add: LIMSEQ_NSLIMSEQ_iff [symmetric] LIMSEQ_inverse_real_of_nat_add) |
|
854 |
||
855 |
lemma NSLIMSEQ_inverse_real_of_nat_add_minus: |
|
856 |
"(%n. r + -inverse(real(Suc n))) ----NS> r" |
|
857 |
by (simp add: LIMSEQ_NSLIMSEQ_iff [symmetric] LIMSEQ_inverse_real_of_nat_add_minus) |
|
858 |
||
859 |
lemma NSLIMSEQ_inverse_real_of_nat_add_minus_mult: |
|
860 |
"(%n. r*( 1 + -inverse(real(Suc n)))) ----NS> r" |
|
861 |
by (simp add: LIMSEQ_NSLIMSEQ_iff [symmetric] LIMSEQ_inverse_real_of_nat_add_minus_mult) |
|
862 |
||
15082 | 863 |
|
20696 | 864 |
subsection {* Convergence *} |
15082 | 865 |
|
866 |
lemma limI: "X ----> L ==> lim X = L" |
|
867 |
apply (simp add: lim_def) |
|
868 |
apply (blast intro: LIMSEQ_unique) |
|
869 |
done |
|
870 |
||
871 |
lemma nslimI: "X ----NS> L ==> nslim X = L" |
|
872 |
apply (simp add: nslim_def) |
|
873 |
apply (blast intro: NSLIMSEQ_unique) |
|
874 |
done |
|
875 |
||
876 |
lemma lim_nslim_iff: "lim X = nslim X" |
|
877 |
by (simp add: lim_def nslim_def LIMSEQ_NSLIMSEQ_iff) |
|
878 |
||
879 |
lemma convergentD: "convergent X ==> \<exists>L. (X ----> L)" |
|
880 |
by (simp add: convergent_def) |
|
881 |
||
882 |
lemma convergentI: "(X ----> L) ==> convergent X" |
|
883 |
by (auto simp add: convergent_def) |
|
884 |
||
885 |
lemma NSconvergentD: "NSconvergent X ==> \<exists>L. (X ----NS> L)" |
|
886 |
by (simp add: NSconvergent_def) |
|
887 |
||
888 |
lemma NSconvergentI: "(X ----NS> L) ==> NSconvergent X" |
|
889 |
by (auto simp add: NSconvergent_def) |
|
890 |
||
891 |
lemma convergent_NSconvergent_iff: "convergent X = NSconvergent X" |
|
892 |
by (simp add: convergent_def NSconvergent_def LIMSEQ_NSLIMSEQ_iff) |
|
893 |
||
894 |
lemma NSconvergent_NSLIMSEQ_iff: "NSconvergent X = (X ----NS> nslim X)" |
|
20682 | 895 |
by (auto intro: theI NSLIMSEQ_unique simp add: NSconvergent_def nslim_def) |
15082 | 896 |
|
897 |
lemma convergent_LIMSEQ_iff: "convergent X = (X ----> lim X)" |
|
20682 | 898 |
by (auto intro: theI LIMSEQ_unique simp add: convergent_def lim_def) |
15082 | 899 |
|
20696 | 900 |
lemma convergent_minus_iff: "(convergent X) = (convergent (%n. -(X n)))" |
901 |
apply (simp add: convergent_def) |
|
902 |
apply (auto dest: LIMSEQ_minus) |
|
903 |
apply (drule LIMSEQ_minus, auto) |
|
904 |
done |
|
905 |
||
906 |
||
907 |
subsection {* Bounded Monotonic Sequences *} |
|
908 |
||
15082 | 909 |
text{*Subsequence (alternative definition, (e.g. Hoskins)*} |
910 |
||
911 |
lemma subseq_Suc_iff: "subseq f = (\<forall>n. (f n) < (f (Suc n)))" |
|
912 |
apply (simp add: subseq_def) |
|
913 |
apply (auto dest!: less_imp_Suc_add) |
|
914 |
apply (induct_tac k) |
|
915 |
apply (auto intro: less_trans) |
|
916 |
done |
|
917 |
||
918 |
lemma monoseq_Suc: |
|
919 |
"monoseq X = ((\<forall>n. X n \<le> X (Suc n)) |
|
920 |
| (\<forall>n. X (Suc n) \<le> X n))" |
|
921 |
apply (simp add: monoseq_def) |
|
922 |
apply (auto dest!: le_imp_less_or_eq) |
|
923 |
apply (auto intro!: lessI [THEN less_imp_le] dest!: less_imp_Suc_add) |
|
924 |
apply (induct_tac "ka") |
|
925 |
apply (auto intro: order_trans) |
|
18585 | 926 |
apply (erule contrapos_np) |
15082 | 927 |
apply (induct_tac "k") |
928 |
apply (auto intro: order_trans) |
|
929 |
done |
|
930 |
||
15360 | 931 |
lemma monoI1: "\<forall>m. \<forall> n \<ge> m. X m \<le> X n ==> monoseq X" |
15082 | 932 |
by (simp add: monoseq_def) |
933 |
||
15360 | 934 |
lemma monoI2: "\<forall>m. \<forall> n \<ge> m. X n \<le> X m ==> monoseq X" |
15082 | 935 |
by (simp add: monoseq_def) |
936 |
||
937 |
lemma mono_SucI1: "\<forall>n. X n \<le> X (Suc n) ==> monoseq X" |
|
938 |
by (simp add: monoseq_Suc) |
|
939 |
||
940 |
lemma mono_SucI2: "\<forall>n. X (Suc n) \<le> X n ==> monoseq X" |
|
941 |
by (simp add: monoseq_Suc) |
|
942 |
||
20696 | 943 |
text{*Bounded Sequence*} |
15082 | 944 |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
945 |
lemma BseqD: "Bseq X ==> \<exists>K. 0 < K & (\<forall>n. norm (X n) \<le> K)" |
15082 | 946 |
by (simp add: Bseq_def) |
947 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
948 |
lemma BseqI: "[| 0 < K; \<forall>n. norm (X n) \<le> K |] ==> Bseq X" |
15082 | 949 |
by (auto simp add: Bseq_def) |
950 |
||
951 |
lemma lemma_NBseq_def: |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
952 |
"(\<exists>K > 0. \<forall>n. norm (X n) \<le> K) = |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
953 |
(\<exists>N. \<forall>n. norm (X n) \<le> real(Suc N))" |
15082 | 954 |
apply auto |
955 |
prefer 2 apply force |
|
956 |
apply (cut_tac x = K in reals_Archimedean2, clarify) |
|
957 |
apply (rule_tac x = n in exI, clarify) |
|
958 |
apply (drule_tac x = na in spec) |
|
959 |
apply (auto simp add: real_of_nat_Suc) |
|
960 |
done |
|
961 |
||
962 |
text{* alternative definition for Bseq *} |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
963 |
lemma Bseq_iff: "Bseq X = (\<exists>N. \<forall>n. norm (X n) \<le> real(Suc N))" |
15082 | 964 |
apply (simp add: Bseq_def) |
965 |
apply (simp (no_asm) add: lemma_NBseq_def) |
|
966 |
done |
|
967 |
||
968 |
lemma lemma_NBseq_def2: |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
969 |
"(\<exists>K > 0. \<forall>n. norm (X n) \<le> K) = (\<exists>N. \<forall>n. norm (X n) < real(Suc N))" |
15082 | 970 |
apply (subst lemma_NBseq_def, auto) |
971 |
apply (rule_tac x = "Suc N" in exI) |
|
972 |
apply (rule_tac [2] x = N in exI) |
|
973 |
apply (auto simp add: real_of_nat_Suc) |
|
974 |
prefer 2 apply (blast intro: order_less_imp_le) |
|
975 |
apply (drule_tac x = n in spec, simp) |
|
976 |
done |
|
977 |
||
978 |
(* yet another definition for Bseq *) |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
979 |
lemma Bseq_iff1a: "Bseq X = (\<exists>N. \<forall>n. norm (X n) < real(Suc N))" |
15082 | 980 |
by (simp add: Bseq_def lemma_NBseq_def2) |
981 |
||
17318
bc1c75855f3d
starfun, starset, and other functions on NS types are now polymorphic;
huffman
parents:
17299
diff
changeset
|
982 |
lemma NSBseqD: "[| NSBseq X; N: HNatInfinite |] ==> ( *f* X) N : HFinite" |
15082 | 983 |
by (simp add: NSBseq_def) |
984 |
||
21842
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
985 |
lemma Standard_subset_HFinite: "Standard \<subseteq> HFinite" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
986 |
unfolding Standard_def by auto |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
987 |
|
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
988 |
lemma NSBseqD2: "NSBseq X \<Longrightarrow> ( *f* X) N \<in> HFinite" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
989 |
apply (cases "N \<in> HNatInfinite") |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
990 |
apply (erule (1) NSBseqD) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
991 |
apply (rule subsetD [OF Standard_subset_HFinite]) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
992 |
apply (simp add: HNatInfinite_def Nats_eq_Standard) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
993 |
done |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
994 |
|
17318
bc1c75855f3d
starfun, starset, and other functions on NS types are now polymorphic;
huffman
parents:
17299
diff
changeset
|
995 |
lemma NSBseqI: "\<forall>N \<in> HNatInfinite. ( *f* X) N : HFinite ==> NSBseq X" |
15082 | 996 |
by (simp add: NSBseq_def) |
997 |
||
998 |
text{*The standard definition implies the nonstandard definition*} |
|
999 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1000 |
lemma lemma_Bseq: "\<forall>n. norm (X n) \<le> K ==> \<forall>n. norm(X((f::nat=>nat) n)) \<le> K" |
15082 | 1001 |
by auto |
1002 |
||
1003 |
lemma Bseq_NSBseq: "Bseq X ==> NSBseq X" |
|
21139 | 1004 |
proof (unfold NSBseq_def, safe) |
1005 |
assume X: "Bseq X" |
|
1006 |
fix N assume N: "N \<in> HNatInfinite" |
|
1007 |
from BseqD [OF X] obtain K where "\<forall>n. norm (X n) \<le> K" by fast |
|
1008 |
hence "\<forall>N. hnorm (starfun X N) \<le> star_of K" by transfer |
|
1009 |
hence "hnorm (starfun X N) \<le> star_of K" by simp |
|
1010 |
also have "star_of K < star_of (K + 1)" by simp |
|
1011 |
finally have "\<exists>x\<in>Reals. hnorm (starfun X N) < x" by (rule bexI, simp) |
|
1012 |
thus "starfun X N \<in> HFinite" by (simp add: HFinite_def) |
|
1013 |
qed |
|
15082 | 1014 |
|
1015 |
text{*The nonstandard definition implies the standard definition*} |
|
1016 |
||
21842
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1017 |
lemma SReal_less_omega: "r \<in> \<real> \<Longrightarrow> r < \<omega>" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1018 |
apply (insert HInfinite_omega) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1019 |
apply (simp add: HInfinite_def) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1020 |
apply (simp add: order_less_imp_le) |
15082 | 1021 |
done |
1022 |
||
21842
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1023 |
lemma NSBseq_Bseq: "NSBseq X \<Longrightarrow> Bseq X" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1024 |
proof (rule ccontr) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1025 |
let ?n = "\<lambda>K. LEAST n. K < norm (X n)" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1026 |
assume "NSBseq X" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1027 |
hence finite: "( *f* X) (( *f* ?n) \<omega>) \<in> HFinite" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1028 |
by (rule NSBseqD2) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1029 |
assume "\<not> Bseq X" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1030 |
hence "\<forall>K>0. \<exists>n. K < norm (X n)" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1031 |
by (simp add: Bseq_def linorder_not_le) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1032 |
hence "\<forall>K>0. K < norm (X (?n K))" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1033 |
by (auto intro: LeastI_ex) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1034 |
hence "\<forall>K>0. K < hnorm (( *f* X) (( *f* ?n) K))" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1035 |
by transfer |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1036 |
hence "\<omega> < hnorm (( *f* X) (( *f* ?n) \<omega>))" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1037 |
by simp |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1038 |
hence "\<forall>r\<in>\<real>. r < hnorm (( *f* X) (( *f* ?n) \<omega>))" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1039 |
by (simp add: order_less_trans [OF SReal_less_omega]) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1040 |
hence "( *f* X) (( *f* ?n) \<omega>) \<in> HInfinite" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1041 |
by (simp add: HInfinite_def) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1042 |
with finite show "False" |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1043 |
by (simp add: HFinite_HInfinite_iff) |
3d8ab6545049
remove references to star_n and FreeUltrafilterNat; new proof of NSBseq_Bseq
huffman
parents:
21810
diff
changeset
|
1044 |
qed |
15082 | 1045 |
|
1046 |
text{* Equivalence of nonstandard and standard definitions |
|
1047 |
for a bounded sequence*} |
|
1048 |
lemma Bseq_NSBseq_iff: "(Bseq X) = (NSBseq X)" |
|
1049 |
by (blast intro!: NSBseq_Bseq Bseq_NSBseq) |
|
1050 |
||
1051 |
text{*A convergent sequence is bounded: |
|
1052 |
Boundedness as a necessary condition for convergence. |
|
1053 |
The nonstandard version has no existential, as usual *} |
|
1054 |
||
1055 |
lemma NSconvergent_NSBseq: "NSconvergent X ==> NSBseq X" |
|
1056 |
apply (simp add: NSconvergent_def NSBseq_def NSLIMSEQ_def) |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1057 |
apply (blast intro: HFinite_star_of approx_sym approx_HFinite) |
15082 | 1058 |
done |
1059 |
||
1060 |
text{*Standard Version: easily now proved using equivalence of NS and |
|
1061 |
standard definitions *} |
|
1062 |
lemma convergent_Bseq: "convergent X ==> Bseq X" |
|
1063 |
by (simp add: NSconvergent_NSBseq convergent_NSconvergent_iff Bseq_NSBseq_iff) |
|
1064 |
||
20696 | 1065 |
subsubsection{*Upper Bounds and Lubs of Bounded Sequences*} |
15082 | 1066 |
|
1067 |
lemma Bseq_isUb: |
|
1068 |
"!!(X::nat=>real). Bseq X ==> \<exists>U. isUb (UNIV::real set) {x. \<exists>n. X n = x} U" |
|
1069 |
by (auto intro: isUbI setleI simp add: Bseq_def abs_le_interval_iff) |
|
1070 |
||
1071 |
||
1072 |
text{* Use completeness of reals (supremum property) |
|
1073 |
to show that any bounded sequence has a least upper bound*} |
|
1074 |
||
1075 |
lemma Bseq_isLub: |
|
1076 |
"!!(X::nat=>real). Bseq X ==> |
|
1077 |
\<exists>U. isLub (UNIV::real set) {x. \<exists>n. X n = x} U" |
|
1078 |
by (blast intro: reals_complete Bseq_isUb) |
|
1079 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1080 |
lemma NSBseq_isUb: "NSBseq X ==> \<exists>U::real. isUb UNIV {x. \<exists>n. X n = x} U" |
15082 | 1081 |
by (simp add: Bseq_NSBseq_iff [symmetric] Bseq_isUb) |
1082 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1083 |
lemma NSBseq_isLub: "NSBseq X ==> \<exists>U::real. isLub UNIV {x. \<exists>n. X n = x} U" |
15082 | 1084 |
by (simp add: Bseq_NSBseq_iff [symmetric] Bseq_isLub) |
1085 |
||
1086 |
||
20696 | 1087 |
subsubsection{*A Bounded and Monotonic Sequence Converges*} |
15082 | 1088 |
|
1089 |
lemma lemma_converg1: |
|
15360 | 1090 |
"!!(X::nat=>real). [| \<forall>m. \<forall> n \<ge> m. X m \<le> X n; |
15082 | 1091 |
isLub (UNIV::real set) {x. \<exists>n. X n = x} (X ma) |
15360 | 1092 |
|] ==> \<forall>n \<ge> ma. X n = X ma" |
15082 | 1093 |
apply safe |
1094 |
apply (drule_tac y = "X n" in isLubD2) |
|
1095 |
apply (blast dest: order_antisym)+ |
|
1096 |
done |
|
1097 |
||
1098 |
text{* The best of both worlds: Easier to prove this result as a standard |
|
1099 |
theorem and then use equivalence to "transfer" it into the |
|
1100 |
equivalent nonstandard form if needed!*} |
|
1101 |
||
1102 |
lemma Bmonoseq_LIMSEQ: "\<forall>n. m \<le> n --> X n = X m ==> \<exists>L. (X ----> L)" |
|
1103 |
apply (simp add: LIMSEQ_def) |
|
1104 |
apply (rule_tac x = "X m" in exI, safe) |
|
1105 |
apply (rule_tac x = m in exI, safe) |
|
1106 |
apply (drule spec, erule impE, auto) |
|
1107 |
done |
|
1108 |
||
1109 |
text{*Now, the same theorem in terms of NS limit *} |
|
15360 | 1110 |
lemma Bmonoseq_NSLIMSEQ: "\<forall>n \<ge> m. X n = X m ==> \<exists>L. (X ----NS> L)" |
15082 | 1111 |
by (auto dest!: Bmonoseq_LIMSEQ simp add: LIMSEQ_NSLIMSEQ_iff) |
1112 |
||
1113 |
lemma lemma_converg2: |
|
1114 |
"!!(X::nat=>real). |
|
1115 |
[| \<forall>m. X m ~= U; isLub UNIV {x. \<exists>n. X n = x} U |] ==> \<forall>m. X m < U" |
|
1116 |
apply safe |
|
1117 |
apply (drule_tac y = "X m" in isLubD2) |
|
1118 |
apply (auto dest!: order_le_imp_less_or_eq) |
|
1119 |
done |
|
1120 |
||
1121 |
lemma lemma_converg3: "!!(X ::nat=>real). \<forall>m. X m \<le> U ==> isUb UNIV {x. \<exists>n. X n = x} U" |
|
1122 |
by (rule setleI [THEN isUbI], auto) |
|
1123 |
||
1124 |
text{* FIXME: @{term "U - T < U"} is redundant *} |
|
1125 |
lemma lemma_converg4: "!!(X::nat=> real). |
|
1126 |
[| \<forall>m. X m ~= U; |
|
1127 |
isLub UNIV {x. \<exists>n. X n = x} U; |
|
1128 |
0 < T; |
|
1129 |
U + - T < U |
|
1130 |
|] ==> \<exists>m. U + -T < X m & X m < U" |
|
1131 |
apply (drule lemma_converg2, assumption) |
|
1132 |
apply (rule ccontr, simp) |
|
1133 |
apply (simp add: linorder_not_less) |
|
1134 |
apply (drule lemma_converg3) |
|
1135 |
apply (drule isLub_le_isUb, assumption) |
|
1136 |
apply (auto dest: order_less_le_trans) |
|
1137 |
done |
|
1138 |
||
1139 |
text{*A standard proof of the theorem for monotone increasing sequence*} |
|
1140 |
||
1141 |
lemma Bseq_mono_convergent: |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1142 |
"[| Bseq X; \<forall>m. \<forall>n \<ge> m. X m \<le> X n |] ==> convergent (X::nat=>real)" |
15082 | 1143 |
apply (simp add: convergent_def) |
1144 |
apply (frule Bseq_isLub, safe) |
|
1145 |
apply (case_tac "\<exists>m. X m = U", auto) |
|
1146 |
apply (blast dest: lemma_converg1 Bmonoseq_LIMSEQ) |
|
1147 |
(* second case *) |
|
1148 |
apply (rule_tac x = U in exI) |
|
1149 |
apply (subst LIMSEQ_iff, safe) |
|
1150 |
apply (frule lemma_converg2, assumption) |
|
1151 |
apply (drule lemma_converg4, auto) |
|
1152 |
apply (rule_tac x = m in exI, safe) |
|
1153 |
apply (subgoal_tac "X m \<le> X n") |
|
1154 |
prefer 2 apply blast |
|
1155 |
apply (drule_tac x=n and P="%m. X m < U" in spec, arith) |
|
1156 |
done |
|
1157 |
||
1158 |
text{*Nonstandard version of the theorem*} |
|
1159 |
||
1160 |
lemma NSBseq_mono_NSconvergent: |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1161 |
"[| NSBseq X; \<forall>m. \<forall>n \<ge> m. X m \<le> X n |] ==> NSconvergent (X::nat=>real)" |
15082 | 1162 |
by (auto intro: Bseq_mono_convergent |
1163 |
simp add: convergent_NSconvergent_iff [symmetric] |
|
1164 |
Bseq_NSBseq_iff [symmetric]) |
|
1165 |
||
1166 |
lemma Bseq_minus_iff: "Bseq (%n. -(X n)) = Bseq X" |
|
1167 |
by (simp add: Bseq_def) |
|
1168 |
||
1169 |
text{*Main monotonicity theorem*} |
|
1170 |
lemma Bseq_monoseq_convergent: "[| Bseq X; monoseq X |] ==> convergent X" |
|
1171 |
apply (simp add: monoseq_def, safe) |
|
1172 |
apply (rule_tac [2] convergent_minus_iff [THEN ssubst]) |
|
1173 |
apply (drule_tac [2] Bseq_minus_iff [THEN ssubst]) |
|
1174 |
apply (auto intro!: Bseq_mono_convergent) |
|
1175 |
done |
|
1176 |
||
20696 | 1177 |
subsubsection{*A Few More Equivalence Theorems for Boundedness*} |
15082 | 1178 |
|
1179 |
text{*alternative formulation for boundedness*} |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1180 |
lemma Bseq_iff2: "Bseq X = (\<exists>k > 0. \<exists>x. \<forall>n. norm (X(n) + -x) \<le> k)" |
15082 | 1181 |
apply (unfold Bseq_def, safe) |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1182 |
apply (rule_tac [2] x = "k + norm x" in exI) |
15360 | 1183 |
apply (rule_tac x = K in exI, simp) |
15221 | 1184 |
apply (rule exI [where x = 0], auto) |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1185 |
apply (erule order_less_le_trans, simp) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1186 |
apply (drule_tac x=n in spec, fold diff_def) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1187 |
apply (drule order_trans [OF norm_triangle_ineq2]) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1188 |
apply simp |
15082 | 1189 |
done |
1190 |
||
1191 |
text{*alternative formulation for boundedness*} |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1192 |
lemma Bseq_iff3: "Bseq X = (\<exists>k > 0. \<exists>N. \<forall>n. norm(X(n) + -X(N)) \<le> k)" |
15082 | 1193 |
apply safe |
1194 |
apply (simp add: Bseq_def, safe) |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1195 |
apply (rule_tac x = "K + norm (X N)" in exI) |
15082 | 1196 |
apply auto |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1197 |
apply (erule order_less_le_trans, simp) |
15082 | 1198 |
apply (rule_tac x = N in exI, safe) |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1199 |
apply (drule_tac x = n in spec) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1200 |
apply (rule order_trans [OF norm_triangle_ineq], simp) |
15082 | 1201 |
apply (auto simp add: Bseq_iff2) |
1202 |
done |
|
1203 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1204 |
lemma BseqI2: "(\<forall>n. k \<le> f n & f n \<le> (K::real)) ==> Bseq f" |
15082 | 1205 |
apply (simp add: Bseq_def) |
15221 | 1206 |
apply (rule_tac x = " (\<bar>k\<bar> + \<bar>K\<bar>) + 1" in exI, auto) |
20217
25b068a99d2b
linear arithmetic splits certain operators (e.g. min, max, abs)
webertj
parents:
19765
diff
changeset
|
1207 |
apply (drule_tac x = n in spec, arith) |
15082 | 1208 |
done |
1209 |
||
1210 |
||
20696 | 1211 |
subsection {* Cauchy Sequences *} |
15082 | 1212 |
|
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1213 |
lemma CauchyI: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1214 |
"(\<And>e. 0 < e \<Longrightarrow> \<exists>M. \<forall>m\<ge>M. \<forall>n\<ge>M. norm (X m - X n) < e) \<Longrightarrow> Cauchy X" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1215 |
by (simp add: Cauchy_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1216 |
|
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1217 |
lemma CauchyD: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1218 |
"\<lbrakk>Cauchy X; 0 < e\<rbrakk> \<Longrightarrow> \<exists>M. \<forall>m\<ge>M. \<forall>n\<ge>M. norm (X m - X n) < e" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1219 |
by (simp add: Cauchy_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1220 |
|
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1221 |
lemma NSCauchyI: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1222 |
"(\<And>M N. \<lbrakk>M \<in> HNatInfinite; N \<in> HNatInfinite\<rbrakk> \<Longrightarrow> starfun X M \<approx> starfun X N) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1223 |
\<Longrightarrow> NSCauchy X" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1224 |
by (simp add: NSCauchy_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1225 |
|
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1226 |
lemma NSCauchyD: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1227 |
"\<lbrakk>NSCauchy X; M \<in> HNatInfinite; N \<in> HNatInfinite\<rbrakk> |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1228 |
\<Longrightarrow> starfun X M \<approx> starfun X N" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1229 |
by (simp add: NSCauchy_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1230 |
|
20696 | 1231 |
subsubsection{*Equivalence Between NS and Standard*} |
1232 |
||
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1233 |
lemma Cauchy_NSCauchy: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1234 |
assumes X: "Cauchy X" shows "NSCauchy X" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1235 |
proof (rule NSCauchyI) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1236 |
fix M assume M: "M \<in> HNatInfinite" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1237 |
fix N assume N: "N \<in> HNatInfinite" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1238 |
have "starfun X M - starfun X N \<in> Infinitesimal" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1239 |
proof (rule InfinitesimalI2) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1240 |
fix r :: real assume r: "0 < r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1241 |
from CauchyD [OF X r] |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1242 |
obtain k where "\<forall>m\<ge>k. \<forall>n\<ge>k. norm (X m - X n) < r" .. |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1243 |
hence "\<forall>m\<ge>star_of k. \<forall>n\<ge>star_of k. |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1244 |
hnorm (starfun X m - starfun X n) < star_of r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1245 |
by transfer |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1246 |
thus "hnorm (starfun X M - starfun X N) < star_of r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1247 |
using M N by (simp add: star_of_le_HNatInfinite) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1248 |
qed |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1249 |
thus "starfun X M \<approx> starfun X N" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1250 |
by (unfold approx_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1251 |
qed |
15082 | 1252 |
|
20751
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1253 |
lemma NSCauchy_Cauchy: |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1254 |
assumes X: "NSCauchy X" shows "Cauchy X" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1255 |
proof (rule CauchyI) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1256 |
fix r::real assume r: "0 < r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1257 |
have "\<exists>k. \<forall>m\<ge>k. \<forall>n\<ge>k. hnorm (starfun X m - starfun X n) < star_of r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1258 |
proof (intro exI allI impI) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1259 |
fix M assume "whn \<le> M" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1260 |
with HNatInfinite_whn have M: "M \<in> HNatInfinite" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1261 |
by (rule HNatInfinite_upward_closed) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1262 |
fix N assume "whn \<le> N" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1263 |
with HNatInfinite_whn have N: "N \<in> HNatInfinite" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1264 |
by (rule HNatInfinite_upward_closed) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1265 |
from X M N have "starfun X M \<approx> starfun X N" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1266 |
by (rule NSCauchyD) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1267 |
hence "starfun X M - starfun X N \<in> Infinitesimal" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1268 |
by (unfold approx_def) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1269 |
thus "hnorm (starfun X M - starfun X N) < star_of r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1270 |
using r by (rule InfinitesimalD2) |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1271 |
qed |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1272 |
thus "\<exists>k. \<forall>m\<ge>k. \<forall>n\<ge>k. norm (X m - X n) < r" |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1273 |
by transfer |
93271c59d211
add intro/dest rules for (NS)LIMSEQ and (NS)Cauchy; rewrite equivalence proofs using transfer
huffman
parents:
20740
diff
changeset
|
1274 |
qed |
15082 | 1275 |
|
1276 |
theorem NSCauchy_Cauchy_iff: "NSCauchy X = Cauchy X" |
|
1277 |
by (blast intro!: NSCauchy_Cauchy Cauchy_NSCauchy) |
|
1278 |
||
20696 | 1279 |
subsubsection {* Cauchy Sequences are Bounded *} |
1280 |
||
15082 | 1281 |
text{*A Cauchy sequence is bounded -- this is the standard |
1282 |
proof mechanization rather than the nonstandard proof*} |
|
1283 |
||
20563 | 1284 |
lemma lemmaCauchy: "\<forall>n \<ge> M. norm (X M - X n) < (1::real) |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1285 |
==> \<forall>n \<ge> M. norm (X n :: 'a::real_normed_vector) < 1 + norm (X M)" |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1286 |
apply (clarify, drule spec, drule (1) mp) |
20563 | 1287 |
apply (simp only: norm_minus_commute) |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1288 |
apply (drule order_le_less_trans [OF norm_triangle_ineq2]) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1289 |
apply simp |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1290 |
done |
15082 | 1291 |
|
1292 |
lemma Cauchy_Bseq: "Cauchy X ==> Bseq X" |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1293 |
apply (simp add: Cauchy_def) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1294 |
apply (drule spec, drule mp, rule zero_less_one, safe) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1295 |
apply (drule_tac x="M" in spec, simp) |
15082 | 1296 |
apply (drule lemmaCauchy) |
22608 | 1297 |
apply (rule_tac k="M" in Bseq_offset) |
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1298 |
apply (simp add: Bseq_def) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1299 |
apply (rule_tac x="1 + norm (X M)" in exI) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1300 |
apply (rule conjI, rule order_less_le_trans [OF zero_less_one], simp) |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1301 |
apply (simp add: order_less_imp_le) |
15082 | 1302 |
done |
1303 |
||
1304 |
text{*A Cauchy sequence is bounded -- nonstandard version*} |
|
1305 |
||
1306 |
lemma NSCauchy_NSBseq: "NSCauchy X ==> NSBseq X" |
|
1307 |
by (simp add: Cauchy_Bseq Bseq_NSBseq_iff [symmetric] NSCauchy_Cauchy_iff) |
|
1308 |
||
20696 | 1309 |
subsubsection {* Cauchy Sequences are Convergent *} |
15082 | 1310 |
|
20830
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1311 |
axclass banach \<subseteq> real_normed_vector |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1312 |
Cauchy_convergent: "Cauchy X \<Longrightarrow> convergent X" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1313 |
|
15082 | 1314 |
text{*Equivalence of Cauchy criterion and convergence: |
1315 |
We will prove this using our NS formulation which provides a |
|
1316 |
much easier proof than using the standard definition. We do not |
|
1317 |
need to use properties of subsequences such as boundedness, |
|
1318 |
monotonicity etc... Compare with Harrison's corresponding proof |
|
1319 |
in HOL which is much longer and more complicated. Of course, we do |
|
1320 |
not have problems which he encountered with guessing the right |
|
1321 |
instantiations for his 'espsilon-delta' proof(s) in this case |
|
1322 |
since the NS formulations do not involve existential quantifiers.*} |
|
1323 |
||
20691 | 1324 |
lemma NSconvergent_NSCauchy: "NSconvergent X \<Longrightarrow> NSCauchy X" |
1325 |
apply (simp add: NSconvergent_def NSLIMSEQ_def NSCauchy_def, safe) |
|
1326 |
apply (auto intro: approx_trans2) |
|
1327 |
done |
|
1328 |
||
1329 |
lemma convergent_Cauchy: "convergent X \<Longrightarrow> Cauchy X" |
|
1330 |
apply (rule NSconvergent_NSCauchy [THEN NSCauchy_Cauchy]) |
|
1331 |
apply (simp add: convergent_NSconvergent_iff) |
|
1332 |
done |
|
1333 |
||
20830
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1334 |
lemma real_NSCauchy_NSconvergent: |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1335 |
fixes X :: "nat \<Rightarrow> real" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1336 |
shows "NSCauchy X \<Longrightarrow> NSconvergent X" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1337 |
apply (simp add: NSconvergent_def NSLIMSEQ_def) |
15082 | 1338 |
apply (frule NSCauchy_NSBseq) |
20830
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1339 |
apply (simp add: NSBseq_def NSCauchy_def) |
15082 | 1340 |
apply (drule HNatInfinite_whn [THEN [2] bspec]) |
1341 |
apply (drule HNatInfinite_whn [THEN [2] bspec]) |
|
1342 |
apply (auto dest!: st_part_Ex simp add: SReal_iff) |
|
1343 |
apply (blast intro: approx_trans3) |
|
1344 |
done |
|
1345 |
||
1346 |
text{*Standard proof for free*} |
|
20830
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1347 |
lemma real_Cauchy_convergent: |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1348 |
fixes X :: "nat \<Rightarrow> real" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1349 |
shows "Cauchy X \<Longrightarrow> convergent X" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1350 |
apply (drule Cauchy_NSCauchy [THEN real_NSCauchy_NSconvergent]) |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1351 |
apply (erule convergent_NSconvergent_iff [THEN iffD2]) |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1352 |
done |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1353 |
|
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1354 |
instance real :: banach |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1355 |
by intro_classes (rule real_Cauchy_convergent) |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1356 |
|
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1357 |
lemma NSCauchy_NSconvergent: |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1358 |
fixes X :: "nat \<Rightarrow> 'a::banach" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1359 |
shows "NSCauchy X \<Longrightarrow> NSconvergent X" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1360 |
apply (drule NSCauchy_Cauchy [THEN Cauchy_convergent]) |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1361 |
apply (erule convergent_NSconvergent_iff [THEN iffD1]) |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1362 |
done |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1363 |
|
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1364 |
lemma NSCauchy_NSconvergent_iff: |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1365 |
fixes X :: "nat \<Rightarrow> 'a::banach" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1366 |
shows "NSCauchy X = NSconvergent X" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1367 |
by (fast intro: NSCauchy_NSconvergent NSconvergent_NSCauchy) |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1368 |
|
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1369 |
lemma Cauchy_convergent_iff: |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1370 |
fixes X :: "nat \<Rightarrow> 'a::banach" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1371 |
shows "Cauchy X = convergent X" |
65ba80cae6df
add axclass banach for complete normed vector spaces
huffman
parents:
20829
diff
changeset
|
1372 |
by (fast intro: Cauchy_convergent convergent_Cauchy) |
15082 | 1373 |
|
1374 |
||
20696 | 1375 |
subsection {* Power Sequences *} |
15082 | 1376 |
|
1377 |
text{*The sequence @{term "x^n"} tends to 0 if @{term "0\<le>x"} and @{term |
|
1378 |
"x<1"}. Proof will use (NS) Cauchy equivalence for convergence and |
|
1379 |
also fact that bounded and monotonic sequence converges.*} |
|
1380 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1381 |
lemma Bseq_realpow: "[| 0 \<le> (x::real); x \<le> 1 |] ==> Bseq (%n. x ^ n)" |
15082 | 1382 |
apply (simp add: Bseq_def) |
1383 |
apply (rule_tac x = 1 in exI) |
|
1384 |
apply (simp add: power_abs) |
|
1385 |
apply (auto dest: power_mono intro: order_less_imp_le simp add: abs_if) |
|
1386 |
done |
|
1387 |
||
1388 |
lemma monoseq_realpow: "[| 0 \<le> x; x \<le> 1 |] ==> monoseq (%n. x ^ n)" |
|
1389 |
apply (clarify intro!: mono_SucI2) |
|
1390 |
apply (cut_tac n = n and N = "Suc n" and a = x in power_decreasing, auto) |
|
1391 |
done |
|
1392 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1393 |
lemma convergent_realpow: |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1394 |
"[| 0 \<le> (x::real); x \<le> 1 |] ==> convergent (%n. x ^ n)" |
15082 | 1395 |
by (blast intro!: Bseq_monoseq_convergent Bseq_realpow monoseq_realpow) |
1396 |
||
1397 |
text{* We now use NS criterion to bring proof of theorem through *} |
|
1398 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1399 |
lemma NSLIMSEQ_realpow_zero: |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1400 |
"[| 0 \<le> (x::real); x < 1 |] ==> (%n. x ^ n) ----NS> 0" |
15082 | 1401 |
apply (simp add: NSLIMSEQ_def) |
1402 |
apply (auto dest!: convergent_realpow simp add: convergent_NSconvergent_iff) |
|
1403 |
apply (frule NSconvergentD) |
|
17318
bc1c75855f3d
starfun, starset, and other functions on NS types are now polymorphic;
huffman
parents:
17299
diff
changeset
|
1404 |
apply (auto simp add: NSLIMSEQ_def NSCauchy_NSconvergent_iff [symmetric] NSCauchy_def starfun_pow) |
15082 | 1405 |
apply (frule HNatInfinite_add_one) |
1406 |
apply (drule bspec, assumption) |
|
1407 |
apply (drule bspec, assumption) |
|
1408 |
apply (drule_tac x = "N + (1::hypnat) " in bspec, assumption) |
|
1409 |
apply (simp add: hyperpow_add) |
|
21810
b2d23672b003
generalized some lemmas; removed redundant lemmas; cleaned up some proofs
huffman
parents:
21404
diff
changeset
|
1410 |
apply (drule approx_mult_subst_star_of, assumption) |
15082 | 1411 |
apply (drule approx_trans3, assumption) |
17318
bc1c75855f3d
starfun, starset, and other functions on NS types are now polymorphic;
huffman
parents:
17299
diff
changeset
|
1412 |
apply (auto simp del: star_of_mult simp add: star_of_mult [symmetric]) |
15082 | 1413 |
done |
1414 |
||
1415 |
text{* standard version *} |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1416 |
lemma LIMSEQ_realpow_zero: |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1417 |
"[| 0 \<le> (x::real); x < 1 |] ==> (%n. x ^ n) ----> 0" |
15082 | 1418 |
by (simp add: NSLIMSEQ_realpow_zero LIMSEQ_NSLIMSEQ_iff) |
1419 |
||
20685
fee8c75e3b5d
added lemmas about LIMSEQ and norm; simplified some proofs
huffman
parents:
20682
diff
changeset
|
1420 |
lemma LIMSEQ_power_zero: |
fee8c75e3b5d
added lemmas about LIMSEQ and norm; simplified some proofs
huffman
parents:
20682
diff
changeset
|
1421 |
fixes x :: "'a::{real_normed_div_algebra,recpower}" |
fee8c75e3b5d
added lemmas about LIMSEQ and norm; simplified some proofs
huffman
parents:
20682
diff
changeset
|
1422 |
shows "norm x < 1 \<Longrightarrow> (\<lambda>n. x ^ n) ----> 0" |
fee8c75e3b5d
added lemmas about LIMSEQ and norm; simplified some proofs
huffman
parents:
20682
diff
changeset
|
1423 |
apply (drule LIMSEQ_realpow_zero [OF norm_ge_zero]) |
fee8c75e3b5d
added lemmas about LIMSEQ and norm; simplified some proofs
huffman
parents:
20682
diff
changeset
|
1424 |
apply (simp add: norm_power [symmetric] LIMSEQ_norm_zero) |
fee8c75e3b5d
added lemmas about LIMSEQ and norm; simplified some proofs
huffman
parents:
20682
diff
changeset
|
1425 |
done |
fee8c75e3b5d
added lemmas about LIMSEQ and norm; simplified some proofs
huffman
parents:
20682
diff
changeset
|
1426 |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1427 |
lemma LIMSEQ_divide_realpow_zero: |
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1428 |
"1 < (x::real) ==> (%n. a / (x ^ n)) ----> 0" |
15082 | 1429 |
apply (cut_tac a = a and x1 = "inverse x" in |
1430 |
LIMSEQ_mult [OF LIMSEQ_const LIMSEQ_realpow_zero]) |
|
1431 |
apply (auto simp add: divide_inverse power_inverse) |
|
1432 |
apply (simp add: inverse_eq_divide pos_divide_less_eq) |
|
1433 |
done |
|
1434 |
||
15102 | 1435 |
text{*Limit of @{term "c^n"} for @{term"\<bar>c\<bar> < 1"}*} |
15082 | 1436 |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1437 |
lemma LIMSEQ_rabs_realpow_zero: "\<bar>c\<bar> < (1::real) ==> (%n. \<bar>c\<bar> ^ n) ----> 0" |
20685
fee8c75e3b5d
added lemmas about LIMSEQ and norm; simplified some proofs
huffman
parents:
20682
diff
changeset
|
1438 |
by (rule LIMSEQ_realpow_zero [OF abs_ge_zero]) |
15082 | 1439 |
|
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1440 |
lemma NSLIMSEQ_rabs_realpow_zero: "\<bar>c\<bar> < (1::real) ==> (%n. \<bar>c\<bar> ^ n) ----NS> 0" |
15082 | 1441 |
by (simp add: LIMSEQ_rabs_realpow_zero LIMSEQ_NSLIMSEQ_iff [symmetric]) |
1442 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1443 |
lemma LIMSEQ_rabs_realpow_zero2: "\<bar>c\<bar> < (1::real) ==> (%n. c ^ n) ----> 0" |
15082 | 1444 |
apply (rule LIMSEQ_rabs_zero [THEN iffD1]) |
1445 |
apply (auto intro: LIMSEQ_rabs_realpow_zero simp add: power_abs) |
|
1446 |
done |
|
1447 |
||
20552
2c31dd358c21
generalized types of many constants to work over arbitrary vector spaces;
huffman
parents:
20408
diff
changeset
|
1448 |
lemma NSLIMSEQ_rabs_realpow_zero2: "\<bar>c\<bar> < (1::real) ==> (%n. c ^ n) ----NS> 0" |
15082 | 1449 |
by (simp add: LIMSEQ_rabs_realpow_zero2 LIMSEQ_NSLIMSEQ_iff [symmetric]) |
1450 |
||
1451 |
(***--------------------------------------------------------------- |
|
1452 |
Theorems proved by Harrison in HOL that we do not need |
|
1453 |
in order to prove equivalence between Cauchy criterion |
|
1454 |
and convergence: |
|
1455 |
-- Show that every sequence contains a monotonic subsequence |
|
1456 |
Goal "\<exists>f. subseq f & monoseq (%n. s (f n))" |
|
1457 |
-- Show that a subsequence of a bounded sequence is bounded |
|
1458 |
Goal "Bseq X ==> Bseq (%n. X (f n))"; |
|
1459 |
-- Show we can take subsequential terms arbitrarily far |
|
1460 |
up a sequence |
|
1461 |
Goal "subseq f ==> n \<le> f(n)"; |
|
1462 |
Goal "subseq f ==> \<exists>n. N1 \<le> n & N2 \<le> f(n)"; |
|
1463 |
---------------------------------------------------------------***) |
|
1464 |
||
10751 | 1465 |
end |