:: FVSUM_1 semantic presentation

theorem Th1: :: FVSUM_1:1
canceled;

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

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

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

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

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

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

theorem Th5: :: FVSUM_1:5
canceled;

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

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

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

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

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

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

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

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

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

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

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

theorem Th13: :: FVSUM_1:13
canceled;

theorem Th14: :: FVSUM_1:14
for b1 being non empty LoopStr
for b2, b3 being Element of b1 holds (diffield b1) . b2,b3 = b2 - b3
proof end;

Lemma12: for b1 being non empty HGrStr
for b2, b3 being Element of b1 holds (the mult of b1 [;] b3,(id the carrier of b1)) . b2 = b3 * b2
proof end;

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

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

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

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

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

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

:: deftheorem Def3 defines + FVSUM_1:def 3 :
for b1 being non empty LoopStr
for b2, b3 being FinSequence of the carrier of b1 holds b2 + b3 = the add of b1 .: b2,b3;

theorem Th20: :: FVSUM_1:20
canceled;

theorem Th21: :: FVSUM_1:21
for b1 being non empty LoopStr
for b2, b3 being FinSequence of the carrier of b1
for b4, b5 being Element of b1
for b6 being Nat holds
( b6 in dom (b2 + b3) & b4 = b2 . b6 & b5 = b3 . b6 implies (b2 + b3) . b6 = b4 + b5 )
proof end;

definition
let c1 be Nat;
let c2 be non empty LoopStr ;
let c3, c4 be Element of c1 -tuples_on the carrier of c2;
redefine func + as c3 + c4 -> Element of a1 -tuples_on the carrier of a2;
coherence
c3 + c4 is Element of c1 -tuples_on the carrier of c2
by FINSEQ_2:140;
end;

theorem Th22: :: FVSUM_1:22
for b1, b2 being Nat
for b3 being non empty LoopStr
for b4, b5 being Element of b3
for b6, b7 being Element of b1 -tuples_on the carrier of b3 holds
( b2 in Seg b1 & b4 = b6 . b2 & b5 = b7 . b2 implies (b6 + b7) . b2 = b4 + b5 )
proof end;

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

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

theorem Th25: :: FVSUM_1:25
for b1 being Nat
for b2 being non empty LoopStr
for b3, b4 being Element of b2 holds (b1 |-> b3) + (b1 |-> b4) = b1 |-> (b3 + b4)
proof end;

theorem Th26: :: FVSUM_1:26
for b1 being Nat
for b2 being non empty Abelian LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds b3 + b4 = b4 + b3 by FINSEQOP:34;

theorem Th27: :: FVSUM_1:27
for b1 being Nat
for b2 being non empty add-associative LoopStr
for b3, b4, b5 being Element of b1 -tuples_on the carrier of b2 holds b3 + (b4 + b5) = (b3 + b4) + b5 by FINSEQOP:29;

Lemma20: for b1 being Nat
for b2 being non empty right_zeroed left_zeroed LoopStr
for b3 being Element of b1 -tuples_on the carrier of b2 holds b3 + (b1 |-> (0. b2)) = b3
proof end;

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

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

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

theorem Th29: :: FVSUM_1:29
canceled;

theorem Th30: :: FVSUM_1:30
for b1 being Nat
for b2 being non empty LoopStr
for b3 being Element of b2
for b4 being FinSequence of the carrier of b2 holds
( b1 in dom (- b4) & b3 = b4 . b1 implies (- b4) . b1 = - b3 )
proof end;

definition
let c1 be Nat;
let c2 be non empty LoopStr ;
let c3 be Element of c1 -tuples_on the carrier of c2;
redefine func - as - c3 -> Element of a1 -tuples_on the carrier of a2;
coherence
- c3 is Element of c1 -tuples_on the carrier of c2
by FINSEQ_2:133;
end;

