COMSEQ_3: Convergence and the Limit of Complex Sequences. Series

:: Convergence and the Limit of Complex Sequences. Series
:: by Yasunari Shidama and Artur Korni{\l}owicz
::
:: Received June 25, 1997
:: Copyright (c) 1997-2011 Association of Mizar Users

begin

Lm1: 0c = 0 + (0 * )
;

theorem :: COMSEQ_3:1

for n being Element of NAT holds
( n + 1 <> 0c & (n + 1) * <> 0c ) ;

theorem Th2: :: COMSEQ_3:2

for rseq being Real_Sequence st ( for n being Element of NAT holds rseq . n = 0 ) holds
for m being Element of NAT holds (Partial_Sums (abs rseq)) . m = 0

proof end;

theorem Th3: :: COMSEQ_3:3

for rseq being Real_Sequence st ( for n being Element of NAT holds rseq . n = 0 ) holds
rseq is absolutely_summable

proof end;

reconsider C = NAT --> 0 as Real_Sequence by FUNCOP_1:57;

Lm2: for n being Element of NAT holds C . n = 0
by FUNCOP_1:13;

registration

cluster Function-like quasi_total summable -> convergent Element of K21(K22(NAT,REAL));
coherence by SERIES_1:7;

end;

registration

cluster Function-like quasi_total absolutely_summable -> summable Element of K21(K22(NAT,REAL));
coherence by SERIES_1:40;

end;

registration

cluster Relation-like NAT -defined REAL -valued Function-like non zero total quasi_total complex-valued ext-real-valued real-valued absolutely_summable Element of K21(K22(NAT,REAL));
existence by Lm2, Th3;

end;

theorem :: COMSEQ_3:4

for rseq being Real_Sequence st rseq is convergent holds
for p being Real st 0 < p holds
ex n being Element of NAT st
for m, l being Element of NAT st n <= m & n <= l holds
abs ((rseq . m) - (rseq . l)) < p

proof end;

theorem :: COMSEQ_3:5

for rseq being Real_Sequence
for p being Real st ( for n being Element of NAT holds rseq . n <= p ) holds
for n, l being Element of NAT holds ((Partial_Sums rseq) . (n + l)) - ((Partial_Sums rseq) . n) <= p * l

proof end;

theorem :: COMSEQ_3:6

for rseq being Real_Sequence
for p being Real st ( for n being Element of NAT holds rseq . n <= p ) holds
for n being Element of NAT holds (Partial_Sums rseq) . n <= p * (n + 1)

proof end;

theorem :: COMSEQ_3:7

for rseq1, rseq2 being Real_Sequence
for m being Element of NAT
for p being Real st ( for n being Element of NAT st n <= m holds
rseq1 . n <= p * (rseq2 . n) ) holds
(Partial_Sums rseq1) . m <= p * ((Partial_Sums rseq2) . m)

proof end;

theorem :: COMSEQ_3:8

for rseq1, rseq2 being Real_Sequence
for m being Element of NAT
for p being Real st ( for n being Element of NAT st n <= m holds
rseq1 . n <= p * (rseq2 . n) ) holds
for n, l being Element of NAT st n + l <= m holds
((Partial_Sums rseq1) . (n + l)) - ((Partial_Sums rseq1) . n) <= p * (((Partial_Sums rseq2) . (n + l)) - ((Partial_Sums rseq2) . n))

proof end;

theorem :: COMSEQ_3:9

for rseq being Real_Sequence st ( for n being Element of NAT holds 0 <= rseq . n ) holds
( ( for n, m being Element of NAT st n <= m holds
abs (((Partial_Sums rseq) . m) - ((Partial_Sums rseq) . n)) = ((Partial_Sums rseq) . m) - ((Partial_Sums rseq) . n) ) & ( for n being Element of NAT holds abs ((Partial_Sums rseq) . n) = (Partial_Sums rseq) . n ) )

proof end;

theorem :: COMSEQ_3:10

