:: Abelian Groups, Fields and Vector Spaces
:: by Eugeniusz Kusak, Wojciech Leo\'nczuk and Micha{\l} Muzalewski
::
:: Copyright (c) 1990-2018 Association of Mizar Users

definition
func G_Real -> strict addLoopStr equals :: VECTSP_1:def 1
coherence
;
end;

:: deftheorem defines G_Real VECTSP_1:def 1 :

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

registration
coherence
the carrier of G_Real is real-membered
;
end;

registration
let a, b be Element of G_Real;
let x, y be Real;
identify a + b with x + y when a = x, b = y;
compatibility
( a = x & b = y implies a + b = x + y )
by BINOP_2:def 9;
end;

registration
coherence
proof end;
end;

registration
let a be Element of G_Real;
let x be Real;
identify - a with - x when a = x;
compatibility
( a = x implies - a = - x )
proof end;
end;

registration
let a, b be Element of G_Real;
let x, y be Real;
identify a - b with x - y when a = x, b = y;
compatibility
( a = x & b = y implies a - b = x - y )
;
end;

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

definition end;

definition end;

:: 4. FIELD STRUCTURE
definition
let IT be non empty doubleLoopStr ;
attr IT is right-distributive means :Def2: :: VECTSP_1:def 2
for a, b, c being Element of IT holds a * (b + c) = (a * b) + (a * c);
attr IT is left-distributive means :Def3: :: VECTSP_1:def 3
for a, b, c being Element of IT holds (b + c) * a = (b * a) + (c * a);
end;

:: deftheorem Def2 defines right-distributive VECTSP_1:def 2 :
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 Def3 defines left-distributive VECTSP_1:def 3 :
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 IT is right_unital means :Def4: :: VECTSP_1:def 4
for x being Element of IT holds x * (1. IT) = x;
end;

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

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

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

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

registration
coherence
the carrier of F_Real is real-membered
;
end;

registration
let a, b be Element of F_Real;
let x, y be Real;
identify a + b with x + y when a = x, b = y;
compatibility
( a = x & b = y implies a + b = x + y )
by BINOP_2:def 9;
end;

registration
let a, b be Element of F_Real;
let x, y be Real;
identify a * b with x * y when a = x, b = y;
compatibility
( a = x & b = y implies a * b = x * y )
by BINOP_2:def 11;
end;

definition
let IT be non empty multLoopStr ;
attr IT is well-unital means :Def6: :: VECTSP_1:def 6
for x being Element of IT holds
( x * (1. IT) = x & (1. IT) * x = x );
end;

:: deftheorem Def6 defines well-unital VECTSP_1:def 6 :
for IT being non empty multLoopStr holds
( IT is well-unital iff for x being Element of IT holds
( x * (1. IT) = x & (1. IT) * x = x ) );

Lm1: for L being non empty multLoopStr st L is well-unital holds
1. L = 1_ L

proof end;

registration
coherence ;
end;

registration
existence
ex b1 being non empty multLoopStr_0 st b1 is well-unital
proof end;
end;

registration
let L be non empty well-unital multLoopStr_0 ;
let x be Element of L;
reduce x * (1. L) to x;
reducibility
x * (1. L) = x
by Def6;
reduce (1. L) * x to x;
reducibility
(1. L) * x = x
by Def6;
end;

definition
let IT be non empty doubleLoopStr ;
attr IT is distributive means :Def7: :: VECTSP_1:def 7
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 Def7 defines distributive VECTSP_1:def 7 :
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 IT is left_unital means :Def8: :: VECTSP_1:def 8
for x being Element of IT holds (1. IT) * x = x;
end;

:: deftheorem Def8 defines left_unital VECTSP_1:def 8 :
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 ;
redefine attr IT is almost_left_invertible means :Def9: :: VECTSP_1:def 9
for x being Element of IT st x <> 0. IT holds
ex y being Element of IT st y * x = 1. IT;
compatibility
( IT is almost_left_invertible iff for x being Element of IT st x <> 0. IT holds
ex y being Element of IT st y * x = 1. IT )
proof end;
end;

:: deftheorem Def9 defines almost_left_invertible VECTSP_1:def 9 :
for IT being non empty multLoopStr_0 holds
( IT is almost_left_invertible iff for x being Element of IT st x <> 0. IT holds
ex y being Element of IT st y * x = 1. IT );

set FR = F_Real ;

reconsider jj = 1 as Real ;