theorem Th31: :: FVSUM_1:31
for b1, b2 being Nat
for b3 being non empty LoopStr
for b4 being Element of b3
for b5 being Element of b2 -tuples_on the carrier of b3 holds
( b1 in Seg b2 & b4 = b5 . b1 implies (- b5) . b1 = - b4 )
proof end;

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

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

theorem Th34: :: FVSUM_1:34
for b1 being Nat
for b2 being non empty LoopStr
for b3 being Element of b2 holds - (b1 |-> b3) = b1 |-> (- b3)
proof end;

Lemma24: for b1 being Nat
for b2 being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for b3 being Element of b1 -tuples_on the carrier of b2 holds b3 + (- b3) = b1 |-> (0. b2)
proof end;

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

theorem Th36: :: FVSUM_1:36
for b1 being Nat
for b2 being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds
( b3 + b4 = b1 |-> (0. b2) implies ( b3 = - b4 & b4 = - b3 ) )
proof end;

theorem Th37: :: FVSUM_1:37
for b1 being Nat
for b2 being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for b3 being Element of b1 -tuples_on the carrier of b2 holds - (- b3) = b3
proof end;

theorem Th38: :: FVSUM_1:38
for b1 being Nat
for b2 being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds
( - b3 = - b4 implies b3 = b4 )
proof end;

Lemma28: for b1 being Nat
for b2 being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for b3, b4, b5 being Element of b1 -tuples_on the carrier of b2 holds
( b3 + b4 = b5 + b4 implies b3 = b5 )
proof end;

theorem Th39: :: FVSUM_1:39
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4, b5 being Element of b1 -tuples_on the carrier of b2 holds
( ( b4 + b3 = b5 + b3 or b4 + b3 = b3 + b5 ) implies b4 = b5 )
proof end;

theorem Th40: :: FVSUM_1:40
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds - (b3 + b4) = (- b3) + (- b4)
proof end;

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

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

theorem Th41: :: FVSUM_1:41
canceled;

theorem Th42: :: FVSUM_1:42
for b1 being Nat
for b2 being non empty LoopStr
for b3, b4 being Element of b2
for b5, b6 being FinSequence of the carrier of b2 holds
( b1 in dom (b5 - b6) & b3 = b5 . b1 & b4 = b6 . b1 implies (b5 - b6) . b1 = b3 - b4 )
proof end;

definition
let c1 be Nat;
let c2 be non empty LoopStr ;
let c3, c4 be Element of c1 -tuples_on the carrier of c2;
redefine func - as c3 - c4 -> Element of a1 -tuples_on the carrier of a2;
coherence
c3 - c4 is Element of c1 -tuples_on the carrier of c2
by FINSEQ_2:140;
end;

theorem Th43: :: FVSUM_1:43
for b1, b2 being Nat
for b3 being non empty LoopStr
for b4, b5 being Element of b3
for b6, b7 being Element of b2 -tuples_on the carrier of b3 holds
( b1 in Seg b2 & b4 = b6 . b1 & b5 = b7 . b1 implies (b6 - b7) . b1 = b4 - b5 )
proof end;

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

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

theorem Th46: :: FVSUM_1:46
for b1 being Nat
for b2 being non empty LoopStr
for b3, b4 being Element of b2 holds (b1 |-> b3) - (b1 |-> b4) = b1 |-> (b3 - b4)
proof end;

theorem Th47: :: FVSUM_1:47
for b1 being Nat
for b2 being non empty LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds b3 - b4 = b3 + (- b4) by FINSEQOP:89;

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

theorem Th49: :: FVSUM_1:49
for b1 being Nat
for b2 being non empty Abelian right_zeroed left_zeroed LoopStr
for b3 being Element of b1 -tuples_on the carrier of b2 holds (b1 |-> (0. b2)) - b3 = - b3
proof end;

theorem Th50: :: FVSUM_1:50
for b1 being Nat
for b2 being non empty add-associative right_zeroed right_complementable left_zeroed LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds b3 - (- b4) = b3 + b4
proof end;

