:: FVSUM_1 semantic presentation

theorem Th1: :: FVSUM_1:1
canceled;

theorem Th2: :: FVSUM_1:2
for K being non empty Abelian LoopStr holds the add of K is commutative
proof end;

theorem Th3: :: FVSUM_1:3
for K being non empty add-associative LoopStr holds the add of K is associative
proof end;

theorem Th4: :: FVSUM_1:4
for K being non empty commutative HGrStr holds the mult of K is commutative
proof end;

registration
let K be non empty Abelian LoopStr ;
cluster the add of a1 -> commutative ;
coherence
the add of K is commutative
by ;
end;

registration
let K be non empty add-associative LoopStr ;
cluster the add of a1 -> associative ;
coherence
the add of K is associative
by ;
end;

registration
let K be non empty commutative HGrStr ;
cluster the mult of a1 -> commutative ;
coherence
the mult of K is commutative
by ;
end;

theorem Th5: :: FVSUM_1:5
canceled;

theorem Th6: :: FVSUM_1:6
for K being non empty commutative left_unital multLoopStr holds 1. K is_a_unity_wrt the mult of K
proof end;

theorem Th7: :: FVSUM_1:7
for K being non empty commutative left_unital multLoopStr holds the_unity_wrt the mult of K = 1. K
proof end;

theorem Th8: :: FVSUM_1:8
for K being non empty right_zeroed left_zeroed LoopStr holds 0. K is_a_unity_wrt the add of K
proof end;

theorem Th9: :: FVSUM_1:9
for K being non empty right_zeroed left_zeroed LoopStr holds the_unity_wrt the add of K = 0. K
proof end;

theorem Th10: :: FVSUM_1:10
for K being non empty right_zeroed left_zeroed LoopStr holds the add of K has_a_unity
proof end;

theorem Th11: :: FVSUM_1:11
for K being non empty commutative left_unital multLoopStr holds the mult of K has_a_unity
proof end;

theorem Th12: :: FVSUM_1:12
for K being non empty distributive doubleLoopStr holds the mult of K is_distributive_wrt the add of K
proof end;

definition
let K be non empty HGrStr ;
let a be Element of K;
func c2 multfield -> UnOp of the carrier of a1 equals :: FVSUM_1:def 1
the mult of K [;] a,(id the carrier of K);
coherence
the mult of K [;] a,(id the carrier of K) is UnOp of the carrier of K
;
end;

:: deftheorem Def1 defines multfield FVSUM_1:def 1 :
for K being non empty HGrStr
for a being Element of K holds a multfield = the mult of K [;] a,(id the carrier of K);

definition
let K be non empty LoopStr ;
func diffield c1 -> BinOp of the carrier of a1 equals :: FVSUM_1:def 2
the add of K * (id the carrier of K),(comp K);
correctness
coherence
the add of K * (id the carrier of K),(comp K) is BinOp of the carrier of K
;
;
end;

:: deftheorem Def2 defines diffield FVSUM_1:def 2 :
for K being non empty LoopStr holds diffield K = the add of K * (id the carrier of K),(comp K);

theorem Th13: :: FVSUM_1:13
canceled;

theorem Th14: :: FVSUM_1:14
for K being non empty LoopStr
for a1, a2 being Element of K holds (diffield K) . a1,a2 = a1 - a2
proof end;

Lemma46: for K being non empty HGrStr
for a, b being Element of K holds (the mult of K [;] b,(id the carrier of K)) . a = b * a
proof end;

theorem Th15: :: FVSUM_1:15
for K being non empty distributive doubleLoopStr
for a being Element of K holds a multfield is_distributive_wrt the add of K
proof end;

theorem Th16: :: FVSUM_1:16
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr holds comp K is_an_inverseOp_wrt the add of K
proof end;

theorem Th17: :: FVSUM_1:17
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr holds the add of K has_an_inverseOp
proof end;

theorem Th18: :: FVSUM_1:18
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr holds the_inverseOp_wrt the add of K = comp K
proof end;