registration
coherence
proof end;
end;

registration
coherence
proof end;
end;

registration
let a be Element of F_Real;
let x be Real;
identify - a with - x when a = x;
compatibility
( a = x implies - a = - x )
proof end;
end;

registration
let a, b be Element of F_Real;
let x, y be Real;
identify a - b with x - y when a = x, b = y;
compatibility
( a = x & b = y implies a - b = x - y )
;
end;

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

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

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

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

registration
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 almost_left_invertible & not b1 is degenerated & b1 is well-unital & b1 is strict )
proof end;
end;

definition end;

definition end;

definition end;

:: 6. AXIOMS OF FIELD
registration
cluster non empty well-unital -> non empty unital for multLoopStr ;
coherence
for b1 being non empty multLoopStr st b1 is well-unital holds
b1 is unital
;
end;

theorem :: VECTSP_1:1
canceled;

theorem :: VECTSP_1:2
canceled;

theorem :: VECTSP_1:3
canceled;

theorem :: VECTSP_1:4
canceled;

::$CT 4 theorem :: VECTSP_1:5 for F being non empty almost_left_invertible associative commutative well-unital distributive doubleLoopStr for x, y, z being Element of F st x <> 0. F & x * y = x * z holds y = z proof end; notation let F be non empty almost_left_invertible associative commutative well-unital doubleLoopStr ; let x be Element of F; synonym x " for / x; end; definition let F be non empty almost_left_invertible associative commutative well-unital doubleLoopStr ; let x be Element of F; assume A1: x <> 0. F ; redefine func / x means :Def10: :: VECTSP_1:def 10 it * x = 1. F; compatibility for b1 being Element of the carrier of F holds ( b1 = x " iff b1 * x = 1. F ) proof end; end; :: deftheorem Def10 defines " VECTSP_1:def 10 : for F being non empty almost_left_invertible associative commutative well-unital doubleLoopStr for x being Element of F st x <> 0. F holds for b3 being Element of the carrier of F holds ( b3 = x " iff b3 * x = 1. F ); registration let a be non zero Element of F_Real; let x be Real; identify a " with x " when a = x; compatibility ( a = x implies a " = x " ) proof end; end; registration let a, b be non zero Element of F_Real; let x, y be Real; identify a / b with x / y when a = x, b = y; compatibility ( a = x & b = y implies a / b = x / y ) ; end; canceled; :: definition :: let F be associative commutative well-unital distributive :: almost_left_invertible non empty doubleLoopStr, x,y be Element of F; :: func x/y ->Element of F equals :: x*y"; :: coherence; :: end; ::$CD
theorem Th2: :: VECTSP_1:6
for F being non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr
for x being Element of F holds x * (0. F) = 0. F
proof end;

registration
let F be non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr ;
let x be Element of F;
let y be zero Element of F;
reduce x * y to y;
reducibility
x * y = y
proof end;
end;

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

registration
let F be non empty right_complementable add-associative right_zeroed left-distributive doubleLoopStr ;
let x be zero Element of F;
let y be Element of F;
reduce x * y to x;
reducibility
x * y = x
proof end;
end;

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

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

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

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

theorem Th8: :: VECTSP_1:12
for F being non empty right_complementable almost_left_invertible add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
for x, y being Element of F holds
( x * y = 0. F iff ( x = 0. F or y = 0. F ) )
proof end;

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