theorem Th51: :: FVSUM_1:51
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds - (b3 - b4) = b4 - b3
proof end;

theorem Th52: :: FVSUM_1:52
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds - (b3 - b4) = (- b3) + b4
proof end;

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

theorem Th54: :: FVSUM_1:54
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds
( b3 - b4 = b1 |-> (0. b2) implies b3 = b4 )
proof end;

theorem Th55: :: FVSUM_1:55
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4, b5 being Element of b1 -tuples_on the carrier of b2 holds (b3 - b4) - b5 = b3 - (b4 + b5)
proof end;

theorem Th56: :: FVSUM_1:56
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4, b5 being Element of b1 -tuples_on the carrier of b2 holds b3 + (b4 - b5) = (b3 + b4) - b5
proof end;

theorem Th57: :: FVSUM_1:57
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4, b5 being Element of b1 -tuples_on the carrier of b2 holds b3 - (b4 - b5) = (b3 - b4) + b5
proof end;

theorem Th58: :: FVSUM_1:58
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds b3 = (b3 + b4) - b4
proof end;

theorem Th59: :: FVSUM_1:59
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds b3 = (b3 - b4) + b4
proof end;

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

theorem Th61: :: FVSUM_1:61
for b1 being non empty HGrStr
for b2, b3 being Element of b1 holds (b2 multfield ) . b3 = b2 * b3 by Th60;

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

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

theorem Th62: :: FVSUM_1:62
for b1 being Nat
for b2 being non empty HGrStr
for b3, b4 being Element of b2
for b5 being FinSequence of the carrier of b2 holds
( b1 in dom (b3 * b5) & b4 = b5 . b1 implies (b3 * b5) . b1 = b3 * b4 )
proof end;

definition
let c1 be Nat;
let c2 be non empty HGrStr ;
let c3 be Element of c1 -tuples_on the carrier of c2;
let c4 be Element of c2;
redefine func * as c4 * c3 -> Element of a1 -tuples_on the carrier of a2;
coherence
c4 * c3 is Element of c1 -tuples_on the carrier of c2
by FINSEQ_2:133;
end;

theorem Th63: :: FVSUM_1:63
for b1, b2 being Nat
for b3 being non empty HGrStr
for b4, b5 being Element of b3
for b6 being Element of b2 -tuples_on the carrier of b3 holds
( b1 in Seg b2 & b4 = b6 . b1 implies (b5 * b6) . b1 = b5 * b4 )
proof end;

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

theorem Th65: :: FVSUM_1:65
for b1 being non empty HGrStr
for b2, b3 being Element of b1 holds b2 * <*b3*> = <*(b2 * b3)*>
proof end;

theorem Th66: :: FVSUM_1:66
for b1 being Nat
for b2 being non empty HGrStr
for b3, b4 being Element of b2 holds b3 * (b1 |-> b4) = b1 |-> (b3 * b4)
proof end;

theorem Th67: :: FVSUM_1:67
for b1 being Nat
for b2 being non empty associative HGrStr
for b3, b4 being Element of b2
for b5 being Element of b1 -tuples_on the carrier of b2 holds (b3 * b4) * b5 = b3 * (b4 * b5)
proof end;

theorem Th68: :: FVSUM_1:68
for b1 being Nat
for b2 being non empty distributive doubleLoopStr
for b3, b4 being Element of b2
for b5 being Element of b1 -tuples_on the carrier of b2 holds (b3 + b4) * b5 = (b3 * b5) + (b4 * b5)
proof end;

theorem Th69: :: FVSUM_1:69
for b1 being Nat
for b2 being non empty distributive doubleLoopStr
for b3 being Element of b2
for b4, b5 being Element of b1 -tuples_on the carrier of b2 holds b3 * (b4 + b5) = (b3 * b4) + (b3 * b5)
proof end;