theorem Th19: :: FVSUM_1:19
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr holds comp K is_distributive_wrt the add of K
proof end;

definition
let K be non empty LoopStr ;
let p1 be FinSequence of the carrier of K, p2 be FinSequence of the carrier of K;
func c2 + c3 -> FinSequence of the carrier of a1 equals :: FVSUM_1:def 3
the add of K .: p1,p2;
correctness
coherence
the add of K .: p1,p2 is FinSequence of the carrier of K
;
;
end;

:: deftheorem Def3 defines + FVSUM_1:def 3 :
for K being non empty LoopStr
for p1, p2 being FinSequence of the carrier of K holds p1 + p2 = the add of K .: p1,p2;

theorem Th20: :: FVSUM_1:20
canceled;

theorem Th21: :: FVSUM_1:21
for K being non empty LoopStr
for p1, p2 being FinSequence of the carrier of K
for a1, a2 being Element of K
for i being Element of NAT st i in dom (p1 + p2) & a1 = p1 . i & a2 = p2 . i holds
(p1 + p2) . i = a1 + a2
proof end;

definition
let i be Element of NAT ;
let K be non empty LoopStr ;
let R1 be Element of i -tuples_on the carrier of K, R2 be Element of i -tuples_on the carrier of K;
redefine func + as c3 + c4 -> Element of a1 -tuples_on the carrier of a2;
coherence
R1 + R2 is Element of i -tuples_on the carrier of K
by FINSEQ_2:140;
end;

theorem Th22: :: FVSUM_1:22
for i, j being Element of NAT
for K being non empty LoopStr
for a1, a2 being Element of K
for R1, R2 being Element of i -tuples_on the carrier of K st j in Seg i & a1 = R1 . j & a2 = R2 . j holds
(R1 + R2) . j = a1 + a2
proof end;

theorem Th23: :: FVSUM_1:23
for K being non empty LoopStr
for p being FinSequence of the carrier of K holds
( (<*> the carrier of K) + p = <*> the carrier of K & p + (<*> the carrier of K) = <*> the carrier of K ) by FINSEQ_2:87;

theorem Th24: :: FVSUM_1:24
for K being non empty LoopStr
for a1, a2 being Element of K holds <*a1*> + <*a2*> = <*(a1 + a2)*>
proof end;

theorem Th25: :: FVSUM_1:25
for i being Element of NAT
for K being non empty LoopStr
for a1, a2 being Element of K holds (i |-> a1) + (i |-> a2) = i |-> (a1 + a2)
proof end;

theorem Th26: :: FVSUM_1:26
for i being Element of NAT
for K being non empty Abelian LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K holds R1 + R2 = R2 + R1 by FINSEQOP:34;

theorem Th27: :: FVSUM_1:27
for i being Element of NAT
for K being non empty add-associative LoopStr
for R1, R2, R3 being Element of i -tuples_on the carrier of K holds R1 + (R2 + R3) = (R1 + R2) + R3 by FINSEQOP:29;

Lemma62: for i being Element of NAT
for K being non empty right_zeroed left_zeroed LoopStr
for R being Element of i -tuples_on the carrier of K holds R + (i |-> (0. K)) = R
proof end;

theorem Th28: :: FVSUM_1:28
for i being Element of NAT
for K being non empty Abelian right_zeroed left_zeroed LoopStr
for R being Element of i -tuples_on the carrier of K holds
( R + (i |-> (0. K)) = R & R = (i |-> (0. K)) + R )
proof end;

definition
let K be non empty LoopStr ;
let p be FinSequence of the carrier of K;
func - c2 -> FinSequence of the carrier of a1 equals :: FVSUM_1:def 4
(comp K) * p;
correctness
coherence
(comp K) * p is FinSequence of the carrier of K
;
;
end;

:: deftheorem Def4 defines - FVSUM_1:def 4 :
for K being non empty LoopStr
for p being FinSequence of the carrier of K holds - p = (comp K) * p;