:: 8. VECTOR SPACE STRUCTURE
definition
let F be 1-sorted ;
attr c2 is strict ;
struct ModuleStr over F -> addLoopStr ;
aggr ModuleStr(# carrier, addF, ZeroF, lmult #) -> ModuleStr over F;
sel lmult c2 -> Function of [: the carrier of F, the carrier of c2:], the carrier of c2;
end;

registration
let F be 1-sorted ;
cluster non empty strict for ModuleStr over F;
existence
ex b1 being ModuleStr over 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 ModuleStr(# A,a,Z,l #) -> non empty ;
coherence
not ModuleStr(# A,a,Z,l #) is empty
;
end;

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

definition
let F be 1-sorted ;
let VS be ModuleStr over F;
mode Scalar of VS is Scalar of F;
mode Vector of VS is Element of VS;
end;

definition
let F be non empty 1-sorted ;
let V be non empty ModuleStr over F;
let x be Element of F;
let v be Element of V;
func x * v -> Element of V equals :: VECTSP_1:def 11
the lmult of V . (x,v);
coherence
the lmult of V . (x,v) is Element of V
;
end;

:: deftheorem defines * VECTSP_1:def 11 :
for F being non empty 1-sorted
for V being non empty ModuleStr over 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 addLoopStr ;
func comp F -> UnOp of the carrier of F means :: VECTSP_1:def 12
for x being Element of F 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 defines comp VECTSP_1:def 12 :
for F being non empty addLoopStr
for b2 being UnOp of the carrier of F holds
( b2 = comp F iff for x being Element of F holds b2 . x = - x );

Lm2: now :: thesis: for F being non empty right_complementable Abelian add-associative right_zeroed associative distributive left_unital doubleLoopStr
for MLT being Function of [: the carrier of F, the carrier of F:], the carrier of F holds
( ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is Abelian & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is add-associative & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_zeroed & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_complementable )
let F be non empty right_complementable Abelian add-associative right_zeroed associative distributive left_unital doubleLoopStr ; :: thesis: for MLT being Function of [: the carrier of F, the carrier of F:], the carrier of F holds
( ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is Abelian & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is add-associative & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_zeroed & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_complementable )

let MLT be Function of [: the carrier of F, the carrier of F:], the carrier of F; :: thesis: ( ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is Abelian & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is add-associative & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_zeroed & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_complementable )
set GF = ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #);
thus ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is Abelian :: thesis: ( ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is add-associative & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_zeroed & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_complementable )
proof
let x, y be Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #); :: according to RLVECT_1:def 2 :: thesis: x + y = y + x
reconsider x9 = x, y9 = y as Element of F ;
thus x + y = y9 + x9 by RLVECT_1:2
.= y + x ; :: thesis: verum
end;
thus ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is add-associative :: thesis: ( ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_zeroed & ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_complementable )
proof
let x, y, z be Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #); :: according to RLVECT_1:def 3 :: thesis: (x + y) + z = x + (y + z)
reconsider x9 = x, y9 = y, z9 = z as Element of F ;
thus (x + y) + z = (x9 + y9) + z9
.= x9 + (y9 + z9) by RLVECT_1:def 3
.= x + (y + z) ; :: thesis: verum
end;
thus ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_zeroed :: thesis: ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_complementable
proof
let x be Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #); :: according to RLVECT_1:def 4 :: thesis: x + (0. ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #)) = x
reconsider x9 = x as Element of F ;
thus x + (0. ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #)) = x9 + (0. F)
.= x by RLVECT_1:4 ; :: thesis: verum
end;
thus ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) is right_complementable :: thesis: verum
proof
let x be Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #); :: according to ALGSTR_0:def 16 :: thesis:
reconsider x9 = x as Element of F ;
consider t being Element of F such that
A1: x9 + t = 0. F by ALGSTR_0:def 11;
reconsider t9 = t as Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) ;
take t9 ; :: according to ALGSTR_0:def 11 :: thesis: x + t9 = 0. ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #)
thus x + t9 = 0. ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) by A1; :: thesis: verum
end;
end;

Lm3: now :: thesis: for F being non empty right_complementable add-associative right_zeroed associative well-unital distributive doubleLoopStr
for MLT being Function of [: the carrier of F, the carrier of F:], the carrier of F st MLT = the multF of F holds
for x, y being Element of F
for v, w being Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) 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 )
let F be non empty right_complementable add-associative right_zeroed associative well-unital distributive doubleLoopStr ; :: thesis: for MLT being Function of [: the carrier of F, the carrier of F:], the carrier of F st MLT = the multF of F holds
for x, y being Element of F
for v, w being Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) 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 )

let MLT be Function of [: the carrier of F, the carrier of F:], the carrier of F; :: thesis: ( MLT = the multF of F implies for x, y being Element of F
for v, w being Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) 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 ) )

assume A1: MLT = the multF of F ; :: thesis: for x, y being Element of F
for v, w being Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) 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 )

let x, y be Element of F; :: thesis: for v, w being Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #) 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 )