theorem Th70: :: FVSUM_1:70
for b1 being Nat
for b2 being non empty commutative distributive left_unital doubleLoopStr
for b3 being Element of b1 -tuples_on the carrier of b2 holds (1. b2) * b3 = b3
proof end;

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

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

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

:: deftheorem Def7 defines mlt FVSUM_1:def 7 :
for b1 being non empty HGrStr
for b2, b3 being FinSequence of the carrier of b1 holds mlt b2,b3 = the mult of b1 .: b2,b3;

theorem Th73: :: FVSUM_1:73
for b1 being Nat
for b2 being non empty HGrStr
for b3, b4 being Element of b2
for b5, b6 being FinSequence of the carrier of b2 holds
( b1 in dom (mlt b5,b6) & b3 = b5 . b1 & b4 = b6 . b1 implies (mlt b5,b6) . b1 = b3 * b4 )
proof end;

definition
let c1 be Nat;
let c2 be non empty HGrStr ;
let c3, c4 be Element of c1 -tuples_on the carrier of c2;
redefine func mlt as mlt c3,c4 -> Element of a1 -tuples_on the carrier of a2;
coherence
mlt c3,c4 is Element of c1 -tuples_on the carrier of c2
by FINSEQ_2:140;
end;

theorem Th74: :: FVSUM_1:74
for b1, b2 being Nat
for b3 being non empty HGrStr
for b4, b5 being Element of b3
for b6, b7 being Element of b2 -tuples_on the carrier of b3 holds
( b1 in Seg b2 & b4 = b6 . b1 & b5 = b7 . b1 implies (mlt b6,b7) . b1 = b4 * b5 )
proof end;

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

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

Lemma40: for b1 being Nat
for b2 being non empty HGrStr
for b3, b4 being Element of b2
for b5, b6 being Element of b1 -tuples_on the carrier of b2 holds mlt (b5 ^ <*b3*>),(b6 ^ <*b4*>) = (mlt b5,b6) ^ <*(b3 * b4)*>
proof end;

Lemma41: for b1 being non empty HGrStr
for b2, b3, b4, b5 being Element of b1 holds mlt <*b2,b3*>,<*b4,b5*> = <*(b2 * b4),(b3 * b5)*>
proof end;

theorem Th77: :: FVSUM_1:77
for b1 being Nat
for b2 being non empty commutative HGrStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds mlt b3,b4 = mlt b4,b3 by FINSEQOP:34;

theorem Th78: :: FVSUM_1:78
for b1 being non empty commutative HGrStr
for b2, b3 being FinSequence of the carrier of b1 holds mlt b2,b3 = mlt b3,b2
proof end;

theorem Th79: :: FVSUM_1:79
for b1 being Nat
for b2 being non empty associative HGrStr
for b3, b4, b5 being Element of b1 -tuples_on the carrier of b2 holds mlt b3,(mlt b4,b5) = mlt (mlt b3,b4),b5
proof end;

theorem Th80: :: FVSUM_1:80
for b1 being Nat
for b2 being non empty associative commutative HGrStr
for b3 being Element of b2
for b4 being Element of b1 -tuples_on the carrier of b2 holds
( mlt (b1 |-> b3),b4 = b3 * b4 & mlt b4,(b1 |-> b3) = b3 * b4 )
proof end;

theorem Th81: :: FVSUM_1:81
for b1 being Nat
for b2 being non empty associative commutative HGrStr
for b3, b4 being Element of b2 holds mlt (b1 |-> b3),(b1 |-> b4) = b1 |-> (b3 * b4)
proof end;

theorem Th82: :: FVSUM_1:82
for b1 being Nat
for b2 being non empty associative HGrStr
for b3 being Element of b2
for b4, b5 being Element of b1 -tuples_on the carrier of b2 holds b3 * (mlt b4,b5) = mlt (b3 * b4),b5
proof end;