theorem Th29: :: FVSUM_1:29
canceled;

theorem Th30: :: FVSUM_1:30
for i being Element of NAT
for K being non empty LoopStr
for a being Element of K
for p being FinSequence of the carrier of K st i in dom (- p) & a = p . i holds
(- p) . i = - a
proof end;

definition
let i be Element of NAT ;
let K be non empty LoopStr ;
let R be Element of i -tuples_on the carrier of K;
redefine func - as - c3 -> Element of a1 -tuples_on the carrier of a2;
coherence
- R is Element of i -tuples_on the carrier of K
by FINSEQ_2:133;
end;

theorem Th31: :: FVSUM_1:31
for j, i being Element of NAT
for K being non empty LoopStr
for a being Element of K
for R being Element of i -tuples_on the carrier of K st j in Seg i & a = R . j holds
(- R) . j = - a
proof end;

theorem Th32: :: FVSUM_1:32
for K being non empty LoopStr holds - (<*> the carrier of K) = <*> the carrier of K by FINSEQ_2:38;

theorem Th33: :: FVSUM_1:33
for K being non empty LoopStr
for a being Element of K holds - <*a*> = <*(- a)*>
proof end;

theorem Th34: :: FVSUM_1:34
for i being Element of NAT
for K being non empty LoopStr
for a being Element of K holds - (i |-> a) = i |-> (- a)
proof end;

Lemma67: for i being Element of NAT
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for R being Element of i -tuples_on the carrier of K holds R + (- R) = i |-> (0. K)
proof end;

theorem Th35: :: FVSUM_1:35
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R being Element of i -tuples_on the carrier of K holds
( R + (- R) = i |-> (0. K) & (- R) + R = i |-> (0. K) )
proof end;

theorem Th36: :: FVSUM_1:36
for i being Element of NAT
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K st R1 + R2 = i |-> (0. K) holds
( R1 = - R2 & R2 = - R1 )
proof end;

theorem Th37: :: FVSUM_1:37
for i being Element of NAT
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for R being Element of i -tuples_on the carrier of K holds - (- R) = R
proof end;

theorem Th38: :: FVSUM_1:38
for i being Element of NAT
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K st - R1 = - R2 holds
R1 = R2
proof end;

Lemma71: for i being Element of NAT
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for R1, R, R2 being Element of i -tuples_on the carrier of K st R1 + R = R2 + R holds
R1 = R2
proof end;

theorem Th39: :: FVSUM_1:39
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R, R1, R2 being Element of i -tuples_on the carrier of K st ( R1 + R = R2 + R or R1 + R = R + R2 ) holds
R1 = R2
proof end;

theorem Th40: :: FVSUM_1:40
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K holds - (R1 + R2) = (- R1) + (- R2)
proof end;

definition
let K be non empty LoopStr ;
let p1 be FinSequence of the carrier of K, p2 be FinSequence of the carrier of K;
func c2 - c3 -> FinSequence of the carrier of a1 equals :: FVSUM_1:def 5
(diffield K) .: p1,p2;
correctness
coherence
(diffield K) .: p1,p2 is FinSequence of the carrier of K
;
;
end;

:: deftheorem Def5 defines - FVSUM_1:def 5 :
for K being non empty LoopStr
for p1, p2 being FinSequence of the carrier of K holds p1 - p2 = (diffield K) .: p1,p2;

theorem Th41: :: FVSUM_1:41
canceled;

theorem Th42: :: FVSUM_1:42
for i being Element of NAT
for K being non empty LoopStr
for a1, a2 being Element of K
for p1, p2 being FinSequence of the carrier of K st i in dom (p1 - p2) & a1 = p1 . i & a2 = p2 . i holds
(p1 - p2) . i = a1 - a2
proof end;

