:: SEQ_1 semantic presentation

definition
mode Real_Sequence is Function of NAT , REAL ;
end;

theorem Th1: :: SEQ_1:1
canceled;

theorem Th2: :: SEQ_1:2
canceled;

theorem Th3: :: SEQ_1:3
for f being Function holds
( f is Real_Sequence iff ( dom f = NAT & ( for x being set st x in NAT holds
f . x is real ) ) )
proof end;

theorem Th4: :: SEQ_1:4
for f being Function holds
( f is Real_Sequence iff ( dom f = NAT & ( for n being Element of NAT holds f . n is real ) ) )
proof end;

definition
let f be Relation;
attr a1 is real-yielding means :Def1: :: SEQ_1:def 1
rng f c= REAL ;
end;

:: deftheorem Def1 defines real-yielding SEQ_1:def 1 :
for f being Relation holds
( f is real-yielding iff rng f c= REAL );

registration
let C be set ;
let D be real-membered set ;
cluster -> real-yielding Relation of a1,a2;
coherence
for b1 being PartFunc of C,D holds b1 is real-yielding
proof end;
end;

registration
cluster real-yielding set ;
existence
ex b1 being Function st b1 is real-yielding
proof end;
end;

registration
let f be real-yielding Function;
let x be set ;
cluster a1 . a2 -> real ;
coherence
f . x is real
proof end;
end;

definition
let f be real-yielding Function;
let x be set ;
redefine func . as c1 . c2 -> Real;
coherence
f . x is Real
by XREAL_0:def 1;
end;

definition
let C be set ;
let D be real-membered set ;
let f be PartFunc of C,D;
let x be set ;
redefine func . as c3 . c4 -> Real;
coherence
f . x is Real
by XREAL_0:def 1;
end;

registration
let F be real-yielding Relation;
let X be set ;
cluster a1 | a2 -> real-yielding ;
coherence
F | X is real-yielding
proof end;
end;

notation
let f be PartFunc of NAT , REAL ;
synonym being_not_0 c1 for non-empty c1;
synonym c1 is_not_0 for non-empty c1;
end;

definition
let f be PartFunc of NAT , REAL ;
redefine attr a1 is non-empty means :Def2: :: SEQ_1:def 2
rng f c= REAL \ {0};
compatibility
( f is being_not_0 iff rng f c= REAL \ {0} )
proof end;
end;

:: deftheorem Def2 defines being_not_0 SEQ_1:def 2 :
for f being PartFunc of NAT , REAL holds
( f is being_not_0 iff rng f c= REAL \ {0} );

theorem Th5: :: SEQ_1:5
canceled;

theorem Th6: :: SEQ_1:6
for seq being Real_Sequence holds
( seq is being_not_0 iff for x being set st x in NAT holds
seq . x <> 0 )
proof end;

theorem Th7: :: SEQ_1:7
for seq being Real_Sequence holds
( seq is being_not_0 iff for n being Element of NAT holds seq . n <> 0 )
proof end;

theorem Th8: :: SEQ_1:8
for seq, seq1 being Real_Sequence st ( for x being set st x in NAT holds
seq . x = seq1 . x ) holds
seq = seq1
proof end;

theorem Th9: :: SEQ_1:9
canceled;

theorem Th10: :: SEQ_1:10
for r being real number ex seq being Real_Sequence st rng seq = {r}
proof end;

scheme :: SEQ_1:sch 44
s44{ F1( set ) -> real number } :
ex seq being Real_Sequence st
for n being Element of NAT holds seq . n = F1(n)
proof end;

scheme :: SEQ_1:sch 47
s47{ F1() -> non empty set , F2() -> non empty set , P1[ set , set ] } :
ex f being PartFunc of F1(),F2() st
( ( for d being Element of F1() holds
( d in dom f iff ex c being Element of F2() st P1[d,c] ) ) & ( for d being Element of F1() st d in dom f holds
P1[d,f . d] ) )
proof end;

scheme :: SEQ_1:sch 51
s51{ F1() -> non empty set , F2() -> non empty set , F3( set ) -> Element of F2(), P1[ set ] } :
ex f being PartFunc of F1(),F2() st
( ( for d being Element of F1() holds
( d in dom f iff P1[d] ) ) & ( for d being Element of F1() st d in dom f holds
f . d = F3(d) ) )
proof end;

