:: VECTSP_1 semantic presentation

definition
canceled;
canceled;
canceled;
canceled;
canceled;
func G_Real -> strict LoopStr equals :: VECTSP_1:def 6
LoopStr(# REAL ,addreal ,0 #);
coherence
LoopStr(# REAL ,addreal ,0 #) is strict LoopStr
;
end;

:: deftheorem Def1 VECTSP_1:def 1 :
canceled;

:: deftheorem Def2 VECTSP_1:def 2 :
canceled;

:: deftheorem Def3 VECTSP_1:def 3 :
canceled;

:: deftheorem Def4 VECTSP_1:def 4 :
canceled;

:: deftheorem Def5 VECTSP_1:def 5 :
canceled;

:: deftheorem Def6 defines G_Real VECTSP_1:def 6 :
G_Real = LoopStr(# REAL ,addreal ,0 #);

registration
cluster G_Real -> non empty strict ;
coherence
not G_Real is empty
;
end;

registration
cluster G_Real -> non empty strict Abelian add-associative right_zeroed right_complementable ;
coherence
( G_Real is Abelian & G_Real is add-associative & G_Real is right_zeroed & G_Real is right_complementable )
proof end;
end;

theorem Th1: :: VECTSP_1:1
canceled;

theorem Th2: :: VECTSP_1:2
canceled;

theorem Th3: :: VECTSP_1:3
canceled;

theorem Th4: :: VECTSP_1:4
canceled;

theorem Th5: :: VECTSP_1:5
canceled;

theorem Th6: :: VECTSP_1:6
for x, y, z being Element of G_Real holds
( x + y = y + x & (x + y) + z = x + (y + z) & x + (0. G_Real ) = x & x + (- x) = 0. G_Real ) by RLVECT_1:def 6, RLVECT_1:def 7, RLVECT_1:def 10;

registration
cluster non empty strict Abelian add-associative right_zeroed right_complementable LoopStr ;
existence
ex b1 being non empty LoopStr st
( b1 is strict & b1 is add-associative & b1 is right_zeroed & b1 is right_complementable & b1 is Abelian )
proof end;
end;

definition
mode AbGroup is non empty Abelian add-associative right_zeroed right_complementable LoopStr ;
end;

theorem Th7: :: VECTSP_1:7
for GS being non empty LoopStr holds
( ( for x, y, z being Element of GS holds
( x + y = y + x & (x + y) + z = x + (y + z) & x + (0. GS) = x & ex x' being Element of GS st x + x' = 0. GS ) ) iff GS is AbGroup ) by RLVECT_1:def 5, RLVECT_1:def 6, RLVECT_1:def 7, RLVECT_1:def 8;

definition
attr a1 is strict;
struct multLoopStr -> HGrStr ;
aggr multLoopStr(# carrier, mult, unity #) -> multLoopStr ;
sel unity c1 -> Element of the carrier of a1;
end;

registration
cluster non empty strict multLoopStr ;
existence
ex b1 being multLoopStr st
( not b1 is empty & b1 is strict )
proof end;
end;

definition
let FS be multLoopStr ;
canceled;
canceled;
func 1_ c1 -> Element of a1 equals :: VECTSP_1:def 9
the unity of FS;
coherence
the unity of FS is Element of FS
;
end;

:: deftheorem Def7 VECTSP_1:def 7 :
canceled;

:: deftheorem Def8 VECTSP_1:def 8 :
canceled;

:: deftheorem Def9 defines 1_ VECTSP_1:def 9 :
for FS being multLoopStr holds 1_ FS = the unity of FS;

definition
attr a1 is strict;
struct multLoopStr_0 -> multLoopStr , ZeroStr ;
aggr multLoopStr_0(# carrier, mult, unity, Zero #) -> multLoopStr_0 ;
end;

registration
cluster non empty strict multLoopStr_0 ;
existence
ex b1 being multLoopStr_0 st
( not b1 is empty & b1 is strict )
proof end;
end;

definition
attr a1 is strict;
struct doubleLoopStr -> LoopStr , multLoopStr_0 ;
aggr doubleLoopStr(# carrier, add, mult, unity, Zero #) -> doubleLoopStr ;
end;

registration
cluster non empty strict doubleLoopStr ;
existence
ex b1 being doubleLoopStr st
( not b1 is empty & b1 is strict )
proof end;
end;

definition
let IT be non empty doubleLoopStr ;
canceled;
attr a1 is right-distributive means :Def11: :: VECTSP_1:def 11
for a, b, c being Element of IT holds a * (b + c) = (a * b) + (a * c);
attr a1 is left-distributive means :Def12: :: VECTSP_1:def 12
for a, b, c being Element of IT holds (b + c) * a = (b * a) + (c * a);
end;

:: deftheorem Def10 VECTSP_1:def 10 :
canceled;

:: deftheorem Def11 defines right-distributive VECTSP_1:def 11 :
for IT being non empty doubleLoopStr holds
( IT is right-distributive iff for a, b, c being Element of IT holds a * (b + c) = (a * b) + (a * c) );

:: deftheorem Def12 defines left-distributive VECTSP_1:def 12 :
for IT being non empty doubleLoopStr holds
( IT is left-distributive iff for a, b, c being Element of IT holds (b + c) * a = (b * a) + (c * a) );

definition
let IT be non empty multLoopStr ;
attr a1 is right_unital means :Def13: :: VECTSP_1:def 13
for x being Element of IT holds x * (1. IT) = x;
end;

:: deftheorem Def13 defines right_unital VECTSP_1:def 13 :
for IT being non empty multLoopStr holds
( IT is right_unital iff for x being Element of IT holds x * (1. IT) = x );

definition
canceled;
func F_Real -> strict doubleLoopStr equals :: VECTSP_1:def 15
doubleLoopStr(# REAL ,addreal ,multreal ,1,0 #);
correctness
coherence
doubleLoopStr(# REAL ,addreal ,multreal ,1,0 #) is strict doubleLoopStr
;
;
end;

:: deftheorem Def14 VECTSP_1:def 14 :
canceled;

:: deftheorem Def15 defines F_Real VECTSP_1:def 15 :
F_Real = doubleLoopStr(# REAL ,addreal ,multreal ,1,0 #);

definition
let IT be non empty doubleLoopStr ;
canceled;
canceled;
attr a1 is distributive means :Def18: :: VECTSP_1:def 18
for x, y, z being Element of IT holds
( x * (y + z) = (x * y) + (x * z) & (y + z) * x = (y * x) + (z * x) );
end;

:: deftheorem Def16 VECTSP_1:def 16 :
canceled;

:: deftheorem Def17 VECTSP_1:def 17 :
canceled;

:: deftheorem Def18 defines distributive VECTSP_1:def 18 :
for IT being non empty doubleLoopStr holds
( IT is distributive iff for x, y, z being Element of IT holds
( x * (y + z) = (x * y) + (x * z) & (y + z) * x = (y * x) + (z * x) ) );

definition
let IT be non empty multLoopStr ;
attr a1 is left_unital means :Def19: :: VECTSP_1:def 19
for x being Element of IT holds (1. IT) * x = x;
end;

:: deftheorem Def19 defines left_unital VECTSP_1:def 19 :
for IT being non empty multLoopStr holds
( IT is left_unital iff for x being Element of IT holds (1. IT) * x = x );

definition
let IT be non empty multLoopStr_0 ;
attr a1 is Field-like means :Def20: :: VECTSP_1:def 20
for x being Element of IT st x <> 0. IT holds
ex y being Element of IT st x * y = 1. IT;
end;

:: deftheorem Def20 defines Field-like VECTSP_1:def 20 :
for IT being non empty multLoopStr_0 holds
( IT is Field-like iff for x being Element of IT st x <> 0. IT holds
ex y being Element of IT st x * y = 1. IT );

definition
let IT be non empty multLoopStr_0 ;
attr a1 is degenerated means :Def21: :: VECTSP_1:def 21
0. IT = 1. IT;
end;

:: deftheorem Def21 defines degenerated VECTSP_1:def 21 :
for IT being non empty multLoopStr_0 holds
( IT is degenerated iff 0. IT = 1. IT );

registration
cluster F_Real -> non empty strict ;
coherence
not F_Real is empty
proof end;
end;

set FR = F_Real ;

E44: now
let h be Element of F_Real , a be Element of F_Real ;
assume E46: a = 1 ;
reconsider g = h as Element of REAL ;
thus h * a = g * 1 by , BINOP_2:def 11
.= h ;
thus a * h = 1 * g by , BINOP_2:def 11
.= h ;
end;

registration
cluster F_Real -> non empty unital strict ;
coherence
F_Real is unital
proof end;
end;

Lemma49: 1. F_Real = 1
proof end;

registration
cluster F_Real -> non empty Abelian add-associative right_zeroed right_complementable unital associative commutative strict right_unital distributive left_unital Field-like non degenerated ;
coherence
( F_Real is add-associative & F_Real is right_zeroed & F_Real is right_complementable & F_Real is Abelian & F_Real is commutative & F_Real is associative & F_Real is left_unital & F_Real is right_unital & F_Real is distributive & F_Real is Field-like & not F_Real is degenerated )
proof end;
end;

Lemma50: for L being non empty doubleLoopStr st L is distributive holds
( L is right-distributive & L is left-distributive )
proof end;

registration
cluster non empty distributive -> non empty right-distributive left-distributive doubleLoopStr ;
coherence
for b1 being non empty doubleLoopStr st b1 is distributive holds
( b1 is left-distributive & b1 is right-distributive )
by ;
cluster non empty right-distributive left-distributive -> non empty distributive doubleLoopStr ;
coherence
for b1 being non empty doubleLoopStr st b1 is left-distributive & b1 is right-distributive holds
b1 is distributive
proof end;
end;

registration
cluster non empty unital -> non empty right_unital left_unital multLoopStr ;
coherence
for b1 being non empty multLoopStr st b1 is unital holds
( b1 is left_unital & b1 is right_unital )
proof end;
cluster non empty right_unital left_unital -> non empty unital multLoopStr ;
coherence
for b1 being non empty multLoopStr st b1 is left_unital & b1 is right_unital holds
b1 is unital
proof end;
end;

registration
cluster non empty associative commutative HGrStr ;
existence
ex b1 being non empty HGrStr st
( b1 is commutative & b1 is associative )
proof end;
end;

registration
cluster non empty unital associative commutative right_unital left_unital multLoopStr ;
existence
ex b1 being non empty multLoopStr st
( b1 is commutative & b1 is associative & b1 is unital )
proof end;
end;

registration
cluster non empty Abelian add-associative right_zeroed right_complementable unital associative commutative strict right-distributive left-distributive right_unital distributive left_unital Field-like non degenerated doubleLoopStr ;
existence
ex b1 being non empty doubleLoopStr st
( b1 is add-associative & b1 is right_zeroed & b1 is right_complementable & b1 is Abelian & b1 is commutative & b1 is associative & b1 is left_unital & b1 is right_unital & b1 is distributive & b1 is Field-like & not b1 is degenerated & b1 is strict )
proof end;
end;

definition
mode Field is non empty Abelian add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr ;
end;

theorem Th8: :: VECTSP_1:8
canceled;

theorem Th9: :: VECTSP_1:9
canceled;

theorem Th10: :: VECTSP_1:10
canceled;

theorem Th11: :: VECTSP_1:11
canceled;

theorem Th12: :: VECTSP_1:12
canceled;

theorem Th13: :: VECTSP_1:13
canceled;

theorem Th14: :: VECTSP_1:14
canceled;

theorem Th15: :: VECTSP_1:15
canceled;

theorem Th16: :: VECTSP_1:16
canceled;

theorem Th17: :: VECTSP_1:17
canceled;

theorem Th18: :: VECTSP_1:18
canceled;

theorem Th19: :: VECTSP_1:19
canceled;

theorem Th20: :: VECTSP_1:20
1. F_Real = 1 by ;

theorem Th21: :: VECTSP_1:21
for x, y, z being Element of F_Real holds
( x + y = y + x & (x + y) + z = x + (y + z) & x + (0. F_Real ) = x & x + (- x) = 0. F_Real & x * y = y * x & (x * y) * z = x * (y * z) & (1. F_Real ) * x = x & ( x <> 0. F_Real implies ex y being Element of F_Real st x * y = 1. F_Real ) & x * (y + z) = (x * y) + (x * z) & (y + z) * x = (y * x) + (z * x) ) by , , , GROUP_1:def 4, RLVECT_1:def 6, RLVECT_1:def 7, RLVECT_1:def 10;

theorem Th22: :: VECTSP_1:22
for FS being non empty doubleLoopStr holds
( ( for x, y, z being Element of FS holds
( ( x <> 0. FS implies ex y being Element of FS st x * y = 1. FS ) & x * (y + z) = (x * y) + (x * z) & (y + z) * x = (y * x) + (z * x) ) ) iff FS is non empty distributive Field-like doubleLoopStr ) by , ;

theorem Th23: :: VECTSP_1:23
canceled;

theorem Th24: :: VECTSP_1:24
canceled;

theorem Th25: :: VECTSP_1:25
canceled;

theorem Th26: :: VECTSP_1:26
canceled;

theorem Th27: :: VECTSP_1:27
canceled;

theorem Th28: :: VECTSP_1:28
canceled;

theorem Th29: :: VECTSP_1:29
canceled;

theorem Th30: :: VECTSP_1:30
canceled;

theorem Th31: :: VECTSP_1:31
canceled;

theorem Th32: :: VECTSP_1:32
canceled;

theorem Th33: :: VECTSP_1:33
for F being non empty associative commutative distributive left_unital Field-like doubleLoopStr
for x, y, z being Element of F st x <> 0. F & x * y = x * z holds
y = z
proof end;

definition
let F be non empty associative commutative distributive left_unital Field-like doubleLoopStr ;
let x be Element of F;
assume E46: x <> 0. F ;
func c2 " -> Element of a1 means :Def22: :: VECTSP_1:def 22
F * it = 1. FR;
existence
ex b1 being Element of F st x * b1 = 1. F
by , ;
uniqueness
for b1, b2 being Element of F st x * b1 = 1. F & x * b2 = 1. F holds
b1 = b2
by , ;
end;

:: deftheorem Def22 defines " VECTSP_1:def 22 :
for F being non empty associative commutative distributive left_unital Field-like doubleLoopStr
for x being Element of F st x <> 0. F holds
for b3 being Element of F holds
( b3 = x " iff x * b3 = 1. F );

definition
let F be non empty associative commutative distributive left_unital Field-like doubleLoopStr ;
let x be Element of F, y be Element of F;
func c2 / c3 -> Element of a1 equals :: VECTSP_1:def 23
F * (x " );
coherence
x * (y " ) is Element of F
;
end;

:: deftheorem Def23 defines / VECTSP_1:def 23 :
for F being non empty associative commutative distributive left_unital Field-like doubleLoopStr
for x, y being Element of F holds x / y = x * (y " );

theorem Th34: :: VECTSP_1:34
canceled;

theorem Th35: :: VECTSP_1:35
canceled;

theorem Th36: :: VECTSP_1:36
for F being non empty add-associative right_zeroed right_complementable right-distributive doubleLoopStr
for x being Element of F holds x * (0. F) = 0. F
proof end;

theorem Th37: :: VECTSP_1:37
canceled;

theorem Th38: :: VECTSP_1:38
canceled;

theorem Th39: :: VECTSP_1:39
for F being non empty add-associative right_zeroed right_complementable left-distributive doubleLoopStr
for x being Element of F holds (0. F) * x = 0. F
proof end;

theorem Th40: :: VECTSP_1:40
for F being non empty add-associative right_zeroed right_complementable right-distributive doubleLoopStr
for x, y being Element of F holds x * (- y) = - (x * y)
proof end;

theorem Th41: :: VECTSP_1:41
for F being non empty add-associative right_zeroed right_complementable left-distributive doubleLoopStr
for x, y being Element of F holds (- x) * y = - (x * y)
proof end;

theorem Th42: :: VECTSP_1:42
for F being non empty add-associative right_zeroed right_complementable distributive doubleLoopStr
for x, y being Element of F holds (- x) * (- y) = x * y
proof end;

theorem Th43: :: VECTSP_1:43
for F being non empty add-associative right_zeroed right_complementable right-distributive doubleLoopStr
for x, y, z being Element of F holds x * (y - z) = (x * y) - (x * z)
proof end;

theorem Th44: :: VECTSP_1:44
for F being non empty add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like doubleLoopStr
for x, y being Element of F holds
( x * y = 0. F iff ( x = 0. F or y = 0. F ) )
proof end;

theorem Th45: :: VECTSP_1:45
for K being non empty add-associative right_zeroed right_complementable left-distributive doubleLoopStr
for a, b, c being Element of K holds (a - b) * c = (a * c) - (b * c)
proof end;

definition
let F be 1-sorted ;
attr a2 is strict;
struct VectSpStr of c1 -> LoopStr ;
aggr VectSpStr(# carrier, add, Zero, lmult #) -> VectSpStr of a1;
sel lmult c2 -> Function of [:the carrier of a1,the carrier of a2:],the carrier of a2;
end;

registration
let F be 1-sorted ;
cluster non empty strict VectSpStr of a1;
existence
ex b1 being VectSpStr of F st
( not b1 is empty & b1 is strict )
proof end;
end;

registration
let F be 1-sorted ;
let A be non empty set ;
let a be BinOp of A;
let Z be Element of A;
let l be Function of [:the carrier of F,A:],A;
cluster VectSpStr(# a2,a3,a4,a5 #) -> non empty ;
coherence
not VectSpStr(# A,a,Z,l #) is empty
proof end;
end;

definition
let F be 1-sorted ;
mode Scalar of a1 is Element of a1;
end;

definition
let F be 1-sorted ;
let VS be VectSpStr of F;
mode Scalar of a2 is Scalar of a1;
mode Vector of a2 is Element of a2;
end;

definition
let F be non empty 1-sorted ;
let V be non empty VectSpStr of F;
let x be Element of F;
let v be Element of V;
func c3 * c4 -> Element of a2 equals :: VECTSP_1:def 24
the lmult of F . V,x;
coherence
the lmult of V . x,v is Element of V
;
end;

:: deftheorem Def24 defines * VECTSP_1:def 24 :
for F being non empty 1-sorted
for V being non empty VectSpStr of F
for x being Element of F
for v being Element of V holds x * v = the lmult of V . x,v;

definition
let F be non empty LoopStr ;
func comp c1 -> UnOp of the carrier of a1 means :: VECTSP_1:def 25
for x being Element of FR holds it . x = - x;
existence
ex b1 being UnOp of the carrier of F st
for x being Element of F holds b1 . x = - x
proof end;
uniqueness
for b1, b2 being UnOp of the carrier of F st ( for x being Element of F holds b1 . x = - x ) & ( for x being Element of F holds b2 . x = - x ) holds
b1 = b2
proof end;
end;

:: deftheorem Def25 defines comp VECTSP_1:def 25 :
for F being non empty LoopStr
for b2 being UnOp of the carrier of F holds
( b2 = comp F iff for x being Element of F holds b2 . x = - x );

E72: now
let F be non empty Abelian add-associative right_zeroed right_complementable associative distributive left_unital doubleLoopStr ;
let MLT be Function of [:the carrier of F,the carrier of F:],the carrier of F;
set GF = VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #);
for x, y, z being Element of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) holds
( x + y = y + x & (x + y) + z = x + (y + z) & x + (0. VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #)) = x & ex x' being Element of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) st x + x' = 0. VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) )
proof
let x be Element of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #), y be Element of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #), z be Element of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #);
reconsider x' = x, y' = y, z' = z as Element of F ;
thus x + y = the add of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) . x,y by RLVECT_1:5
.= y' + x' by RLVECT_1:5
.= the add of F . y',x' by RLVECT_1:5
.= y + x by RLVECT_1:5 ;
thus (x + y) + z = the add of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) . (x + y),z by RLVECT_1:5
.= the add of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) . (the add of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) . x,y),z by RLVECT_1:5
.= the add of F . (x' + y'),z' by RLVECT_1:5
.= (x' + y') + z' by RLVECT_1:5
.= x' + (y' + z') by RLVECT_1:def 6
.= the add of F . x',(y' + z') by RLVECT_1:5
.= the add of F . x',(the add of F . y',z') by RLVECT_1:5
.= the add of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) . x,(y + z) by RLVECT_1:5
.= x + (y + z) by RLVECT_1:5 ;
thus x + (0. VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #)) = the add of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) . x,(0. VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #)) by RLVECT_1:5
.= x' + (0. F) by RLVECT_1:5
.= x by RLVECT_1:10 ;
consider t being Element of F such that
E46: x' + t = 0. F by RLVECT_1:def 8;
reconsider t' = t as Element of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) ;
take t' ;
thus x + t' = the add of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) . x,t' by RLVECT_1:5
.= 0. VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) by RLVECT_1:5, ;
end;
hence VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #) is AbGroup by RLVECT_1:def 5, RLVECT_1:def 6, RLVECT_1:def 7, RLVECT_1:def 8;
end;

E77: now
let F be non empty add-associative right_zeroed right_complementable associative distributive left_unital doubleLoopStr ;
let MLT be Function of [:the carrier of F,the carrier of F:],the carrier of F;
assume E46: MLT = the mult of F ;
set LS = VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #);
let x be Element of F, y be Element of F;
let v be Element of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #), w be Element of VectSpStr(# the carrier of F,the add of F,the Zero of F,MLT #);
reconsider v' = v, w' = w as Element of F ;
thus x * (v + w) = MLT . x,(the add of F . v',w') by RLVECT_1:5
.= x * (v' + w') by RLVECT_1:5,
.= (x * v') + (x * w') by
.= the add of F . (MLT . x,v'),(x * w') by RLVECT_1:5,
.= (x * v) + (x * w) by , RLVECT_1:5 ;
thus (x + y) * v = (x + y) * v' by
.= (x * v') + (y * v') by
.= the add of F . (MLT . x,v'),(y * v') by RLVECT_1:5,
.= (x * v) + (y * v) by , RLVECT_1:5 ;
thus (x * y) * v = (x * y) * v' by
.= x * (y * v') by GROUP_1:def 4
.= x * (y * v) by ;
thus (1. F) * v = (1. F) * v' by
.= v by ;
end;

definition
let F be non empty doubleLoopStr ;
let IT be non empty VectSpStr of F;
attr a2 is VectSp-like means :Def26: :: VECTSP_1:def 26
for x, y being Element of FR
for v, w being Element of F holds
( x * (v + w) = (x * v) + (x * w) & (x + y) * v = (x * v) + (y * v) & (x * y) * v = x * (y * v) & (1. FR) * v = v );
end;

:: deftheorem Def26 defines VectSp-like VECTSP_1:def 26 :
for F being non empty doubleLoopStr
for IT being non empty VectSpStr of F holds
( IT is VectSp-like iff for x, y being Element of F
for v, w being Element of IT holds
( x * (v + w) = (x * v) + (x * w) & (x + y) * v = (x * v) + (y * v) & (x * y) * v = x * (y * v) & (1. F) * v = v ) );

registration
let F be non empty Abelian add-associative right_zeroed right_complementable associative distributive left_unital doubleLoopStr ;
cluster non empty Abelian add-associative right_zeroed right_complementable strict VectSp-like VectSpStr of a1;
existence
ex b1 being non empty VectSpStr of F st
( b1 is VectSp-like & b1 is add-associative & b1 is right_zeroed & b1 is right_complementable & b1 is Abelian & b1 is strict )
proof end;
end;

definition
let F be non empty Abelian add-associative right_zeroed right_complementable associative distributive left_unital doubleLoopStr ;
mode VectSp of a1 is non empty Abelian add-associative right_zeroed right_complementable VectSp-like VectSpStr of a1;
end;

theorem Th46: :: VECTSP_1:46
canceled;

theorem Th47: :: VECTSP_1:47
canceled;

theorem Th48: :: VECTSP_1:48
canceled;

theorem Th49: :: VECTSP_1:49
canceled;

theorem Th50: :: VECTSP_1:50
canceled;

theorem Th51: :: VECTSP_1:51
canceled;

theorem Th52: :: VECTSP_1:52
canceled;

theorem Th53: :: VECTSP_1:53
canceled;

theorem Th54: :: VECTSP_1:54
canceled;

theorem Th55: :: VECTSP_1:55
canceled;

theorem Th56: :: VECTSP_1:56
canceled;

theorem Th57: :: VECTSP_1:57
canceled;

theorem Th58: :: VECTSP_1:58
canceled;

theorem Th59: :: VECTSP_1:59
for F being non empty Abelian add-associative right_zeroed right_complementable associative distributive left_unital doubleLoopStr
for x being Element of F
for V being non empty add-associative right_zeroed right_complementable VectSp-like VectSpStr of F
for v being Element of V holds
( (0. F) * v = 0. V & (- (1. F)) * v = - v & x * (0. V) = 0. V )
proof end;

theorem Th60: :: VECTSP_1:60
for F being Field
for x being Element of F
for V being non empty add-associative right_zeroed right_complementable VectSp-like VectSpStr of F
for v being Element of V holds
( x * v = 0. V iff ( x = 0. F or v = 0. V ) )
proof end;

theorem Th61: :: VECTSP_1:61
canceled;

theorem Th62: :: VECTSP_1:62
canceled;

theorem Th63: :: VECTSP_1:63
for V being non empty add-associative right_zeroed right_complementable LoopStr
for v, w being Element of V holds
( v + w = 0. V iff - v = w )
proof end;

Lemma84: for V being non empty add-associative right_zeroed right_complementable LoopStr
for v, w being Element of V holds - (w + (- v)) = v - w
proof end;

Lemma85: for V being non empty add-associative right_zeroed right_complementable LoopStr
for v, w being Element of V holds - ((- v) - w) = w + v
proof end;

theorem Th64: :: VECTSP_1:64
for V being non empty add-associative right_zeroed right_complementable LoopStr
for u, v, w being Element of V holds
( - (v + w) = (- w) - v & - (w + (- v)) = v - w & - (v - w) = w + (- v) & - ((- v) - w) = w + v & u - (w + v) = (u - v) - w ) by , , RLVECT_1:41, RLVECT_1:44, RLVECT_1:47;

theorem Th65: :: VECTSP_1:65
for V being non empty add-associative right_zeroed right_complementable LoopStr
for v being Element of V holds
( (0. V) - v = - v & v - (0. V) = v ) by RLVECT_1:26, RLVECT_1:27;

theorem Th66: :: VECTSP_1:66
for F being non empty add-associative right_zeroed right_complementable LoopStr
for x, y being Element of F holds
( ( x + (- y) = 0. F implies x = y ) & ( x = y implies x + (- y) = 0. F ) & ( x - y = 0. F implies x = y ) & ( x = y implies x - y = 0. F ) )
proof end;

theorem Th67: :: VECTSP_1:67
for F being Field
for x being Element of F
for V being non empty add-associative right_zeroed right_complementable VectSp-like VectSpStr of F
for v being Element of V st x <> 0. F holds
(x " ) * (x * v) = v
proof end;

theorem Th68: :: VECTSP_1:68
for F being non empty Abelian add-associative right_zeroed right_complementable associative distributive left_unital doubleLoopStr
for V being non empty add-associative right_zeroed right_complementable VectSp-like VectSpStr of F
for x being Element of F
for v, w being Element of V holds
( - (x * v) = (- x) * v & w - (x * v) = w + ((- x) * v) )
proof end;

registration
cluster non empty commutative left_unital -> non empty right_unital multLoopStr ;
coherence
for b1 being non empty multLoopStr st b1 is commutative & b1 is left_unital holds
b1 is right_unital
proof end;
end;

theorem Th69: :: VECTSP_1:69
for F being non empty Abelian add-associative right_zeroed right_complementable associative right_unital distributive left_unital doubleLoopStr
for V being non empty add-associative right_zeroed right_complementable VectSp-like VectSpStr of F
for x being Element of F
for v being Element of V holds x * (- v) = - (x * v)
proof end;

theorem Th70: :: VECTSP_1:70
for F being non empty Abelian add-associative right_zeroed right_complementable associative right_unital distributive left_unital doubleLoopStr
for V being non empty add-associative right_zeroed right_complementable VectSp-like VectSpStr of F
for x being Element of F
for v, w being Element of V holds x * (v - w) = (x * v) - (x * w)
proof end;

theorem Th71: :: VECTSP_1:71
canceled;

theorem Th72: :: VECTSP_1:72
canceled;

theorem Th73: :: VECTSP_1:73
for F being non empty add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr
for x being Element of F st x <> 0. F holds
(x " ) " = x
proof end;

theorem Th74: :: VECTSP_1:74
for F being Field
for x being Element of F st x <> 0. F holds
( x " <> 0. F & - (x " ) <> 0. F )
proof end;

theorem Th75: :: VECTSP_1:75
canceled;

theorem Th76: :: VECTSP_1:76
canceled;

theorem Th77: :: VECTSP_1:77
canceled;

theorem Th78: :: VECTSP_1:78
(1. F_Real ) + (1. F_Real ) <> 0. F_Real
proof end;

definition
let IT be non empty LoopStr ;
canceled;
attr a1 is Fanoian means :Def28: :: VECTSP_1:def 28
for a being Element of FR st a + a = 0. FR holds
a = 0. FR;
end;

:: deftheorem Def27 VECTSP_1:def 27 :
canceled;

:: deftheorem Def28 defines Fanoian VECTSP_1:def 28 :
for IT being non empty LoopStr holds
( IT is Fanoian iff for a being Element of IT st a + a = 0. IT holds
a = 0. IT );

registration
cluster non empty Fanoian LoopStr ;
existence
ex b1 being non empty LoopStr st b1 is Fanoian
proof end;
end;

definition
let F be non empty add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr ;
redefine attr a1 is Fanoian means :Def29: :: VECTSP_1:def 29
(1. FR) + (1. FR) <> 0. FR;
compatibility
( F is Fanoian iff (1. F) + (1. F) <> 0. F )
proof end;
end;

:: deftheorem Def29 defines Fanoian VECTSP_1:def 29 :
for F being non empty add-associative right_zeroed right_complementable associative commutative distributive left_unital Field-like non degenerated doubleLoopStr holds
( F is Fanoian iff (1. F) + (1. F) <> 0. F );

registration
cluster unital strict right_unital Fanoian doubleLoopStr ;
existence
ex b1 being Field st
( b1 is strict & b1 is Fanoian )
proof end;
end;

theorem Th79: :: VECTSP_1:79
canceled;

theorem Th80: :: VECTSP_1:80
canceled;

theorem Th81: :: VECTSP_1:81
for F being non empty add-associative right_zeroed right_complementable LoopStr
for a, b being Element of F holds - (a - b) = b - a by RLVECT_1:47;

theorem Th82: :: VECTSP_1:82
canceled;

theorem Th83: :: VECTSP_1:83
canceled;

theorem Th84: :: VECTSP_1:84
for F being non empty add-associative right_zeroed right_complementable LoopStr
for a, b being Element of F st a - b = 0. F holds
a = b by ;

theorem Th85: :: VECTSP_1:85
canceled;

theorem Th86: :: VECTSP_1:86
for F being non empty add-associative right_zeroed right_complementable LoopStr
for a being Element of F st - a = 0. F holds
a = 0. F
proof end;

theorem Th87: :: VECTSP_1:87
for F being non empty add-associative right_zeroed right_complementable LoopStr
for a, b being Element of F st a - b = 0. F holds
b - a = 0. F
proof end;

theorem Th88: :: VECTSP_1:88
for F being Field
for a, b, c being Element of F holds
( ( a <> 0. F & (a * c) - b = 0. F implies c = b * (a " ) ) & ( a <> 0. F & b - (c * a) = 0. F implies c = b * (a " ) ) )
proof end;

theorem Th89: :: VECTSP_1:89
for F being non empty add-associative right_zeroed right_complementable LoopStr
for a, b being Element of F holds a + b = - ((- b) + (- a))
proof end;

theorem Th90: :: VECTSP_1:90
for F being non empty add-associative right_zeroed right_complementable LoopStr
for a, b, c being Element of F holds (b + a) - (c + a) = b - c
proof end;

theorem Th91: :: VECTSP_1:91
canceled;

theorem Th92: :: VECTSP_1:92
for G being non empty add-associative right_zeroed right_complementable LoopStr
for v, w being Element of G holds - ((- v) + w) = (- w) + v
proof end;

theorem Th93: :: VECTSP_1:93
for G being non empty Abelian add-associative LoopStr
for u, v, w being Element of G holds (u - v) - w = (u - w) - v
proof end;

theorem Th94: :: VECTSP_1:94
for B being AbGroup holds HGrStr(# the carrier of B,the add of B #) is commutative Group
proof end;

theorem Th95: :: VECTSP_1:95
for L being non empty add-associative right_zeroed right_complementable unital right-distributive doubleLoopStr
for n being Element of NAT st n > 0 holds
(power L) . (0. L),n = 0. L
proof end;