for seq1, seq2 being Complex_Sequence st seq1 is convergent & seq2 is convergent & lim (seq1 - seq2) = 0c holds
lim seq1 = lim seq2

proof end;

begin

Lm3: for seq being Complex_Sequence
for n being Element of NAT holds
( |.(seq . n).| = |.seq.| . n & 0 <= |.seq.| . n )

proof end;

definition

let z be complex number ;
func z GeoSeq -> Complex_Sequence means :Def1: :: COMSEQ_3:def 1
( it . 0 = 1r & ( for n being Element of NAT holds it . (n + 1) = (it . n) * z ) );
existence

proof end;

uniqueness

proof end;

end;

:: deftheorem Def1 defines GeoSeq COMSEQ_3:def 1 :

notation

let z be complex number ;
let n be natural number ;
synonym z #N n for z |^ n;

end;

definition

let z be complex number ;
let n be natural number ;
:: original: #N
redefine func z #N n -> Element of COMPLEX equals :: COMSEQ_3:def 2
(z GeoSeq) . n;
coherence by XCMPLX_0:def 2;
compatibility

proof end;

end;

:: deftheorem defines #N COMSEQ_3:def 2 :

theorem :: COMSEQ_3:11

for z being Element of COMPLEX holds z #N 0 = 1r by COMPLEX1:def 7, NEWTON:9;

definition

let f be complex-valued Function;
set A = dom f;
deffunc H₁( set ) -> Element of REAL = Re (f . $1);
func Re f -> Function means :Def3: :: COMSEQ_3:def 3
( dom it = dom f & ( for x being set st x in dom it holds
it . x = Re (f . x) ) );
existence

proof end;

uniqueness

proof end;

deffunc H₂( set ) -> Element of REAL = Im (f . $1);
func Im f -> Function means :Def4: :: COMSEQ_3:def 4
( dom it = dom f & ( for x being set st x in dom it holds
it . x = Im (f . x) ) );
existence

proof end;

uniqueness

proof end;

end;

:: deftheorem Def3 defines Re COMSEQ_3:def 3 :

:: deftheorem Def4 defines Im COMSEQ_3:def 4 :

registration

let f be complex-valued Function;
cluster Re f -> real-valued ;
coherence

proof end;

cluster Im f -> real-valued ;
coherence

proof end;

end;

definition

let X be set ;
let f be PartFunc of X,COMPLEX;
:: original: Re
redefine func Re f -> PartFunc of X,REAL;
coherence

proof end;

:: original: Im
redefine func Im f -> PartFunc of X,REAL;
coherence

proof end;

end;

definition

let c be Complex_Sequence;
:: original: Re
redefine func Re c -> Real_Sequence means :Def5: :: COMSEQ_3:def 5
for n being Element of NAT holds it . n = Re (c . n);
coherence

proof end;

compatibility

proof end;

:: original: Im
redefine func Im c -> Real_Sequence means :Def6: :: COMSEQ_3:def 6
for n being Element of NAT holds it . n = Im (c . n);
coherence

proof end;

compatibility

proof end;

end;

:: deftheorem Def5 defines Re COMSEQ_3:def 5 :

:: deftheorem Def6 defines Im COMSEQ_3:def 6 :

theorem Th12: :: COMSEQ_3:12

for z being Element of COMPLEX holds |.z.| <= (abs (Re z)) + (abs (Im z))

proof end;

theorem Th13: :: COMSEQ_3:13

for z being Element of COMPLEX holds
( abs (Re z) <= |.z.| & abs (Im z) <= |.z.| )

proof end;

theorem Th14: :: COMSEQ_3:14

for seq1, seq2 being Complex_Sequence st Re seq1 = Re seq2 & Im seq1 = Im seq2 holds
seq1 = seq2

proof end;

theorem Th15: :: COMSEQ_3:15

for seq1, seq2 being Complex_Sequence holds
( (Re seq1) + (Re seq2) = Re (seq1 + seq2) & (Im seq1) + (Im seq2) = Im (seq1 + seq2) )

proof end;

theorem Th16: :: COMSEQ_3:16

