Article VECTSP_1, MML version 4.99.1005

:: VECTSP_1:funcnot 1 => VECTSP_1:func 1
definition
  func G_Real -> strict addLoopStr equals
    addLoopStr(#REAL,addreal,0#);
end;

:: VECTSP_1:def 6
theorem
G_Real = addLoopStr(#REAL,addreal,0#);

:: VECTSP_1:funcreg 1
registration
  cluster G_Real -> non empty strict;
end;

:: VECTSP_1:condreg 1
registration
  cluster -> real (Element of the carrier of G_Real);
end;

:: VECTSP_1:funcreg 2
registration
  cluster G_Real -> strict right_complementable Abelian add-associative right_zeroed;
end;

:: VECTSP_1:th 6
theorem
for b1, b2, b3 being Element of the carrier of G_Real holds
b1 + b2 = b2 + b1 &
 (b1 + b2) + b3 = b1 + (b2 + b3) &
 b1 + 0. G_Real = b1 &
 b1 + - b1 = 0. G_Real;

:: VECTSP_1:exreg 1
registration
  cluster non empty strict right_complementable Abelian add-associative right_zeroed addLoopStr;
end;

:: VECTSP_1:modenot 1
definition
  mode AddGroup is non empty right_complementable add-associative right_zeroed addLoopStr;
end;

:: VECTSP_1:modenot 2
definition
  mode AbGroup is non empty right_complementable Abelian add-associative right_zeroed addLoopStr;
end;

:: VECTSP_1:attrnot 1 => VECTSP_1:attr 1
definition
  let a1 be non empty doubleLoopStr;
  attr a1 is right-distributive means
    for b1, b2, b3 being Element of the carrier of a1 holds
    b1 * (b2 + b3) = (b1 * b2) + (b1 * b3);
end;

:: VECTSP_1:dfs 2
definiens
  let a1 be non empty doubleLoopStr;
To prove
     a1 is right-distributive
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    b1 * (b2 + b3) = (b1 * b2) + (b1 * b3);

:: VECTSP_1:def 11
theorem
for b1 being non empty doubleLoopStr holds
      b1 is right-distributive
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      b2 * (b3 + b4) = (b2 * b3) + (b2 * b4);

:: VECTSP_1:attrnot 2 => VECTSP_1:attr 2
definition
  let a1 be non empty doubleLoopStr;
  attr a1 is left-distributive means
    for b1, b2, b3 being Element of the carrier of a1 holds
    (b2 + b3) * b1 = (b2 * b1) + (b3 * b1);
end;

:: VECTSP_1:dfs 3
definiens
  let a1 be non empty doubleLoopStr;
To prove
     a1 is left-distributive
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    (b2 + b3) * b1 = (b2 * b1) + (b3 * b1);

:: VECTSP_1:def 12
theorem
for b1 being non empty doubleLoopStr holds
      b1 is left-distributive
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      (b3 + b4) * b2 = (b3 * b2) + (b4 * b2);

:: VECTSP_1:attrnot 3 => VECTSP_1:attr 3
definition
  let a1 be non empty multLoopStr;
  attr a1 is right_unital means
    for b1 being Element of the carrier of a1 holds
       b1 * 1. a1 = b1;
end;

:: VECTSP_1:dfs 4
definiens
  let a1 be non empty multLoopStr;
To prove
     a1 is right_unital
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 * 1. a1 = b1;

:: VECTSP_1:def 13
theorem
for b1 being non empty multLoopStr holds
      b1 is right_unital
   iff
      for b2 being Element of the carrier of b1 holds
         b2 * 1. b1 = b2;

:: VECTSP_1:funcnot 2 => VECTSP_1:func 2
definition
  func F_Real -> strict doubleLoopStr equals
    doubleLoopStr(#REAL,addreal,multreal,1,0#);
end;

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

:: VECTSP_1:funcreg 3
registration
  cluster F_Real -> non empty strict;
end;

:: VECTSP_1:condreg 2
registration
  cluster -> real (Element of the carrier of F_Real);
end;

:: VECTSP_1:attrnot 4 => VECTSP_1:attr 4
definition
  let a1 be non empty multLoopStr;
  attr a1 is well-unital means
    for b1 being Element of the carrier of a1 holds
       b1 * 1. a1 = b1 & (1. a1) * b1 = b1;
end;

:: VECTSP_1:dfs 6
definiens
  let a1 be non empty multLoopStr;
To prove
     a1 is well-unital
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 * 1. a1 = b1 & (1. a1) * b1 = b1;

:: VECTSP_1:def 16
theorem
for b1 being non empty multLoopStr holds
      b1 is well-unital
   iff
      for b2 being Element of the carrier of b1 holds
         b2 * 1. b1 = b2 & (1. b1) * b2 = b2;

:: VECTSP_1:funcreg 4
registration
  cluster F_Real -> strict well-unital;
end;

:: VECTSP_1:exreg 2
registration
  cluster non empty well-unital multLoopStr_0;
end;

:: VECTSP_1:attrnot 5 => VECTSP_1:attr 5
definition
  let a1 be non empty doubleLoopStr;
  attr a1 is distributive means
    for b1, b2, b3 being Element of the carrier of a1 holds
    b1 * (b2 + b3) = (b1 * b2) + (b1 * b3) &
     (b2 + b3) * b1 = (b2 * b1) + (b3 * b1);
end;

:: VECTSP_1:dfs 7
definiens
  let a1 be non empty doubleLoopStr;
To prove
     a1 is distributive
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1 holds
    b1 * (b2 + b3) = (b1 * b2) + (b1 * b3) &
     (b2 + b3) * b1 = (b2 * b1) + (b3 * b1);

:: VECTSP_1:def 18
theorem
for b1 being non empty doubleLoopStr holds
      b1 is distributive
   iff
      for b2, b3, b4 being Element of the carrier of b1 holds
      b2 * (b3 + b4) = (b2 * b3) + (b2 * b4) &
       (b3 + b4) * b2 = (b3 * b2) + (b4 * b2);

:: VECTSP_1:attrnot 6 => VECTSP_1:attr 6
definition
  let a1 be non empty multLoopStr;
  attr a1 is left_unital means
    for b1 being Element of the carrier of a1 holds
       (1. a1) * b1 = b1;
end;

:: VECTSP_1:dfs 8
definiens
  let a1 be non empty multLoopStr;
To prove
     a1 is left_unital
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       (1. a1) * b1 = b1;

:: VECTSP_1:def 19
theorem
for b1 being non empty multLoopStr holds
      b1 is left_unital
   iff
      for b2 being Element of the carrier of b1 holds
         (1. b1) * b2 = b2;

:: VECTSP_1:attrnot 7 => ALGSTR_0:attr 33
definition
  let a1 be multLoopStr_0;
  attr a1 is almost_left_invertible means
    for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds ex b2 being Element of the carrier of a1 st
          b2 * b1 = 1. a1;
end;

:: VECTSP_1:dfs 9
definiens
  let a1 be non empty multLoopStr_0;
To prove
     a1 is almost_left_invertible
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 <> 0. a1
       holds ex b2 being Element of the carrier of a1 st
          b2 * b1 = 1. a1;

:: VECTSP_1:def 20
theorem
for b1 being non empty multLoopStr_0 holds
      b1 is almost_left_invertible
   iff
      for b2 being Element of the carrier of b1
            st b2 <> 0. b1
         holds ex b3 being Element of the carrier of b1 st
            b3 * b2 = 1. b1;

:: VECTSP_1:funcreg 5
registration
  cluster F_Real -> strict unital;
end;

:: VECTSP_1:funcreg 6
registration
  cluster F_Real -> non degenerated right_complementable almost_left_invertible strict Abelian add-associative right_zeroed associative commutative right_unital distributive left_unital;
end;

:: VECTSP_1:condreg 3
registration
  cluster non empty distributive -> right-distributive left-distributive (doubleLoopStr);
end;

:: VECTSP_1:condreg 4
registration
  cluster non empty right-distributive left-distributive -> distributive (doubleLoopStr);
end;

:: VECTSP_1:condreg 5
registration
  cluster non empty well-unital -> right_unital left_unital (multLoopStr);
end;

:: VECTSP_1:condreg 6
registration
  cluster non empty right_unital left_unital -> unital (multLoopStr);
end;

:: VECTSP_1:exreg 3
registration
  cluster non empty associative commutative multMagma;
end;

:: VECTSP_1:exreg 4
registration
  cluster non empty unital associative commutative multLoopStr;
end;

:: VECTSP_1:exreg 5
registration
  cluster non empty non degenerated right_complementable almost_left_invertible strict Abelian add-associative right_zeroed associative commutative right_unital well-unital distributive left_unital doubleLoopStr;
end;

:: VECTSP_1:modenot 3
definition
  mode Field is non empty non degenerated right_complementable almost_left_invertible Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr;
end;

:: VECTSP_1:th 20
theorem
1. F_Real = 1;

:: VECTSP_1:th 21
theorem
for b1, b2, b3 being Element of the carrier of F_Real holds
b1 + b2 = b2 + b1 &
 (b1 + b2) + b3 = b1 + (b2 + b3) &
 b1 + 0. F_Real = b1 &
 b1 + - b1 = 0. F_Real &
 b1 * b2 = b2 * b1 &
 (b1 * b2) * b3 = b1 * (b2 * b3) &
 (1. F_Real) * b1 = b1 &
 (b1 <> 0. F_Real implies ex b4 being Element of the carrier of F_Real st
    b4 * b1 = 1. F_Real) &
 b1 * (b2 + b3) = (b1 * b2) + (b1 * b3) &
 (b2 + b3) * b1 = (b2 * b1) + (b3 * b1);

:: VECTSP_1:th 22
theorem
for b1 being non empty doubleLoopStr holds
      for b2, b3, b4 being Element of the carrier of b1 holds
      (b2 <> 0. b1 implies ex b5 being Element of the carrier of b1 st
          b5 * b2 = 1. b1) &
       b2 * (b3 + b4) = (b2 * b3) + (b2 * b4) &
       (b3 + b4) * b2 = (b3 * b2) + (b4 * b2)
   iff
      b1 is non empty almost_left_invertible distributive doubleLoopStr;

:: VECTSP_1:condreg 7
registration
  cluster non empty well-unital -> unital (multLoopStr);
end;

:: VECTSP_1:th 33
theorem
for b1 being non empty almost_left_invertible associative commutative well-unital distributive doubleLoopStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 <> 0. b1 & b2 * b3 = b2 * b4
   holds b3 = b4;

:: VECTSP_1:funcnot 3 => ALGSTR_0:func 11
definition
  let a1 be multLoopStr_0;
  let a2 be Element of the carrier of a1;
  assume a2 <> 0. a1;
  func A2 " -> Element of the carrier of a1 means
    it * a2 = 1. a1;
end;

:: VECTSP_1:def 22
theorem
for b1 being non empty almost_left_invertible associative commutative well-unital doubleLoopStr
for b2 being Element of the carrier of b1
   st b2 <> 0. b1
for b3 being Element of the carrier of b1 holds
      b3 = b2 "
   iff
      b3 * b2 = 1. b1;

:: VECTSP_1:funcnot 4 => VECTSP_1:func 3
definition
  let a1 be non empty almost_left_invertible associative commutative well-unital distributive doubleLoopStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 / A3 -> Element of the carrier of a1 equals
    a2 * (a3 ");
end;

:: VECTSP_1:def 23
theorem
for b1 being non empty almost_left_invertible associative commutative well-unital distributive doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
b2 / b3 = b2 * (b3 ");

:: VECTSP_1:th 36
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr
for b2 being Element of the carrier of b1 holds
   b2 * 0. b1 = 0. b1;

:: VECTSP_1:th 39
theorem
for b1 being non empty right_complementable add-associative right_zeroed left-distributive doubleLoopStr
for b2 being Element of the carrier of b1 holds
   (0. b1) * b2 = 0. b1;

:: VECTSP_1:th 40
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
b2 * - b3 = - (b2 * b3);

:: VECTSP_1:th 41
theorem
for b1 being non empty right_complementable add-associative right_zeroed left-distributive doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
(- b2) * b3 = - (b2 * b3);

:: VECTSP_1:th 42
theorem
for b1 being non empty right_complementable add-associative right_zeroed distributive doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
(- b2) * - b3 = b2 * b3;

:: VECTSP_1:th 43
theorem
for b1 being non empty right_complementable add-associative right_zeroed right-distributive doubleLoopStr
for b2, b3, b4 being Element of the carrier of b1 holds
b2 * (b3 - b4) = (b2 * b3) - (b2 * b4);

:: VECTSP_1:th 44
theorem
for b1 being non empty right_complementable almost_left_invertible add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
   b2 * b3 = 0. b1
iff
   (b2 = 0. b1 or b3 = 0. b1);

:: VECTSP_1:th 45
theorem
for b1 being non empty right_complementable add-associative right_zeroed left-distributive doubleLoopStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 - b3) * b4 = (b2 * b4) - (b3 * b4);

:: VECTSP_1:structnot 1 => VECTSP_1:struct 1
definition
  let a1 be 1-sorted;
  struct(addLoopStr) VectSpStr(#
    carrier -> set,
    addF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    ZeroF -> Element of the carrier of it,
    lmult -> Function-like quasi_total Relation of [:the carrier of A1,the carrier of it:],the carrier of it
  #);
end;

:: VECTSP_1:attrnot 8 => VECTSP_1:attr 7
definition
  let a1 be 1-sorted;
  let a2 be VectSpStr over a1;
  attr a2 is strict;
end;

:: VECTSP_1:exreg 6
registration
  let a1 be 1-sorted;
  cluster strict VectSpStr over a1;
end;

:: VECTSP_1:aggrnot 1 => VECTSP_1:aggr 1
definition
  let a1 be 1-sorted;
  let a2 be set;
  let a3 be Function-like quasi_total Relation of [:a2,a2:],a2;
  let a4 be Element of a2;
  let a5 be Function-like quasi_total Relation of [:the carrier of a1,a2:],a2;
  aggr VectSpStr(#a2,a3,a4,a5#) -> strict VectSpStr over a1;
end;

:: VECTSP_1:selnot 1 => VECTSP_1:sel 1
definition
  let a1 be 1-sorted;
  let a2 be VectSpStr over a1;
  sel the lmult of a2 -> Function-like quasi_total Relation of [:the carrier of a1,the carrier of a2:],the carrier of a2;
end;

:: VECTSP_1:exreg 7
registration
  let a1 be 1-sorted;
  cluster non empty strict VectSpStr over a1;
end;

:: VECTSP_1:funcreg 7
registration
  let a1 be 1-sorted;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of [:a2,a2:],a2;
  let a4 be Element of a2;
  let a5 be Function-like quasi_total Relation of [:the carrier of a1,a2:],a2;
  cluster VectSpStr(#a2,a3,a4,a5#) -> non empty strict;
end;

:: VECTSP_1:modenot 4
definition
  let a1 be 1-sorted;
  mode Scalar of a1 is Element of the carrier of a1;
end;

:: VECTSP_1:modenot 5
definition
  let a1 be 1-sorted;
  let a2 be VectSpStr over a1;
  mode Scalar of a2 is Element of the carrier of a1;
end;

:: VECTSP_1:modenot 6
definition
  let a1 be 1-sorted;
  let a2 be VectSpStr over a1;
  mode Vector of a2 is Element of the carrier of a2;
end;

:: VECTSP_1:funcnot 5 => VECTSP_1:func 4
definition
  let a1 be non empty 1-sorted;
  let a2 be non empty VectSpStr over a1;
  let a3 be Element of the carrier of a1;
  let a4 be Element of the carrier of a2;
  func A3 * A4 -> Element of the carrier of a2 equals
    (the lmult of a2) .(a3,a4);
end;

:: VECTSP_1:def 24
theorem
for b1 being non empty 1-sorted
for b2 being non empty VectSpStr over b1
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2 holds
   b3 * b4 = (the lmult of b2) .(b3,b4);

:: VECTSP_1:funcnot 6 => VECTSP_1:func 5
definition
  let a1 be non empty addLoopStr;
  func comp A1 -> Function-like quasi_total Relation of the carrier of a1,the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
       it . b1 = - b1;
end;

:: VECTSP_1:def 25
theorem
for b1 being non empty addLoopStr
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of b1 holds
      b2 = comp b1
   iff
      for b3 being Element of the carrier of b1 holds
         b2 . b3 = - b3;

:: VECTSP_1:attrnot 9 => VECTSP_1:attr 8
definition
  let a1 be non empty doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
  attr a2 is VectSp-like means
    for b1, b2 being Element of the carrier of a1
    for b3, b4 being Element of the carrier of a2 holds
    b1 * (b3 + b4) = (b1 * b3) + (b1 * b4) &
     (b1 + b2) * b3 = (b1 * b3) + (b2 * b3) &
     (b1 * b2) * b3 = b1 * (b2 * b3) &
     (1. a1) * b3 = b3;
end;

:: VECTSP_1:dfs 14
definiens
  let a1 be non empty doubleLoopStr;
  let a2 be non empty VectSpStr over a1;
To prove
     a2 is VectSp-like
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
    for b3, b4 being Element of the carrier of a2 holds
    b1 * (b3 + b4) = (b1 * b3) + (b1 * b4) &
     (b1 + b2) * b3 = (b1 * b3) + (b2 * b3) &
     (b1 * b2) * b3 = b1 * (b2 * b3) &
     (1. a1) * b3 = b3;

:: VECTSP_1:def 26
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty VectSpStr over b1 holds
      b2 is VectSp-like(b1)
   iff
      for b3, b4 being Element of the carrier of b1
      for b5, b6 being Element of the carrier of b2 holds
      b3 * (b5 + b6) = (b3 * b5) + (b3 * b6) &
       (b3 + b4) * b5 = (b3 * b5) + (b4 * b5) &
       (b3 * b4) * b5 = b3 * (b4 * b5) &
       (1. b1) * b5 = b5;

:: VECTSP_1:exreg 8
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  cluster non empty right_complementable Abelian add-associative right_zeroed strict VectSp-like VectSpStr over a1;
end;

:: VECTSP_1:modenot 7
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  mode VectSp of a1 is non empty right_complementable Abelian add-associative right_zeroed VectSp-like VectSpStr over a1;
end;

:: VECTSP_1:th 59
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b2 being Element of the carrier of b1
for b3 being non empty right_complementable add-associative right_zeroed VectSp-like VectSpStr over b1
for b4 being Element of the carrier of b3 holds
   (0. b1) * b4 = 0. b3 & (- 1. b1) * b4 = - b4 & b2 * 0. b3 = 0. b3;

:: VECTSP_1:th 60
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
for b2 being Element of the carrier of b1
for b3 being non empty right_complementable add-associative right_zeroed VectSp-like VectSpStr over b1
for b4 being Element of the carrier of b3 holds
      b2 * b4 = 0. b3
   iff
      (b2 = 0. b1 or b4 = 0. b3);

:: VECTSP_1:th 63
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1 holds
   b2 + b3 = 0. b1
iff
   - b2 = b3;

:: VECTSP_1:th 64
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2, b3, b4 being Element of the carrier of b1 holds
- (b3 + b4) = (- b4) - b3 &
 - (b4 + - b3) = b3 - b4 &
 - (b3 - b4) = b4 + - b3 &
 - ((- b3) - b4) = b4 + b3 &
 b2 - (b4 + b3) = (b2 - b3) - b4;

:: VECTSP_1:th 65
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2 being Element of the carrier of b1 holds
   (0. b1) - b2 = - b2 & b2 - 0. b1 = b2;

:: VECTSP_1:th 66
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1 holds
(b2 + - b3 = 0. b1 implies b2 = b3) &
 (b2 = b3 implies b2 + - b3 = 0. b1) &
 (b2 - b3 = 0. b1 implies b2 = b3) &
 (b2 = b3 implies b2 - b3 = 0. b1);

:: VECTSP_1:th 67
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
for b2 being Element of the carrier of b1
for b3 being non empty right_complementable add-associative right_zeroed VectSp-like VectSpStr over b1
for b4 being Element of the carrier of b3
      st b2 <> 0. b1
   holds b2 " * (b2 * b4) = b4;

:: VECTSP_1:th 68
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b2 being non empty right_complementable add-associative right_zeroed VectSp-like VectSpStr over b1
for b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of b2 holds
- (b3 * b4) = (- b3) * b4 &
 b5 - (b3 * b4) = b5 + ((- b3) * b4);

:: VECTSP_1:condreg 8
registration
  cluster non empty commutative left_unital -> right_unital (multLoopStr);
end;

:: VECTSP_1:th 69
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative right_unital well-unital distributive doubleLoopStr
for b2 being non empty right_complementable add-associative right_zeroed VectSp-like VectSpStr over b1
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2 holds
   b3 * - b4 = - (b3 * b4);

:: VECTSP_1:th 70
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative right_unital well-unital distributive doubleLoopStr
for b2 being non empty right_complementable add-associative right_zeroed VectSp-like VectSpStr over b1
for b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of b2 holds
b3 * (b4 - b5) = (b3 * b4) - (b3 * b5);

:: VECTSP_1:th 73
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
for b2 being Element of the carrier of b1
      st b2 <> 0. b1
   holds b2 " " = b2;

:: VECTSP_1:th 74
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
for b2 being Element of the carrier of b1
      st b2 <> 0. b1
   holds b2 " <> 0. b1 & - (b2 ") <> 0. b1;

:: VECTSP_1:th 78
theorem
(1. F_Real) + 1. F_Real <> 0. F_Real;

:: VECTSP_1:attrnot 10 => VECTSP_1:attr 9
definition
  let a1 be non empty addLoopStr;
  attr a1 is Fanoian means
    for b1 being Element of the carrier of a1
          st b1 + b1 = 0. a1
       holds b1 = 0. a1;
end;

:: VECTSP_1:dfs 15
definiens
  let a1 be non empty addLoopStr;
To prove
     a1 is Fanoian
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 + b1 = 0. a1
       holds b1 = 0. a1;

:: VECTSP_1:def 28
theorem
for b1 being non empty addLoopStr holds
      b1 is Fanoian
   iff
      for b2 being Element of the carrier of b1
            st b2 + b2 = 0. b1
         holds b2 = 0. b1;

:: VECTSP_1:exreg 9
registration
  cluster non empty Fanoian addLoopStr;
end;

:: VECTSP_1:attrnot 11 => VECTSP_1:attr 9
definition
  let a1 be non empty addLoopStr;
  attr a1 is Fanoian means
    (1. a1) + 1. a1 <> 0. a1;
end;

:: VECTSP_1:dfs 16
definiens
  let a1 be non empty non degenerated right_complementable almost_left_invertible add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr;
To prove
     a1 is Fanoian
it is sufficient to prove
  thus (1. a1) + 1. a1 <> 0. a1;

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

:: VECTSP_1:exreg 10
registration
  cluster non empty non degenerated non trivial right_complementable almost_left_invertible strict Abelian add-associative right_zeroed unital associative commutative right-distributive left-distributive right_unital well-unital distributive left_unital Fanoian doubleLoopStr;
end;

:: VECTSP_1:th 84
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1
      st b2 - b3 = 0. b1
   holds b2 = b3;

:: VECTSP_1:th 86
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2 being Element of the carrier of b1
      st - b2 = 0. b1
   holds b2 = 0. b1;

:: VECTSP_1:th 87
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1
      st b2 - b3 = 0. b1
   holds b3 - b2 = 0. b1;

:: VECTSP_1:th 88
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible Abelian add-associative right_zeroed associative commutative well-unital distributive doubleLoopStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 <> 0. b1 & (b2 * b4) - b3 = 0. b1 implies b4 = b3 * (b2 ")) &
 (b2 <> 0. b1 & b3 - (b4 * b2) = 0. b1 implies b4 = b3 * (b2 "));

:: VECTSP_1:th 89
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1 holds
b2 + b3 = - ((- b3) + - b2);

:: VECTSP_1:th 90
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b3 + b2) - (b4 + b2) = b3 - b4;

:: VECTSP_1:th 92
theorem
for b1 being non empty right_complementable add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1 holds
- ((- b2) + b3) = (- b3) + b2;

:: VECTSP_1:th 93
theorem
for b1 being non empty Abelian add-associative addLoopStr
for b2, b3, b4 being Element of the carrier of b1 holds
(b2 - b3) - b4 = (b2 - b4) - b3;

:: VECTSP_1:th 94
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr holds
   multMagma(#the carrier of b1,the addF of b1#) is non empty Group-like associative commutative multMagma;

:: VECTSP_1:th 95
theorem
for b1 being non empty right_complementable add-associative right_zeroed unital right-distributive doubleLoopStr
for b2 being Element of NAT
      st 0 < b2
   holds (power b1) .(0. b1,b2) = 0. b1;

:: VECTSP_1:exreg 11
registration
  cluster non empty well-unital multLoopStr;
end;

:: VECTSP_1:th 96
theorem
for b1 being non empty multLoopStr
      st b1 is well-unital
   holds 1. b1 = 1_ b1;