definition
let i be Element of NAT ;
let K be non empty LoopStr ;
let R1 be Element of i -tuples_on the carrier of K, R2 be Element of i -tuples_on the carrier of K;
redefine func - as c3 - c4 -> Element of a1 -tuples_on the carrier of a2;
coherence
R1 - R2 is Element of i -tuples_on the carrier of K
by FINSEQ_2:140;
end;

theorem Th43: :: FVSUM_1:43
for j, i being Element of NAT
for K being non empty LoopStr
for a1, a2 being Element of K
for R1, R2 being Element of i -tuples_on the carrier of K st j in Seg i & a1 = R1 . j & a2 = R2 . j holds
(R1 - R2) . j = a1 - a2
proof end;

theorem Th44: :: FVSUM_1:44
for K being non empty LoopStr
for p1 being FinSequence of the carrier of K holds
( (<*> the carrier of K) - p1 = <*> the carrier of K & p1 - (<*> the carrier of K) = <*> the carrier of K ) by FINSEQ_2:87;

theorem Th45: :: FVSUM_1:45
for K being non empty LoopStr
for a1, a2 being Element of K holds <*a1*> - <*a2*> = <*(a1 - a2)*>
proof end;

theorem Th46: :: FVSUM_1:46
for i being Element of NAT
for K being non empty LoopStr
for a1, a2 being Element of K holds (i |-> a1) - (i |-> a2) = i |-> (a1 - a2)
proof end;

theorem Th47: :: FVSUM_1:47
for i being Element of NAT
for K being non empty LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K holds R1 - R2 = R1 + (- R2) by FINSEQOP:89;

theorem Th48: :: FVSUM_1:48
for i being Element of NAT
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for R being Element of i -tuples_on the carrier of K holds R - (i |-> (0. K)) = R
proof end;

theorem Th49: :: FVSUM_1:49
for i being Element of NAT
for K being non empty Abelian right_zeroed left_zeroed LoopStr
for R being Element of i -tuples_on the carrier of K holds (i |-> (0. K)) - R = - R
proof end;

theorem Th50: :: FVSUM_1:50
for i being Element of NAT
for K being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K holds R1 - (- R2) = R1 + R2
proof end;

theorem Th51: :: FVSUM_1:51
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K holds - (R1 - R2) = R2 - R1
proof end;

theorem Th52: :: FVSUM_1:52
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K holds - (R1 - R2) = (- R1) + R2
proof end;

theorem Th53: :: FVSUM_1:53
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R being Element of i -tuples_on the carrier of K holds R - R = i |-> (0. K)
proof end;

theorem Th54: :: FVSUM_1:54
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K st R1 - R2 = i |-> (0. K) holds
R1 = R2
proof end;

theorem Th55: :: FVSUM_1:55
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R2, R3 being Element of i -tuples_on the carrier of K holds (R1 - R2) - R3 = R1 - (R2 + R3)
proof end;

theorem Th56: :: FVSUM_1:56
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R2, R3 being Element of i -tuples_on the carrier of K holds R1 + (R2 - R3) = (R1 + R2) - R3
proof end;

theorem Th57: :: FVSUM_1:57
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R2, R3 being Element of i -tuples_on the carrier of K holds R1 - (R2 - R3) = (R1 - R2) + R3
proof end;

theorem Th58: :: FVSUM_1:58
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R being Element of i -tuples_on the carrier of K holds R1 = (R1 + R) - R
proof end;

theorem Th59: :: FVSUM_1:59
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R being Element of i -tuples_on the carrier of K holds R1 = (R1 - R) + R
proof end;

theorem Th60: :: FVSUM_1:60
for K being non empty HGrStr
for a, b being Element of K holds (the mult of K [;] a,(id the carrier of K)) . b = a * b
proof end;

theorem Th61: :: FVSUM_1:61
for K being non empty HGrStr
for a, b being Element of K holds (a multfield ) . b = a * b by Th7;

definition
let K be non empty HGrStr ;
let p be FinSequence of the carrier of K;
let a be Element of K;
func c3 * c2 -> FinSequence of the carrier of a1 equals :: FVSUM_1:def 6
(a multfield ) * p;
correctness
coherence
(a multfield ) * p is FinSequence of the carrier of K
;
;
end;