theorem Th83: :: FVSUM_1:83
for b1 being Nat
for b2 being non empty associative commutative HGrStr
for b3 being Element of b2
for b4, b5 being Element of b1 -tuples_on the carrier of b2 holds
( b3 * (mlt b4,b5) = mlt (b3 * b4),b5 & b3 * (mlt b4,b5) = mlt b4,(b3 * b5) )
proof end;

theorem Th84: :: FVSUM_1:84
for b1 being Nat
for b2 being non empty associative commutative HGrStr
for b3 being Element of b2
for b4 being Element of b1 -tuples_on the carrier of b2 holds b3 * b4 = mlt (b1 |-> b3),b4 by Th80;

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

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

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

theorem Th85: :: FVSUM_1:85
canceled;

theorem Th86: :: FVSUM_1:86
canceled;

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

theorem Th88: :: FVSUM_1:88
canceled;

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

theorem Th90: :: FVSUM_1:90
canceled;

theorem Th91: :: FVSUM_1:91
canceled;

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

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

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

theorem Th95: :: FVSUM_1:95
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds Sum (b3 + b4) = (Sum b3) + (Sum b4)
proof end;

theorem Th96: :: FVSUM_1:96
for b1 being Nat
for b2 being non empty Abelian add-associative right_zeroed right_complementable LoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds Sum (b3 - b4) = (Sum b3) - (Sum b4)
proof end;

definition
canceled;
end;

:: deftheorem Def9 FVSUM_1:def 9 :
canceled;

theorem Th97: :: FVSUM_1:97
canceled;

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

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

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

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

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

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

theorem Th104: :: FVSUM_1:104
for b1 being non empty associative commutative left_unital doubleLoopStr
for b2, b3, b4 being Element of b1 holds Product <*b2,b3,b4*> = (b2 * b3) * b4
proof end;

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

theorem Th106: :: FVSUM_1:106
for b1 being Nat
for b2 being non empty associative commutative left_unital doubleLoopStr holds Product (b1 |-> (1. b2)) = 1. b2
proof end;

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

theorem Th108: :: FVSUM_1:108
for b1, b2 being Nat
for b3 being non empty associative commutative left_unital doubleLoopStr
for b4 being Element of b3 holds Product ((b1 + b2) |-> b4) = (Product (b1 |-> b4)) * (Product (b2 |-> b4))
proof end;

theorem Th109: :: FVSUM_1:109
for b1, b2 being Nat
for b3 being non empty associative commutative left_unital doubleLoopStr
for b4 being Element of b3 holds Product ((b1 * b2) |-> b4) = Product (b2 |-> (Product (b1 |-> b4)))
proof end;

theorem Th110: :: FVSUM_1:110
for b1 being Nat
for b2 being non empty associative commutative left_unital doubleLoopStr
for b3, b4 being Element of b2 holds Product (b1 |-> (b3 * b4)) = (Product (b1 |-> b3)) * (Product (b1 |-> b4))
proof end;

theorem Th111: :: FVSUM_1:111
for b1 being Nat
for b2 being non empty associative commutative left_unital doubleLoopStr
for b3, b4 being Element of b1 -tuples_on the carrier of b2 holds Product (mlt b3,b4) = (Product b3) * (Product b4)
proof end;

theorem Th112: :: FVSUM_1:112
for b1 being Nat
for b2 being non empty associative commutative left_unital doubleLoopStr
for b3 being Element of b2
for b4 being Element of b1 -tuples_on the carrier of b2 holds Product (b3 * b4) = (Product (b1 |-> b3)) * (Product b4)
proof end;

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

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

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

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

theorem Th115: :: FVSUM_1:115
for b1 being non empty associative commutative left_unital doubleLoopStr
for b2, b3 being FinSequence of the carrier of b1 holds b2 "*" b3 = b3 "*" b2 by Th78;