set LS = ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #);
let v, w be Element of ModuleStr(# the carrier of F, the addF of F,(0. F),MLT #); :: thesis: ( x * (v + w) = (x * v) + (x * w) & (x + y) * v = (x * v) + (y * v) & (x * y) * v = x * (y * v) & (1. F) * v = v )
reconsider v9 = v, w9 = w as Element of F ;
thus x * (v + w) = x * (v9 + w9) by A1
.= (x * v9) + (x * w9) by Def7
.= (x * v) + (x * w) by A1 ; :: thesis: ( (x + y) * v = (x * v) + (y * v) & (x * y) * v = x * (y * v) & (1. F) * v = v )
thus (x + y) * v = (x + y) * v9 by A1
.= (x * v9) + (y * v9) by Def7
.= (x * v) + (y * v) by A1 ; :: thesis: ( (x * y) * v = x * (y * v) & (1. F) * v = v )
thus (x * y) * v = (x * y) * v9 by A1
.= x * (y * v9) by GROUP_1:def 3
.= x * (y * v) by A1 ; :: thesis: (1. F) * v = v
thus (1. F) * v = (1. F) * v9 by A1
.= v ; :: thesis: verum
end;

definition
let F be non empty doubleLoopStr ;
let IT be non empty ModuleStr over F;
attr IT is vector-distributive means :Def13: :: VECTSP_1:def 13
for x being Element of F
for v, w being Element of IT holds x * (v + w) = (x * v) + (x * w);
attr IT is scalar-distributive means :Def14: :: VECTSP_1:def 14
for x, y being Element of F
for v being Element of IT holds (x + y) * v = (x * v) + (y * v);
attr IT is scalar-associative means :Def15: :: VECTSP_1:def 15
for x, y being Element of F
for v being Element of IT holds (x * y) * v = x * (y * v);
attr IT is scalar-unital means :Def16: :: VECTSP_1:def 16
for v being Element of IT holds (1. F) * v = v;
end;

:: deftheorem Def13 defines vector-distributive VECTSP_1:def 13 :
for F being non empty doubleLoopStr
for IT being non empty ModuleStr over F holds
( IT is vector-distributive iff for x being Element of F
for v, w being Element of IT holds x * (v + w) = (x * v) + (x * w) );

:: deftheorem Def14 defines scalar-distributive VECTSP_1:def 14 :
for F being non empty doubleLoopStr
for IT being non empty ModuleStr over F holds
( IT is scalar-distributive iff for x, y being Element of F
for v being Element of IT holds (x + y) * v = (x * v) + (y * v) );

:: deftheorem Def15 defines scalar-associative VECTSP_1:def 15 :
for F being non empty doubleLoopStr
for IT being non empty ModuleStr over F holds
( IT is scalar-associative iff for x, y being Element of F
for v being Element of IT holds (x * y) * v = x * (y * v) );

:: deftheorem Def16 defines scalar-unital VECTSP_1:def 16 :
for F being non empty doubleLoopStr
for IT being non empty ModuleStr over F holds
( IT is scalar-unital iff for v being Element of IT holds (1. F) * v = v );

registration
let F be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr ;
existence
ex b1 being non empty ModuleStr over F st
( b1 is scalar-distributive & b1 is vector-distributive & b1 is scalar-associative & b1 is scalar-unital & b1 is add-associative & b1 is right_zeroed & b1 is right_complementable & b1 is Abelian & b1 is strict )
proof end;
end;

definition end;

theorem Th10: :: VECTSP_1:14
for F being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for x being Element of F
for V being non empty right_complementable add-associative right_zeroed vector-distributive scalar-distributive scalar-associative scalar-unital ModuleStr over 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 :: VECTSP_1:15
for F being Field
for x being Element of F
for V being VectSp of F
for v being Element of V holds
( x * v = 0. V iff ( x = 0. F or v = 0. V ) )
proof end;

:: 13. APPENDIX
theorem :: VECTSP_1:16
for v, w being Element of V holds
( v + w = 0. V iff - v = w )
proof end;

for v, w being Element of V holds - (w + (- v)) = v - w

proof end;

for v, w being Element of V holds - ((- v) - w) = w + v

proof end;

theorem :: VECTSP_1:17
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 ;

theorem :: VECTSP_1:18
for v being Element of V holds
( (0. V) - v = - v & v - (0. V) = v ) by ;

theorem Th15: :: VECTSP_1:19
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 :: VECTSP_1:20
for F being Field
for x being Element of F
for V being VectSp of F
for v being Element of V st x <> 0. F holds
(x ") * (x * v) = v
proof end;

theorem Th17: :: VECTSP_1:21
for F being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for V being non empty right_complementable add-associative right_zeroed vector-distributive scalar-distributive scalar-associative scalar-unital ModuleStr over 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
coherence
for b1 being non empty multLoopStr st b1 is commutative & b1 is left_unital holds
b1 is right_unital
proof end;
end;

theorem Th18: :: VECTSP_1:22
for F being non empty right_complementable Abelian add-associative right_zeroed associative right_unital well-unital distributive doubleLoopStr
for V being non empty right_complementable add-associative right_zeroed vector-distributive scalar-distributive scalar-associative scalar-unital ModuleStr over F
for x being Element of F
for v being Element of V holds x * (- v) = - (x * v)
proof end;

theorem :: VECTSP_1:23
for F being non empty right_complementable Abelian add-associative right_zeroed associative right_unital well-unital distributive doubleLoopStr
for V being non empty right_complementable add-associative right_zeroed vector-distributive scalar-distributive scalar-associative scalar-unital ModuleStr over 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 Th20: :: VECTSP_1:24
for F being non empty non degenerated right_complementable almost_left_invertible add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
for x being Element of F st x <> 0. F holds
(x ") " = x
proof end;

registration
let F be non degenerated right_complementable almost_left_invertible add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr ;
let x be non zero Element of F;
reduce (x ") " to x;
reducibility
(x ") " = x
proof end;
end;

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

theorem Th22: :: VECTSP_1:26
() + () <> 0. F_Real ;

definition
let IT be non empty addLoopStr ;
attr IT is Fanoian means :: VECTSP_1:def 17
for a being Element of IT st a + a = 0. IT holds
a = 0. IT;
end;

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

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

definition
let F be non empty non degenerated right_complementable almost_left_invertible add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr ;
redefine attr F is Fanoian means :: VECTSP_1:def 18
(1. F) + (1. F) <> 0. F;
compatibility
( F is Fanoian iff (1. F) + (1. F) <> 0. F )
proof end;
end;

:: deftheorem defines Fanoian VECTSP_1:def 18 :
for F being non empty non degenerated right_complementable almost_left_invertible add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr holds
( F is Fanoian iff (1. F) + (1. F) <> 0. F );

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

theorem :: VECTSP_1:27
for a, b being Element of F st a - b = 0. F holds
a = b by Th15;

theorem Th24: :: VECTSP_1:28
for a being Element of F st - a = 0. F holds
a = 0. F
proof end;

theorem :: VECTSP_1:29
for a, b being Element of F st a - b = 0. F holds
b - a = 0. F
proof end;

theorem :: VECTSP_1:30
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 :: VECTSP_1:31
for a, b being Element of F holds a + b = - ((- b) + (- a))
proof end;

theorem :: VECTSP_1:32
for a, b, c being Element of F holds (b + a) - (c + a) = b - c
proof end;

theorem :: VECTSP_1:33
for v, w being Element of G holds - ((- v) + w) = (- w) + v
proof end;

theorem :: VECTSP_1:34
for u, v, w being Element of G holds (u - v) - w = (u - w) - v
proof end;

theorem :: VECTSP_1:35
for B being AbGroup holds multMagma(# the carrier of B, the addF of B #) is commutative Group
proof end;

:: from COMPTRIG, 2006.08.12, A.T.
theorem :: VECTSP_1:36
for L being non empty right_complementable add-associative right_zeroed unital right-distributive doubleLoopStr
for n being Element of NAT st n > 0 holds
() . ((0. L),n) = 0. L
proof end;

:: 2007.02.14, A.T.
registration
existence
ex b1 being non empty multLoopStr st b1 is well-unital
proof end;
end;

registration
let S be non empty well-unital multLoopStr ;
identify 1_ S with 1. S;
compatibility
1_ S = 1. S
by Lm1;
end;

theorem :: VECTSP_1:37
for L being non empty multLoopStr st L is well-unital holds
1. L = 1_ L by Lm1;

definition
let G, H be non empty addMagma ;
let f be Function of G,H;
attr f is additive means :: VECTSP_1:def 19
for x, y being Element of G holds f . (x + y) = (f . x) + (f . y);
end;

:: deftheorem defines additive VECTSP_1:def 19 :
for G, H being non empty addMagma
for f being Function of G,H holds
( f is additive iff for x, y being Element of G holds f . (x + y) = (f . x) + (f . y) );

registration
let L be non empty right_unital multLoopStr ;
let x be Element of L;
reduce x * (1. L) to x;
reducibility
x * (1. L) = x
by Def4;
end;

registration
let L be non empty left_unital multLoopStr ;
let x be Element of L;
reduce (1. L) * x to x;
reducibility
(1. L) * x = x
by Def8;
end;