:: deftheorem Def6 defines * FVSUM_1:def 6 :
for K being non empty HGrStr
for p being FinSequence of the carrier of K
for a being Element of K holds a * p = (a multfield ) * p;

theorem Th62: :: FVSUM_1:62
for i being Element of NAT
for K being non empty HGrStr
for a, a' being Element of K
for p being FinSequence of the carrier of K st i in dom (a * p) & a' = p . i holds
(a * p) . i = a * a'
proof end;

definition
let i be Element of NAT ;
let K be non empty HGrStr ;
let R be Element of i -tuples_on the carrier of K;
let a be Element of K;
redefine func * as c4 * c3 -> Element of a1 -tuples_on the carrier of a2;
coherence
a * R is Element of i -tuples_on the carrier of K
by FINSEQ_2:133;
end;

theorem Th63: :: FVSUM_1:63
for j, i being Element of NAT
for K being non empty HGrStr
for a', a being Element of K
for R being Element of i -tuples_on the carrier of K st j in Seg i & a' = R . j holds
(a * R) . j = a * a'
proof end;

theorem Th64: :: FVSUM_1:64
for K being non empty HGrStr
for a being Element of K holds a * (<*> the carrier of K) = <*> the carrier of K by FINSEQ_2:38;

theorem Th65: :: FVSUM_1:65
for K being non empty HGrStr
for a, a1 being Element of K holds a * <*a1*> = <*(a * a1)*>
proof end;

theorem Th66: :: FVSUM_1:66
for i being Element of NAT
for K being non empty HGrStr
for a1, a2 being Element of K holds a1 * (i |-> a2) = i |-> (a1 * a2)
proof end;

theorem Th67: :: FVSUM_1:67
for i being Element of NAT
for K being non empty associative HGrStr
for a1, a2 being Element of K
for R being Element of i -tuples_on the carrier of K holds (a1 * a2) * R = a1 * (a2 * R)
proof end;

theorem Th68: :: FVSUM_1:68
for i being Element of NAT
for K being non empty distributive doubleLoopStr
for a1, a2 being Element of K
for R being Element of i -tuples_on the carrier of K holds (a1 + a2) * R = (a1 * R) + (a2 * R)
proof end;

theorem Th69: :: FVSUM_1:69
for i being Element of NAT
for K being non empty distributive doubleLoopStr
for a being Element of K
for R1, R2 being Element of i -tuples_on the carrier of K holds a * (R1 + R2) = (a * R1) + (a * R2)
proof end;

theorem Th70: :: FVSUM_1:70
for i being Element of NAT
for K being non empty commutative distributive left_unital doubleLoopStr
for R being Element of i -tuples_on the carrier of K holds (1. K) * R = R
proof end;

theorem Th71: :: FVSUM_1:71
for i being Element of NAT
for K being non empty add-associative right_zeroed right_complementable distributive doubleLoopStr
for R being Element of i -tuples_on the carrier of K holds (0. K) * R = i |-> (0. K)
proof end;

theorem Th72: :: FVSUM_1:72
for i being Element of NAT
for K being non empty add-associative right_zeroed right_complementable commutative distributive left_unital doubleLoopStr
for R being Element of i -tuples_on the carrier of K holds (- (1. K)) * R = - R
proof end;

definition
let M be non empty HGrStr ;
let p1 be FinSequence of the carrier of M, p2 be FinSequence of the carrier of M;
func mlt c2,c3 -> FinSequence of the carrier of a1 equals :: FVSUM_1:def 7
the mult of M .: p1,p2;
correctness
coherence
the mult of M .: p1,p2 is FinSequence of the carrier of M
;
;
end;

:: deftheorem Def7 defines mlt FVSUM_1:def 7 :
for M being non empty HGrStr
for p1, p2 being FinSequence of the carrier of M holds mlt p1,p2 = the mult of M .: p1,p2;