scheme :: SEQ_1:sch 52
s52{ F1() -> set , F2() -> set , F3() -> set , F4( set ) -> set } :
for f, g being PartFunc of F1(),F2() st dom f = F3() & ( for c being Element of F1() st c in dom f holds
f . c = F4(c) ) & dom g = F3() & ( for c being Element of F1() st c in dom g holds
g . c = F4(c) ) holds
f = g
proof end;

definition
let f1 be real-yielding Function, f2 be real-yielding Function;
func c1 + c2 -> Function means :Def3: :: SEQ_1:def 3
( dom it = (dom f1) /\ (dom f2) & ( for c being set st c in dom it holds
it . c = (f1 . c) + (f2 . c) ) );
existence
ex b1 being Function st
( dom b1 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b1 holds
b1 . c = (f1 . c) + (f2 . c) ) )
proof end;
uniqueness
for b1, b2 being Function st dom b1 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b1 holds
b1 . c = (f1 . c) + (f2 . c) ) & dom b2 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b2 holds
b2 . c = (f1 . c) + (f2 . c) ) holds
b1 = b2
proof end;
commutativity
for b1 being Function
for f1, f2 being real-yielding Function st dom b1 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b1 holds
b1 . c = (f1 . c) + (f2 . c) ) holds
( dom b1 = (dom f2) /\ (dom f1) & ( for c being set st c in dom b1 holds
b1 . c = (f2 . c) + (f1 . c) ) )
;
func c1 - c2 -> Function means :Def4: :: SEQ_1:def 4
( dom it = (dom f1) /\ (dom f2) & ( for c being set st c in dom it holds
it . c = (f1 . c) - (f2 . c) ) );
existence
ex b1 being Function st
( dom b1 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b1 holds
b1 . c = (f1 . c) - (f2 . c) ) )
proof end;
uniqueness
for b1, b2 being Function st dom b1 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b1 holds
b1 . c = (f1 . c) - (f2 . c) ) & dom b2 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b2 holds
b2 . c = (f1 . c) - (f2 . c) ) holds
b1 = b2
proof end;
func c1 (#) c2 -> Function means :Def5: :: SEQ_1:def 5
( dom it = (dom f1) /\ (dom f2) & ( for c being set st c in dom it holds
it . c = (f1 . c) * (f2 . c) ) );
existence
ex b1 being Function st
( dom b1 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b1 holds
b1 . c = (f1 . c) * (f2 . c) ) )
proof end;
uniqueness
for b1, b2 being Function st dom b1 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b1 holds
b1 . c = (f1 . c) * (f2 . c) ) & dom b2 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b2 holds
b2 . c = (f1 . c) * (f2 . c) ) holds
b1 = b2
proof end;
commutativity
for b1 being Function
for f1, f2 being real-yielding Function st dom b1 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b1 holds
b1 . c = (f1 . c) * (f2 . c) ) holds
( dom b1 = (dom f2) /\ (dom f1) & ( for c being set st c in dom b1 holds
b1 . c = (f2 . c) * (f1 . c) ) )
;
end;

:: deftheorem Def3 defines + SEQ_1:def 3 :
for f1, f2 being real-yielding Function
for b3 being Function holds
( b3 = f1 + f2 iff ( dom b3 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b3 holds
b3 . c = (f1 . c) + (f2 . c) ) ) );

:: deftheorem Def4 defines - SEQ_1:def 4 :
for f1, f2 being real-yielding Function
for b3 being Function holds
( b3 = f1 - f2 iff ( dom b3 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b3 holds
b3 . c = (f1 . c) - (f2 . c) ) ) );

:: deftheorem Def5 defines (#) SEQ_1:def 5 :
for f1, f2 being real-yielding Function
for b3 being Function holds
( b3 = f1 (#) f2 iff ( dom b3 = (dom f1) /\ (dom f2) & ( for c being set st c in dom b3 holds
b3 . c = (f1 . c) * (f2 . c) ) ) );