for seq being Complex_Sequence holds
( - (Re seq) = Re (- seq) & - (Im seq) = Im (- seq) )

proof end;

theorem Th17: :: COMSEQ_3:17

for r being Real
for z being Element of COMPLEX holds
( r * (Re z) = Re (r * z) & r * (Im z) = Im (r * z) )

proof end;

theorem Th18: :: COMSEQ_3:18

for seq1, seq2 being Complex_Sequence holds
( (Re seq1) - (Re seq2) = Re (seq1 - seq2) & (Im seq1) - (Im seq2) = Im (seq1 - seq2) )

proof end;

theorem :: COMSEQ_3:19

for seq being Complex_Sequence
for r being Real holds
( r (#) (Re seq) = Re (r (#) seq) & r (#) (Im seq) = Im (r (#) seq) )

proof end;

theorem :: COMSEQ_3:20

for seq being Complex_Sequence
for z being Element of COMPLEX holds
( Re (z (#) seq) = ((Re z) (#) (Re seq)) - ((Im z) (#) (Im seq)) & Im (z (#) seq) = ((Re z) (#) (Im seq)) + ((Im z) (#) (Re seq)) )

proof end;

theorem :: COMSEQ_3:21

for seq1, seq2 being Complex_Sequence holds
( Re (seq1 (#) seq2) = ((Re seq1) (#) (Re seq2)) - ((Im seq1) (#) (Im seq2)) & Im (seq1 (#) seq2) = ((Re seq1) (#) (Im seq2)) + ((Im seq1) (#) (Re seq2)) )

proof end;

definition

let Nseq be increasing sequence of NAT;
let seq be Complex_Sequence;
:: original: *
redefine func seq * Nseq -> Complex_Sequence;
coherence

proof end;

end;

theorem Th22: :: COMSEQ_3:22

for seq being Complex_Sequence
for Nseq being increasing sequence of NAT holds
( Re (seq * Nseq) = (Re seq) * Nseq & Im (seq * Nseq) = (Im seq) * Nseq )

proof end;

theorem Th23: :: COMSEQ_3:23

for seq being Complex_Sequence
for k being Element of NAT holds
( (Re seq) ^\ k = Re (seq ^\ k) & (Im seq) ^\ k = Im (seq ^\ k) )

proof end;

definition

canceled;
canceled;
canceled;
let seq be Complex_Sequence;
func Sum seq -> Element of COMPLEX equals :: COMSEQ_3:def 10
lim (Partial_Sums seq);
coherence ;

end;

:: deftheorem COMSEQ_3:def 7 :

:: deftheorem COMSEQ_3:def 8 :

:: deftheorem COMSEQ_3:def 9 :

:: deftheorem defines Sum COMSEQ_3:def 10 :

theorem Th24: :: COMSEQ_3:24

for seq being Complex_Sequence st ( for n being Element of NAT holds seq . n = 0c ) holds
for m being Element of NAT holds (Partial_Sums seq) . m = 0c

proof end;

theorem Th25: :: COMSEQ_3:25

for seq being Complex_Sequence st ( for n being Element of NAT holds seq . n = 0c ) holds
for m being Element of NAT holds (Partial_Sums |.seq.|) . m = 0

proof end;

theorem Th26: :: COMSEQ_3:26

for seq being Complex_Sequence holds
( Partial_Sums (Re seq) = Re (Partial_Sums seq) & Partial_Sums (Im seq) = Im (Partial_Sums seq) )

proof end;

theorem Th27: :: COMSEQ_3:27

for seq1, seq2 being Complex_Sequence holds (Partial_Sums seq1) + (Partial_Sums seq2) = Partial_Sums (seq1 + seq2) by SERIES_1:8;

theorem Th28: :: COMSEQ_3:28

for seq1, seq2 being Complex_Sequence holds (Partial_Sums seq1) - (Partial_Sums seq2) = Partial_Sums (seq1 - seq2)

proof end;

theorem Th29: :: COMSEQ_3:29

for seq being Complex_Sequence
for z being complex number holds Partial_Sums (z (#) seq) = z (#) (Partial_Sums seq)

proof end;

theorem :: COMSEQ_3:30

for seq being Complex_Sequence
for k being Element of NAT holds |.((Partial_Sums seq) . k).| <= (Partial_Sums |.seq.|) . k

proof end;

theorem Th31: :: COMSEQ_3:31

for seq being Complex_Sequence
for m, n being Element of NAT holds |.(((Partial_Sums seq) . m) - ((Partial_Sums seq) . n)).| <= abs (((Partial_Sums |.seq.|) . m) - ((Partial_Sums |.seq.|) . n))

proof end;

theorem Th32: :: COMSEQ_3:32

for seq being Complex_Sequence
for k being Element of NAT holds
( (Partial_Sums (Re seq)) ^\ k = Re ((Partial_Sums seq) ^\ k) & (Partial_Sums (Im seq)) ^\ k = Im ((Partial_Sums seq) ^\ k) )

proof end;

theorem :: COMSEQ_3:33

for seq1, seq being Complex_Sequence st ( for n being Element of NAT holds seq1 . n = seq . 0 ) holds
Partial_Sums (seq ^\ 1) = ((Partial_Sums seq) ^\ 1) - seq1

proof end;

theorem Th34: :: COMSEQ_3:34

for seq being Complex_Sequence holds Partial_Sums |.seq.| is non-decreasing

proof end;

registration

let seq be Complex_Sequence;
cluster Partial_Sums |.seq.| -> non-decreasing ;
coherence by Th34;

end;

theorem :: COMSEQ_3:35

for seq1, seq2 being Complex_Sequence
for m being Element of NAT st ( for n being Element of NAT st n <= m holds
seq1 . n = seq2 . n ) holds
(Partial_Sums seq1) . m = (Partial_Sums seq2) . m

proof end;

theorem Th36: :: COMSEQ_3:36

for z being Element of COMPLEX st 1r <> z holds
for n being Element of NAT holds (Partial_Sums (z GeoSeq)) . n = (1r - (z #N (n + 1))) / (1r - z)

proof end;

theorem Th37: :: COMSEQ_3:37

for seq being Complex_Sequence
for z being Element of COMPLEX st z <> 1r & ( for n being Element of NAT holds seq . (n + 1) = z * (seq . n) ) holds
for n being Element of NAT holds (Partial_Sums seq) . n = (seq . 0) * ((1r - (z #N (n + 1))) / (1r - z))

proof end;

begin

theorem Th38: :: COMSEQ_3:38

for a, b being Real_Sequence
for c being Complex_Sequence st ( for n being Element of NAT holds
( Re (c . n) = a . n & Im (c . n) = b . n ) ) holds
( ( a is convergent & b is convergent ) iff c is convergent )

proof end;

theorem Th39: :: COMSEQ_3:39

for a, b being convergent Real_Sequence
for c being Complex_Sequence st ( for n being Element of NAT holds
( Re (c . n) = a . n & Im (c . n) = b . n ) ) holds
( c is convergent & lim c = (lim a) + ((lim b) * ) )

proof end;

theorem Th40: :: COMSEQ_3:40

for a, b being Real_Sequence
for c being convergent Complex_Sequence st ( for n being Element of NAT holds
( Re (c . n) = a . n & Im (c . n) = b . n ) ) holds
( a is convergent & b is convergent & lim a = Re (lim c) & lim b = Im (lim c) )

proof end;

theorem Th41: :: COMSEQ_3:41

for c being convergent Complex_Sequence holds
( Re c is convergent & Im c is convergent & lim (Re c) = Re (lim c) & lim (Im c) = Im (lim c) )

proof end;

registration

let c be convergent Complex_Sequence;
cluster Re c -> convergent Real_Sequence;
coherence by Th41;
cluster Im c -> convergent Real_Sequence;
coherence by Th41;

end;

theorem Th42: :: COMSEQ_3:42

for c being Complex_Sequence st Re c is convergent & Im c is convergent holds
( c is convergent & Re (lim c) = lim (Re c) & Im (lim c) = lim (Im c) )

proof end;

theorem Th43: :: COMSEQ_3:43

for seq being Complex_Sequence
for z being Element of COMPLEX st 0 < |.z.| & |.z.| < 1 & seq . 0 = z & ( for n being Element of NAT holds seq . (n + 1) = (seq . n) * z ) holds
( seq is convergent & lim seq = 0c )

proof end;

theorem Th44: :: COMSEQ_3:44

for seq being Complex_Sequence
for z being Element of COMPLEX st |.z.| < 1 & ( for n being Element of NAT holds seq . n = z #N (n + 1) ) holds
( seq is convergent & lim seq = 0c )

proof end;

theorem :: COMSEQ_3:45

for seq being Complex_Sequence
for r being Real st r > 0 & ex m being Element of NAT st
for n being Element of NAT st n >= m holds
|.(seq . n).| >= r & |.seq.| is convergent holds
lim |.seq.| <> 0

proof end;

theorem Th46: :: COMSEQ_3:46

for seq being Complex_Sequence holds
( seq is convergent iff for p being Real st 0 < p holds
ex n being Element of NAT st
for m being Element of NAT st n <= m holds
|.((seq . m) - (seq . n)).| < p )

proof end;

theorem :: COMSEQ_3:47

for seq being Complex_Sequence st seq is convergent holds
for p being Real st 0 < p holds
ex n being Element of NAT st
for m, l being Element of NAT st n <= m & n <= l holds
|.((seq . m) - (seq . l)).| < p

proof end;

theorem :: COMSEQ_3:48

for rseq being Real_Sequence
for seq being Complex_Sequence st ( for n being Element of NAT holds |.(seq . n).| <= rseq . n ) & rseq is convergent & lim rseq = 0 holds
( seq is convergent & lim seq = 0c )

proof end;

begin

theorem :: COMSEQ_3:49

for seq, seq1 being Complex_Sequence st seq is subsequence of seq1 holds
( Re seq is subsequence of Re seq1 & Im seq is subsequence of Im seq1 )

proof end;

theorem :: COMSEQ_3:50

canceled;

theorem :: COMSEQ_3:51

for seq being Complex_Sequence st seq is bounded holds
ex seq1 being Complex_Sequence st
( seq1 is subsequence of seq & seq1 is convergent )

proof end;

definition

canceled;
let seq be Complex_Sequence;
attr seq is summable means :Def12: :: COMSEQ_3:def 12
Partial_Sums seq is convergent ;

end;

:: deftheorem COMSEQ_3:def 11 :

:: deftheorem Def12 defines summable COMSEQ_3:def 12 :

set D = NAT --> 0c;

registration

cluster Relation-like NAT -defined COMPLEX -valued Function-like non zero total quasi_total complex-valued summable Element of K21(K22(NAT,COMPLEX));
existence

proof end;

end;

registration

let seq be summable Complex_Sequence;
cluster Partial_Sums seq -> convergent ;
coherence by Def12;

end;

definition

let seq be Complex_Sequence;
attr seq is absolutely_summable means :Def13: :: COMSEQ_3:def 13
|.seq.| is summable ;

end;

:: deftheorem Def13 defines absolutely_summable COMSEQ_3:def 13 :

theorem Th52: :: COMSEQ_3:52

for seq being Complex_Sequence st ( for n being Element of NAT holds seq . n = 0c ) holds
seq is absolutely_summable

proof end;

registration

cluster Relation-like NAT -defined COMPLEX -valued Function-like non zero total quasi_total complex-valued absolutely_summable Element of K21(K22(NAT,COMPLEX));
existence

proof end;

end;

registration

let seq be absolutely_summable Complex_Sequence;
cluster |.seq.| -> summable Real_Sequence;
coherence by Def13;

end;

theorem Th53: :: COMSEQ_3:53

for seq being Complex_Sequence st seq is summable holds
( seq is convergent & lim seq = 0c )

proof end;

registration

cluster Function-like quasi_total summable -> convergent Element of K21(K22(NAT,COMPLEX));
coherence by Th53;

end;

theorem Th54: :: COMSEQ_3:54

for seq being Complex_Sequence st seq is summable holds
( Re seq is summable & Im seq is summable & Sum seq = (Sum (Re seq)) + ((Sum (Im seq)) * ) )

proof end;

registration

let seq be summable Complex_Sequence;
cluster Re seq -> summable Real_Sequence;
coherence by Th54;
cluster Im seq -> summable Real_Sequence;
coherence by Th54;

end;

theorem Th55: :: COMSEQ_3:55

for seq1, seq2 being Complex_Sequence st seq1 is summable & seq2 is summable holds
( seq1 + seq2 is summable & Sum (seq1 + seq2) = (Sum seq1) + (Sum seq2) )

proof end;

theorem Th56: :: COMSEQ_3:56

for seq1, seq2 being Complex_Sequence st seq1 is summable & seq2 is summable holds
( seq1 - seq2 is summable & Sum (seq1 - seq2) = (Sum seq1) - (Sum seq2) )

proof end;

registration

let seq1, seq2 be summable Complex_Sequence;
cluster seq1 + seq2 -> summable Complex_Sequence;
coherence by Th55;
cluster seq1 - seq2 -> summable Complex_Sequence;
coherence by Th56;

end;

theorem Th57: :: COMSEQ_3:57

for seq being Complex_Sequence st seq is summable holds
for z being complex number holds
( z (#) seq is summable & Sum (z (#) seq) = z * (Sum seq) )

proof end;

registration

let z be Element of COMPLEX ;
let seq be summable Complex_Sequence;
cluster z (#) seq -> summable Complex_Sequence;
coherence by Th57;

end;

theorem Th58: :: COMSEQ_3:58

for seq being Complex_Sequence st Re seq is summable & Im seq is summable holds
( seq is summable & Sum seq = (Sum (Re seq)) + ((Sum (Im seq)) * ) )

proof end;

theorem Th59: :: COMSEQ_3:59

for seq being Complex_Sequence st seq is summable holds
for n being Element of NAT holds seq ^\ n is summable

proof end;

registration

let seq be summable Complex_Sequence;
let n be Element of NAT ;
cluster seq ^\ n -> summable ;
coherence by Th59;

end;

theorem :: COMSEQ_3:60

for seq being Complex_Sequence st ex n being Element of NAT st seq ^\ n is summable holds
seq is summable

proof end;

theorem :: COMSEQ_3:61

for seq being Complex_Sequence st seq is summable holds
for n being Element of NAT holds Sum seq = ((Partial_Sums seq) . n) + (Sum (seq ^\ (n + 1)))

proof end;

theorem Th62: :: COMSEQ_3:62

for seq being Complex_Sequence holds
( Partial_Sums |.seq.| is bounded_above iff seq is absolutely_summable )

proof end;

registration

let seq be absolutely_summable Complex_Sequence;
cluster Partial_Sums |.seq.| -> bounded_above ;
coherence by Th62;

end;

theorem Th63: :: COMSEQ_3:63

for seq being Complex_Sequence holds
( seq is summable iff for p being Real st 0 < p holds
ex n being Element of NAT st
for m being Element of NAT st n <= m holds
|.(((Partial_Sums seq) . m) - ((Partial_Sums seq) . n)).| < p )

proof end;

theorem Th64: :: COMSEQ_3:64

for seq being Complex_Sequence st seq is absolutely_summable holds
seq is summable

proof end;

registration

cluster Function-like quasi_total absolutely_summable -> summable Element of K21(K22(NAT,COMPLEX));
coherence by Th64;

end;

registration

cluster Relation-like NAT -defined COMPLEX -valued Function-like non zero total quasi_total complex-valued absolutely_summable Element of K21(K22(NAT,COMPLEX));
existence

proof end;

end;

theorem Th65: :: COMSEQ_3:65

for z being Element of COMPLEX st |.z.| < 1 holds
( z GeoSeq is summable & Sum (z GeoSeq) = 1r / (1r - z) )

proof end;

theorem :: COMSEQ_3:66

for seq being Complex_Sequence
for z being Element of COMPLEX st |.z.| < 1 & ( for n being Element of NAT holds seq . (n + 1) = z * (seq . n) ) holds
( seq is summable & Sum seq = (seq . 0) / (1r - z) )

proof end;

theorem :: COMSEQ_3:67

for rseq1 being Real_Sequence
for seq2 being Complex_Sequence st rseq1 is summable & ex m being Element of NAT st
for n being Element of NAT st m <= n holds
|.(seq2 . n).| <= rseq1 . n holds
seq2 is absolutely_summable

proof end;

theorem :: COMSEQ_3:68

for seq1, seq2 being Complex_Sequence st ( for n being Element of NAT holds
( 0 <= |.seq1.| . n & |.seq1.| . n <= |.seq2.| . n ) ) & seq2 is absolutely_summable holds
( seq1 is absolutely_summable & Sum |.seq1.| <= Sum |.seq2.| )

proof end;

theorem :: COMSEQ_3:69

for seq being Complex_Sequence st ( for n being Element of NAT holds |.seq.| . n > 0 ) & ex m being Element of NAT st
for n being Element of NAT st n >= m holds
(|.seq.| . (n + 1)) / (|.seq.| . n) >= 1 holds
not seq is absolutely_summable by SERIES_1:31;

theorem :: COMSEQ_3:70

for rseq1 being Real_Sequence
for seq being Complex_Sequence st ( for n being Element of NAT holds rseq1 . n = n -root (|.seq.| . n) ) & rseq1 is convergent & lim rseq1 < 1 holds
seq is absolutely_summable

proof end;

theorem :: COMSEQ_3:71

for rseq1 being Real_Sequence
for seq being Complex_Sequence st ( for n being Element of NAT holds rseq1 . n = n -root (|.seq.| . n) ) & ex m being Element of NAT st
for n being Element of NAT st m <= n holds
rseq1 . n >= 1 holds
not |.seq.| is summable

proof end;

theorem :: COMSEQ_3:72

for rseq1 being Real_Sequence
for seq being Complex_Sequence st ( for n being Element of NAT holds rseq1 . n = n -root (|.seq.| . n) ) & rseq1 is convergent & lim rseq1 > 1 holds
not seq is absolutely_summable

proof end;

theorem :: COMSEQ_3:73

for rseq1 being Real_Sequence
for seq being Complex_Sequence st |.seq.| is non-increasing & ( for n being Element of NAT holds rseq1 . n = (2 to_power n) * (|.seq.| . (2 to_power n)) ) holds
( seq is absolutely_summable iff rseq1 is summable )

proof end;

theorem :: COMSEQ_3:74

for seq being Complex_Sequence
for p being Real st p > 1 & ( for n being Element of NAT st n >= 1 holds
|.seq.| . n = 1 / (n to_power p) ) holds
seq is absolutely_summable

proof end;

theorem :: COMSEQ_3:75

for seq being Complex_Sequence
for p being Real st p <= 1 & ( for n being Element of NAT st n >= 1 holds
|.seq.| . n = 1 / (n to_power p) ) holds
not seq is absolutely_summable by SERIES_1:37;

theorem :: COMSEQ_3:76

for rseq1 being Real_Sequence
for seq being Complex_Sequence st ( for n being Element of NAT holds
( seq . n <> 0c & rseq1 . n = (|.seq.| . (n + 1)) / (|.seq.| . n) ) ) & rseq1 is convergent & lim rseq1 < 1 holds
seq is absolutely_summable

proof end;

theorem :: COMSEQ_3:77

for seq being Complex_Sequence st ( for n being Element of NAT holds seq . n <> 0c ) & ex m being Element of NAT st
for n being Element of NAT st n >= m holds
(|.seq.| . (n + 1)) / (|.seq.| . n) >= 1 holds
not seq is absolutely_summable

proof end;