theorem Th73: :: FVSUM_1:73
for i being Element of NAT
for K being non empty HGrStr
for a1, a2 being Element of K
for p1, p2 being FinSequence of the carrier of K st i in dom (mlt p1,p2) & a1 = p1 . i & a2 = p2 . i holds
(mlt p1,p2) . i = a1 * a2
proof end;

definition
let i be Element of NAT ;
let K be non empty HGrStr ;
let R1 be Element of i -tuples_on the carrier of K, R2 be Element of i -tuples_on the carrier of K;
redefine func mlt as mlt c3,c4 -> Element of a1 -tuples_on the carrier of a2;
coherence
mlt R1,R2 is Element of i -tuples_on the carrier of K
by FINSEQ_2:140;
end;

theorem Th74: :: FVSUM_1:74
for j, i being Element of NAT
for K being non empty HGrStr
for a1, a2 being Element of K
for R1, R2 being Element of i -tuples_on the carrier of K st j in Seg i & a1 = R1 . j & a2 = R2 . j holds
(mlt R1,R2) . j = a1 * a2
proof end;

theorem Th75: :: FVSUM_1:75
for K being non empty HGrStr
for p being FinSequence of the carrier of K holds
( mlt (<*> the carrier of K),p = <*> the carrier of K & mlt p,(<*> the carrier of K) = <*> the carrier of K ) by FINSEQ_2:87;

theorem Th76: :: FVSUM_1:76
for K being non empty HGrStr
for a1, a2 being Element of K holds mlt <*a1*>,<*a2*> = <*(a1 * a2)*>
proof end;

Lemma92: for i being Element of NAT
for K being non empty HGrStr
for a1, a2 being Element of K
for R1, R2 being Element of i -tuples_on the carrier of K holds mlt (R1 ^ <*a1*>),(R2 ^ <*a2*>) = (mlt R1,R2) ^ <*(a1 * a2)*>
proof end;

Lemma93: for K being non empty HGrStr
for a1, a2, b1, b2 being Element of K holds mlt <*a1,a2*>,<*b1,b2*> = <*(a1 * b1),(a2 * b2)*>
proof end;

theorem Th77: :: FVSUM_1:77
for i being Element of NAT
for K being non empty commutative HGrStr
for R1, R2 being Element of i -tuples_on the carrier of K holds mlt R1,R2 = mlt R2,R1 by FINSEQOP:34;

theorem Th78: :: FVSUM_1:78
for K being non empty commutative HGrStr
for p, q being FinSequence of the carrier of K holds mlt p,q = mlt q,p
proof end;

theorem Th79: :: FVSUM_1:79
for i being Element of NAT
for K being non empty associative HGrStr
for R1, R2, R3 being Element of i -tuples_on the carrier of K holds mlt R1,(mlt R2,R3) = mlt (mlt R1,R2),R3
proof end;

theorem Th80: :: FVSUM_1:80
for i being Element of NAT
for K being non empty associative commutative HGrStr
for a being Element of K
for R being Element of i -tuples_on the carrier of K holds
( mlt (i |-> a),R = a * R & mlt R,(i |-> a) = a * R )
proof end;

theorem Th81: :: FVSUM_1:81
for i being Element of NAT
for K being non empty associative commutative HGrStr
for a1, a2 being Element of K holds mlt (i |-> a1),(i |-> a2) = i |-> (a1 * a2)
proof end;

theorem Th82: :: FVSUM_1:82
for i being Element of NAT
for K being non empty associative HGrStr
for a being Element of K
for R1, R2 being Element of i -tuples_on the carrier of K holds a * (mlt R1,R2) = mlt (a * R1),R2
proof end;

theorem Th83: :: FVSUM_1:83
for i being Element of NAT
for K being non empty associative commutative HGrStr
for a being Element of K
for R1, R2 being Element of i -tuples_on the carrier of K holds
( a * (mlt R1,R2) = mlt (a * R1),R2 & a * (mlt R1,R2) = mlt R1,(a * R2) )
proof end;