registration
let f1 be real-yielding Function, f2 be real-yielding Function;
cluster a1 + a2 -> real-yielding ;
coherence
f1 + f2 is real-yielding
proof end;
cluster a1 - a2 -> real-yielding ;
coherence
f1 - f2 is real-yielding
proof end;
cluster a1 (#) a2 -> real-yielding ;
coherence
f1 (#) f2 is real-yielding
proof end;
end;

definition
let C be set ;
let D be real-membered set ;
let f1 be PartFunc of C,D, f2 be PartFunc of C,D;
redefine func + as c3 + c4 -> PartFunc of a1, REAL ;
coherence
f1 + f2 is PartFunc of C, REAL
proof end;
redefine func - as c3 - c4 -> PartFunc of a1, REAL ;
coherence
f1 - f2 is PartFunc of C, REAL
proof end;
redefine func (#) as c3 (#) c4 -> PartFunc of a1, REAL ;
coherence
f1 (#) f2 is PartFunc of C, REAL
proof end;
end;

theorem Th11: :: SEQ_1:11
for seq, seq1, seq2 being Real_Sequence holds
( seq = seq1 + seq2 iff for n being Element of NAT holds seq . n = (seq1 . n) + (seq2 . n) )
proof end;

theorem Th12: :: SEQ_1:12
for seq, seq1, seq2 being Real_Sequence holds
( seq = seq1 (#) seq2 iff for n being Element of NAT holds seq . n = (seq1 . n) * (seq2 . n) )
proof end;

definition
let seq1 be Real_Sequence;
let seq2 be Real_Sequence;
redefine func + as c1 + c2 -> Real_Sequence;
coherence
seq1 + seq2 is Real_Sequence
proof end;
redefine func - as c1 - c2 -> Real_Sequence;
coherence
seq1 - seq2 is Real_Sequence
proof end;
redefine func (#) as c1 (#) c2 -> Real_Sequence;
coherence
seq1 (#) seq2 is Real_Sequence
proof end;
end;

definition
let f be real-yielding Function;
let r be real number ;
func c2 (#) c1 -> Function means :Def6: :: SEQ_1:def 6
( dom it = dom f & ( for c being set st c in dom it holds
it . c = r * (f . c) ) );
existence
ex b1 being Function st
( dom b1 = dom f & ( for c being set st c in dom b1 holds
b1 . c = r * (f . c) ) )
proof end;
uniqueness
for b1, b2 being Function st dom b1 = dom f & ( for c being set st c in dom b1 holds
b1 . c = r * (f . c) ) & dom b2 = dom f & ( for c being set st c in dom b2 holds
b2 . c = r * (f . c) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def6 defines (#) SEQ_1:def 6 :
for f being real-yielding Function
for r being real number
for b3 being Function holds
( b3 = r (#) f iff ( dom b3 = dom f & ( for c being set st c in dom b3 holds
b3 . c = r * (f . c) ) ) );

registration
let r be real number ;
let f be real-yielding Function;
cluster a1 (#) a2 -> real-yielding ;
coherence
r (#) f is real-yielding
proof end;
end;

definition
let C be set ;
let D be real-membered set ;
let f be PartFunc of C,D;
let r be real number ;
redefine func (#) as c4 (#) c3 -> PartFunc of a1, REAL ;
coherence
r (#) f is PartFunc of C, REAL
proof end;
end;

definition
let seq be Real_Sequence;
let r be real number ;
redefine func (#) as c2 (#) c1 -> Real_Sequence;
coherence
r (#) seq is Real_Sequence
proof end;
end;

theorem Th13: :: SEQ_1:13
for r being real number
for seq1, seq2 being Real_Sequence holds
( seq1 = r (#) seq2 iff for n being Element of NAT holds seq1 . n = r * (seq2 . n) )
proof end;

definition
let f be real-yielding Function;
func - c1 -> Function means :Def7: :: SEQ_1:def 7
( dom it = dom f & ( for c being set st c in dom it holds
it . c = - (f . c) ) );
existence
ex b1 being Function st
( dom b1 = dom f & ( for c being set st c in dom b1 holds
b1 . c = - (f . c) ) )
proof end;
uniqueness
for b1, b2 being Function st dom b1 = dom f & ( for c being set st c in dom b1 holds
b1 . c = - (f . c) ) & dom b2 = dom f & ( for c being set st c in dom b2 holds
b2 . c = - (f . c) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def7 defines - SEQ_1:def 7 :
for f being real-yielding Function
for b2 being Function holds
( b2 = - f iff ( dom b2 = dom f & ( for c being set st c in dom b2 holds
b2 . c = - (f . c) ) ) );

registration
let f be real-yielding Function;
cluster - a1 -> real-yielding ;
coherence
- f is real-yielding
proof end;
end;

definition
let C be set ;
let D be real-membered set ;
let f be PartFunc of C,D;
redefine func - as - c3 -> PartFunc of a1, REAL ;
coherence
- f is PartFunc of C, REAL
proof end;
end;

definition
let seq be Real_Sequence;
redefine func - as - c1 -> Real_Sequence;
coherence
- seq is Real_Sequence
proof end;
end;

theorem Th14: :: SEQ_1:14
for seq1, seq2 being Real_Sequence holds
( seq1 = - seq2 iff for n being Element of NAT holds seq1 . n = - (seq2 . n) )
proof end;

theorem Th15: :: SEQ_1:15
for seq1, seq2 being Real_Sequence holds seq1 - seq2 = seq1 + (- seq2)
proof end;

definition
let seq be Real_Sequence;
func c1 " -> Real_Sequence means :Def8: :: SEQ_1:def 8
for n being Element of NAT holds it . n = (seq . n) " ;
existence
ex b1 being Real_Sequence st
for n being Element of NAT holds b1 . n = (seq . n) "
proof end;
uniqueness
for b1, b2 being Real_Sequence st ( for n being Element of NAT holds b1 . n = (seq . n) " ) & ( for n being Element of NAT holds b2 . n = (seq . n) " ) holds
b1 = b2
proof end;
end;

:: deftheorem Def8 defines " SEQ_1:def 8 :
for seq being Real_Sequence
for b2 being Real_Sequence holds
( b2 = seq " iff for n being Element of NAT holds b2 . n = (seq . n) " );

definition
let seq1 be Real_Sequence;
let seq be Real_Sequence;
func c1 /" c2 -> Real_Sequence equals :: SEQ_1:def 9
seq1 (#) (seq " );
correctness
coherence
seq1 (#) (seq " ) is Real_Sequence
;
;
end;

:: deftheorem Def9 defines /" SEQ_1:def 9 :
for seq1, seq being Real_Sequence holds seq1 /" seq = seq1 (#) (seq " );

definition
let f be real-yielding Function;
func abs c1 -> Function means :Def10: :: SEQ_1:def 10
( dom it = dom f & ( for c being set st c in dom it holds
it . c = abs (f . c) ) );
existence
ex b1 being Function st
( dom b1 = dom f & ( for c being set st c in dom b1 holds
b1 . c = abs (f . c) ) )
proof end;
uniqueness
for b1, b2 being Function st dom b1 = dom f & ( for c being set st c in dom b1 holds
b1 . c = abs (f . c) ) & dom b2 = dom f & ( for c being set st c in dom b2 holds
b2 . c = abs (f . c) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def10 defines abs SEQ_1:def 10 :
for f being real-yielding Function
for b2 being Function holds
( b2 = abs f iff ( dom b2 = dom f & ( for c being set st c in dom b2 holds
b2 . c = abs (f . c) ) ) );

registration
let f be real-yielding Function;
cluster abs a1 -> real-yielding ;
coherence
abs f is real-yielding
proof end;
end;

definition
let C be set ;
let D be real-membered set ;
let f be PartFunc of C,D;
redefine func abs as abs c3 -> PartFunc of a1, REAL ;
coherence
abs f is PartFunc of C, REAL
proof end;
end;

definition
let seq be Real_Sequence;
redefine func abs as abs c1 -> Real_Sequence;
coherence
abs seq is Real_Sequence
proof end;
end;

theorem Th16: :: SEQ_1:16
for seq1, seq being Real_Sequence holds
( seq1 = abs seq iff for n being Element of NAT holds seq1 . n = abs (seq . n) )
proof end;

theorem Th17: :: SEQ_1:17
canceled;

theorem Th18: :: SEQ_1:18
canceled;

theorem Th19: :: SEQ_1:19
canceled;

theorem Th20: :: SEQ_1:20
for seq1, seq2, seq3 being Real_Sequence holds (seq1 + seq2) + seq3 = seq1 + (seq2 + seq3)
proof end;

theorem Th21: :: SEQ_1:21
canceled;

theorem Th22: :: SEQ_1:22
for seq1, seq2, seq3 being Real_Sequence holds (seq1 (#) seq2) (#) seq3 = seq1 (#) (seq2 (#) seq3)
proof end;

theorem Th23: :: SEQ_1:23
for seq1, seq2, seq3 being Real_Sequence holds (seq1 + seq2) (#) seq3 = (seq1 (#) seq3) + (seq2 (#) seq3)
proof end;

theorem Th24: :: SEQ_1:24
for seq3, seq1, seq2 being Real_Sequence holds seq3 (#) (seq1 + seq2) = (seq3 (#) seq1) + (seq3 (#) seq2) by ;

theorem Th25: :: SEQ_1:25
for seq being Real_Sequence holds - seq = (- 1) (#) seq
proof end;

theorem Th26: :: SEQ_1:26
for r being real number
for seq1, seq2 being Real_Sequence holds r (#) (seq1 (#) seq2) = (r (#) seq1) (#) seq2
proof end;

theorem Th27: :: SEQ_1:27
for r being real number
for seq1, seq2 being Real_Sequence holds r (#) (seq1 (#) seq2) = seq1 (#) (r (#) seq2)
proof end;

theorem Th28: :: SEQ_1:28
for seq1, seq2, seq3 being Real_Sequence holds (seq1 - seq2) (#) seq3 = (seq1 (#) seq3) - (seq2 (#) seq3)
proof end;

theorem Th29: :: SEQ_1:29
for seq3, seq1, seq2 being Real_Sequence holds (seq3 (#) seq1) - (seq3 (#) seq2) = seq3 (#) (seq1 - seq2) by ;

theorem Th30: :: SEQ_1:30
for r being real number
for seq1, seq2 being Real_Sequence holds r (#) (seq1 + seq2) = (r (#) seq1) + (r (#) seq2)
proof end;

theorem Th31: :: SEQ_1:31
for r, p being real number
for seq being Real_Sequence holds (r * p) (#) seq = r (#) (p (#) seq)
proof end;

theorem Th32: :: SEQ_1:32
for r being real number
for seq1, seq2 being Real_Sequence holds r (#) (seq1 - seq2) = (r (#) seq1) - (r (#) seq2)
proof end;

theorem Th33: :: SEQ_1:33
for r being real number
for seq1, seq being Real_Sequence holds r (#) (seq1 /" seq) = (r (#) seq1) /" seq by ;

theorem Th34: :: SEQ_1:34
for seq1, seq2, seq3 being Real_Sequence holds seq1 - (seq2 + seq3) = (seq1 - seq2) - seq3
proof end;

theorem Th35: :: SEQ_1:35
for seq being Real_Sequence holds 1 (#) seq = seq
proof end;

theorem Th36: :: SEQ_1:36
for seq being Real_Sequence holds - (- seq) = seq
proof end;

theorem Th37: :: SEQ_1:37
for seq1, seq2 being Real_Sequence holds seq1 - (- seq2) = seq1 + seq2
proof end;

theorem Th38: :: SEQ_1:38
for seq1, seq2, seq3 being Real_Sequence holds seq1 - (seq2 - seq3) = (seq1 - seq2) + seq3
proof end;

theorem Th39: :: SEQ_1:39
for seq1, seq2, seq3 being Real_Sequence holds seq1 + (seq2 - seq3) = (seq1 + seq2) - seq3
proof end;

theorem Th40: :: SEQ_1:40
for seq1, seq2 being Real_Sequence holds
( (- seq1) (#) seq2 = - (seq1 (#) seq2) & seq1 (#) (- seq2) = - (seq1 (#) seq2) )
proof end;

theorem Th41: :: SEQ_1:41
for seq being Real_Sequence st seq is being_not_0 holds
seq " is being_not_0
proof end;

theorem Th42: :: SEQ_1:42
for seq being Real_Sequence holds (seq " ) " = seq
proof end;

theorem Th43: :: SEQ_1:43
for seq, seq1 being Real_Sequence holds
( ( seq is being_not_0 & seq1 is being_not_0 ) iff seq (#) seq1 is being_not_0 )
proof end;

theorem Th44: :: SEQ_1:44
for seq, seq1 being Real_Sequence holds (seq " ) (#) (seq1 " ) = (seq (#) seq1) "
proof end;

theorem Th45: :: SEQ_1:45
for seq, seq1 being Real_Sequence st seq is being_not_0 holds
(seq1 /" seq) (#) seq = seq1
proof end;

theorem Th46: :: SEQ_1:46
for seq', seq, seq1', seq1 being Real_Sequence holds (seq' /" seq) (#) (seq1' /" seq1) = (seq' (#) seq1') /" (seq (#) seq1)
proof end;

theorem Th47: :: SEQ_1:47
for seq, seq1 being Real_Sequence st seq is being_not_0 & seq1 is being_not_0 holds
seq /" seq1 is being_not_0
proof end;

theorem Th48: :: SEQ_1:48
for seq, seq1 being Real_Sequence holds (seq /" seq1) " = seq1 /" seq
proof end;

theorem Th49: :: SEQ_1:49
for seq2, seq1, seq being Real_Sequence holds seq2 (#) (seq1 /" seq) = (seq2 (#) seq1) /" seq by ;

theorem Th50: :: SEQ_1:50
for seq2, seq, seq1 being Real_Sequence holds seq2 /" (seq /" seq1) = (seq2 (#) seq1) /" seq
proof end;

theorem Th51: :: SEQ_1:51
for seq1, seq2, seq being Real_Sequence st seq1 is being_not_0 holds
seq2 /" seq = (seq2 (#) seq1) /" (seq (#) seq1)
proof end;

theorem Th52: :: SEQ_1:52
for r being real number
for seq being Real_Sequence st r <> 0 & seq is being_not_0 holds
r (#) seq is being_not_0
proof end;

theorem Th53: :: SEQ_1:53
for seq being Real_Sequence st seq is being_not_0 holds
- seq is being_not_0
proof end;

theorem Th54: :: SEQ_1:54
for r being real number
for seq being Real_Sequence holds (r (#) seq) " = (r " ) (#) (seq " )
proof end;

Lemma102: (- 1) " = - 1
;

theorem Th55: :: SEQ_1:55
for seq being Real_Sequence holds (- seq) " = (- 1) (#) (seq " )
proof end;

theorem Th56: :: SEQ_1:56
for seq1, seq being Real_Sequence holds
( - (seq1 /" seq) = (- seq1) /" seq & seq1 /" (- seq) = - (seq1 /" seq) )
proof end;

theorem Th57: :: SEQ_1:57
for seq1, seq, seq1' being Real_Sequence holds
( (seq1 /" seq) + (seq1' /" seq) = (seq1 + seq1') /" seq & (seq1 /" seq) - (seq1' /" seq) = (seq1 - seq1') /" seq ) by , ;

theorem Th58: :: SEQ_1:58
for seq, seq', seq1, seq1' being Real_Sequence st seq is being_not_0 & seq' is being_not_0 holds
( (seq1 /" seq) + (seq1' /" seq') = ((seq1 (#) seq') + (seq1' (#) seq)) /" (seq (#) seq') & (seq1 /" seq) - (seq1' /" seq') = ((seq1 (#) seq') - (seq1' (#) seq)) /" (seq (#) seq') )
proof end;

theorem Th59: :: SEQ_1:59
for seq1', seq, seq', seq1 being Real_Sequence holds (seq1' /" seq) /" (seq' /" seq1) = (seq1' (#) seq1) /" (seq (#) seq')
proof end;

theorem Th60: :: SEQ_1:60
for seq, seq' being Real_Sequence holds abs (seq (#) seq') = (abs seq) (#) (abs seq')
proof end;

theorem Th61: :: SEQ_1:61
for seq being Real_Sequence st seq is being_not_0 holds
abs seq is being_not_0
proof end;

theorem Th62: :: SEQ_1:62
for seq being Real_Sequence holds (abs seq) " = abs (seq " )
proof end;

theorem Th63: :: SEQ_1:63
for seq', seq being Real_Sequence holds abs (seq' /" seq) = (abs seq') /" (abs seq)
proof end;

theorem Th64: :: SEQ_1:64
for r being real number
for seq being Real_Sequence holds abs (r (#) seq) = (abs r) (#) (abs seq)
proof end;