theorem Th84: :: FVSUM_1:84
for i being Element of NAT
for K being non empty associative commutative HGrStr
for a being Element of K
for R being Element of i -tuples_on the carrier of K holds a * R = mlt (i |-> a),R by ;

registration
cluster non empty Abelian right_zeroed -> non empty left_zeroed LoopStr ;
coherence
for b1 being non empty LoopStr st b1 is Abelian & b1 is right_zeroed holds
b1 is left_zeroed
proof end;
end;

definition
let K be non empty Abelian add-associative right_zeroed right_complementable LoopStr ;
let p be FinSequence of the carrier of K;
redefine func Sum c2 -> Element of the carrier of a1 equals :: FVSUM_1:def 8
the add of K $$ p;
compatibility
for b1 being Element of the carrier of K holds
( b1 = Sum p iff b1 = the add of K $$ p )
proof end;
end;

:: deftheorem Def8 defines Sum FVSUM_1:def 8 :
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for p being FinSequence of the carrier of K holds Sum p = the add of K $$ p;

theorem Th85: :: FVSUM_1:85
canceled;

theorem Th86: :: FVSUM_1:86
canceled;

theorem Th87: :: FVSUM_1:87
for K being non empty add-associative right_zeroed right_complementable LoopStr
for a being Element of K
for p being FinSequence of the carrier of K holds Sum (p ^ <*a*>) = (Sum p) + a
proof end;

theorem Th88: :: FVSUM_1:88
canceled;

theorem Th89: :: FVSUM_1:89
for K being non empty add-associative right_zeroed right_complementable LoopStr
for a being Element of K
for p being FinSequence of the carrier of K holds Sum (<*a*> ^ p) = a + (Sum p)
proof end;

theorem Th90: :: FVSUM_1:90
canceled;

theorem Th91: :: FVSUM_1:91
canceled;

theorem Th92: :: FVSUM_1:92
for K being non empty Abelian add-associative right_zeroed right_complementable distributive doubleLoopStr
for a being Element of K
for p being FinSequence of the carrier of K holds Sum (a * p) = a * (Sum p)
proof end;

theorem Th93: :: FVSUM_1:93
for K being non empty LoopStr
for R being Element of 0 -tuples_on the carrier of K holds Sum R = 0. K
proof end;

theorem Th94: :: FVSUM_1:94
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for p being FinSequence of the carrier of K holds Sum (- p) = - (Sum p)
proof end;

theorem Th95: :: FVSUM_1:95
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K holds Sum (R1 + R2) = (Sum R1) + (Sum R2)
proof end;

theorem Th96: :: FVSUM_1:96
for i being Element of NAT
for K being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for R1, R2 being Element of i -tuples_on the carrier of K holds Sum (R1 - R2) = (Sum R1) - (Sum R2)
proof end;

definition
canceled;
end;

:: deftheorem Def9 FVSUM_1:def 9 :
canceled;

theorem Th97: :: FVSUM_1:97
canceled;

theorem Th98: :: FVSUM_1:98
for K being non empty commutative left_unital multLoopStr holds Product (<*> the carrier of K) = 1. K by GROUP_4:11;

theorem Th99: :: FVSUM_1:99
for K being non empty HGrStr
for a being Element of K holds Product <*a*> = a by FINSOP_1:12;

theorem Th100: :: FVSUM_1:100
for K being non empty commutative left_unital doubleLoopStr
for a being Element of K
for p being FinSequence of the carrier of K holds Product (p ^ <*a*>) = (Product p) * a by GROUP_4:9;

theorem Th101: :: FVSUM_1:101
for K being non empty associative commutative left_unital doubleLoopStr
for p1, p2 being FinSequence of the carrier of K holds Product (p1 ^ p2) = (Product p1) * (Product p2) by GROUP_4:8;

theorem Th102: :: FVSUM_1:102
for K being non empty associative commutative left_unital doubleLoopStr
for a being Element of K
for p1 being FinSequence of the carrier of K holds Product (<*a*> ^ p1) = a * (Product p1)
proof end;

theorem Th103: :: FVSUM_1:103
for K being non empty associative commutative left_unital doubleLoopStr
for a1, a2 being Element of K holds Product <*a1,a2*> = a1 * a2 by GROUP_4:13;

theorem Th104: :: FVSUM_1:104
for K being non empty associative commutative left_unital doubleLoopStr
for a1, a2, a3 being Element of K holds Product <*a1,a2,a3*> = (a1 * a2) * a3
proof end;

theorem Th105: :: FVSUM_1:105
for K being non empty associative commutative left_unital doubleLoopStr
for R being Element of 0 -tuples_on the carrier of K holds Product R = 1. K
proof end;

theorem Th106: :: FVSUM_1:106
for i being Element of NAT
for K being non empty associative commutative left_unital doubleLoopStr holds Product (i |-> (1. K)) = 1. K
proof end;

theorem Th107: :: FVSUM_1:107
for K being non empty Abelian add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr
for p being FinSequence of the carrier of K holds
( ex k being Element of NAT st
( k in dom p & p . k = 0. K ) iff Product p = 0. K )
proof end;

theorem Th108: :: FVSUM_1:108
for i, j being Element of NAT
for K being non empty associative commutative left_unital doubleLoopStr
for a being Element of K holds Product ((i + j) |-> a) = (Product (i |-> a)) * (Product (j |-> a))
proof end;

theorem Th109: :: FVSUM_1:109
for i, j being Element of NAT
for K being non empty associative commutative left_unital doubleLoopStr
for a being Element of K holds Product ((i * j) |-> a) = Product (j |-> (Product (i |-> a)))
proof end;

theorem Th110: :: FVSUM_1:110
for i being Element of NAT
for K being non empty associative commutative left_unital doubleLoopStr
for a1, a2 being Element of K holds Product (i |-> (a1 * a2)) = (Product (i |-> a1)) * (Product (i |-> a2))
proof end;

theorem Th111: :: FVSUM_1:111
for i being Element of NAT
for K being non empty associative commutative left_unital doubleLoopStr
for R1, R2 being Element of i -tuples_on the carrier of K holds Product (mlt R1,R2) = (Product R1) * (Product R2)
proof end;

theorem Th112: :: FVSUM_1:112
for i being Element of NAT
for K being non empty associative commutative left_unital doubleLoopStr
for a being Element of K
for R1 being Element of i -tuples_on the carrier of K holds Product (a * R1) = (Product (i |-> a)) * (Product R1)
proof end;

definition
let K be non empty doubleLoopStr ;
let p be FinSequence of the carrier of K, q be FinSequence of the carrier of K;
func c2 "*" c3 -> Element of a1 equals :: FVSUM_1:def 10
Sum (mlt p,q);
coherence
Sum (mlt p,q) is Element of K
;
end;

:: deftheorem Def10 defines "*" FVSUM_1:def 10 :
for K being non empty doubleLoopStr
for p, q being FinSequence of the carrier of K holds p "*" q = Sum (mlt p,q);

theorem Th113: :: FVSUM_1:113
for K being non empty Abelian add-associative right_zeroed right_complementable associative commutative left_unital doubleLoopStr
for a, b being Element of K holds <*a*> "*" <*b*> = a * b
proof end;

theorem Th114: :: FVSUM_1:114
for K being non empty Abelian add-associative right_zeroed right_complementable associative commutative left_unital doubleLoopStr
for a1, a2, b1, b2 being Element of K holds <*a1,a2*> "*" <*b1,b2*> = (a1 * b1) + (a2 * b2)
proof end;

theorem Th115: :: FVSUM_1:115
for K being non empty associative commutative left_unital doubleLoopStr
for p, q being FinSequence of the carrier of K holds p "*" q = q "*" p by ;