Article VECTSP_2, MML version 4.99.1005

:: VECTSP_2:exreg 1
registration
  cluster non empty right_complementable strict unital distributive Abelian add-associative right_zeroed doubleLoopStr;
end;

:: VECTSP_2:exreg 2
registration
  cluster non empty right_complementable strict unital associative right-distributive left-distributive right_unital well-unital distributive left_unital Abelian add-associative right_zeroed doubleLoopStr;
end;

:: VECTSP_2:exreg 3
registration
  cluster non empty right_complementable unital associative commutative right-distributive left-distributive right_unital well-unital distributive left_unital Abelian add-associative right_zeroed doubleLoopStr;
end;

:: VECTSP_2:modenot 1
definition
  mode comRing is non empty right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
end;

:: VECTSP_2:exreg 4
registration
  cluster non empty right_complementable strict unital associative commutative right-distributive left-distributive right_unital well-unital distributive left_unital Abelian add-associative right_zeroed doubleLoopStr;
end;

:: VECTSP_2:attrnot 1 => VECTSP_2:attr 1
definition
  let a1 be non empty multLoopStr_0;
  attr a1 is domRing-like means
    for b1, b2 being Element of the carrier of a1
          st b1 * b2 = 0. a1 & b1 <> 0. a1
       holds b2 = 0. a1;
end;

:: VECTSP_2:dfs 1
definiens
  let a1 be non empty multLoopStr_0;
To prove
     a1 is domRing-like
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 * b2 = 0. a1 & b1 <> 0. a1
       holds b2 = 0. a1;

:: VECTSP_2:def 5
theorem
for b1 being non empty multLoopStr_0 holds
      b1 is domRing-like
   iff
      for b2, b3 being Element of the carrier of b1
            st b2 * b3 = 0. b1 & b2 <> 0. b1
         holds b3 = 0. b1;

:: VECTSP_2:exreg 5
registration
  cluster non empty non degenerated right_complementable strict unital associative commutative right-distributive left-distributive right_unital well-unital distributive left_unital Abelian add-associative right_zeroed domRing-like doubleLoopStr;
end;

:: VECTSP_2:modenot 2
definition
  mode domRing is non empty non degenerated right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed domRing-like doubleLoopStr;
end;

:: VECTSP_2:th 13
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
   b1 is non empty non degenerated right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed domRing-like doubleLoopStr;

:: VECTSP_2:exreg 6
registration
  cluster non empty non degenerated right_complementable almost_left_invertible unital associative right-distributive left-distributive right_unital well-unital distributive left_unital Abelian add-associative right_zeroed doubleLoopStr;
end;

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

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

:: VECTSP_2:condreg 1
registration
  cluster non empty commutative left_unital -> well-unital (multLoopStr);
end;

:: VECTSP_2:condreg 2
registration
  cluster non empty commutative right_unital -> well-unital (multLoopStr);
end;

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

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

:: VECTSP_2:th 38
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr
for b2, b3 being Element of the carrier of b1 holds
ex b4 being Element of the carrier of b1 st
   b2 = b3 + b4 & b2 = b4 + b3;

:: VECTSP_2:th 39
theorem
for b1 being non empty non degenerated right_complementable distributive add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
      st b2 * b3 = 1. b1
   holds b2 <> 0. b1 & b3 <> 0. b1;

:: VECTSP_2:th 40
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive add-associative right_zeroed doubleLoopStr
for b2 being Element of the carrier of b1
      st b2 <> 0. b1
   holds ex b3 being Element of the carrier of b1 st
      b2 * b3 = 1. b1;

:: VECTSP_2:th 41
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
      st b3 * b2 = 1. b1
   holds b2 * b3 = 1. b1;

:: VECTSP_2:th 42
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 * b3 = b2 * b4 & b2 <> 0. b1
   holds b3 = b4;

:: VECTSP_2:funcnot 1 => 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_2:def 7
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive add-associative right_zeroed 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_2:funcnot 2 => VECTSP_2:func 1
definition
  let a1 be non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed 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_2:def 8
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1 holds
b2 / b3 = b2 * (b3 ");

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

:: VECTSP_2:th 45
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
      st b2 * b3 = 1_ b1
   holds b3 = b2 " & b2 = b3 ";

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

:: VECTSP_2:th 47
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
      st b2 * b3 = 0. b1 & b2 <> 0. b1
   holds b3 = 0. b1;

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

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

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

:: VECTSP_2:th 51
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being Element of the carrier of b1
      st b2 <> 0. b1
   holds b2 * ((1_ b1) / b2) = 1_ b1 & ((1_ b1) / b2) * b2 = 1_ b1;

:: VECTSP_2:th 52
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being Element of the carrier of b1
      st b2 <> 0. b1
   holds b2 / b2 = 1_ b1;

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

:: VECTSP_2:th 54
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
      st b2 <> 0. b1
   holds - (b3 / b2) = (- b3) / b2 & b3 / - b2 = - (b3 / b2);

:: VECTSP_2:th 55
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 <> 0. b1
   holds (b3 / b2) + (b4 / b2) = (b3 + b4) / b2 &
    (b3 / b2) - (b4 / b2) = (b3 - b4) / b2;

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

:: VECTSP_2:th 57
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
      st b2 <> 0. b1
   holds (b3 / b2) * b2 = b3;

:: VECTSP_2:structnot 1 => VECTSP_2:struct 1
definition
  let a1 be 1-sorted;
  struct(addLoopStr) RightModStr(#
    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,
    rmult -> Function-like quasi_total Relation of [:the carrier of it,the carrier of A1:],the carrier of it
  #);
end;

:: VECTSP_2:attrnot 2 => VECTSP_2:attr 2
definition
  let a1 be 1-sorted;
  let a2 be RightModStr over a1;
  attr a2 is strict;
end;

:: VECTSP_2:exreg 8
registration
  let a1 be 1-sorted;
  cluster strict RightModStr over a1;
end;

:: VECTSP_2:aggrnot 1 => VECTSP_2: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 [:a2,the carrier of a1:],a2;
  aggr RightModStr(#a2,a3,a4,a5#) -> strict RightModStr over a1;
end;

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

:: VECTSP_2:exreg 9
registration
  let a1 be 1-sorted;
  cluster non empty RightModStr over a1;
end;

:: VECTSP_2:funcreg 1
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 [:a2,the carrier of a1:],a2;
  cluster RightModStr(#a2,a3,a4,a5#) -> non empty strict;
end;

:: VECTSP_2:modenot 4
definition
  let a1 be non empty doubleLoopStr;
  let a2 be non empty RightModStr over a1;
  mode Scalar of a2 is Element of the carrier of a1;
end;

:: VECTSP_2:modenot 5
definition
  let a1 be non empty doubleLoopStr;
  let a2 be non empty RightModStr over a1;
  mode Vector of a2 is Element of the carrier of a2;
end;

:: VECTSP_2:structnot 2 => VECTSP_2:struct 2
definition
  let a1, a2 be 1-sorted;
  struct(VectSpStr over a1RightModStr over a2) BiModStr(#
    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,
    rmult -> Function-like quasi_total Relation of [:the carrier of it,the carrier of A1:],the carrier of it
  #);
end;

:: VECTSP_2:attrnot 3 => VECTSP_2:attr 3
definition
  let a1, a2 be 1-sorted;
  let a3 be BiModStr over a1,a2;
  attr a3 is strict;
end;

:: VECTSP_2:exreg 10
registration
  let a1, a2 be 1-sorted;
  cluster strict BiModStr over a1,a2;
end;

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

:: VECTSP_2:exreg 11
registration
  let a1, a2 be 1-sorted;
  cluster non empty BiModStr over a1,a2;
end;

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

:: VECTSP_2:funcnot 3 => VECTSP_2:func 2
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed addLoopStr;
  func AbGr A1 -> non empty strict right_complementable Abelian add-associative right_zeroed addLoopStr equals
    addLoopStr(#the carrier of a1,the addF of a1,0. a1#);
end;

:: VECTSP_2:def 9
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr holds
   AbGr b1 = addLoopStr(#the carrier of b1,the addF of b1,0. b1#);

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

:: VECTSP_2:funcnot 4 => VECTSP_2:func 3
definition
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  func LeftModule A1 -> non empty right_complementable strict Abelian add-associative right_zeroed VectSpStr over a1 equals
    VectSpStr(#the carrier of a1,the addF of a1,0. a1,the multF of a1#);
end;

:: VECTSP_2:def 11
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
   LeftModule b1 = VectSpStr(#the carrier of b1,the addF of b1,0. b1,the multF of b1#);

:: VECTSP_2:exreg 13
registration
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster non empty right_complementable Abelian add-associative right_zeroed strict RightModStr over a1;
end;

:: VECTSP_2:funcnot 5 => VECTSP_2:func 4
definition
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  func RightModule A1 -> non empty right_complementable Abelian add-associative right_zeroed strict RightModStr over a1 equals
    RightModStr(#the carrier of a1,the addF of a1,0. a1,the multF of a1#);
end;

:: VECTSP_2:def 14
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
   RightModule b1 = RightModStr(#the carrier of b1,the addF of b1,0. b1,the multF of b1#);

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

:: VECTSP_2:def 15
theorem
for b1 being non empty 1-sorted
for b2 being non empty RightModStr over b1
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2 holds
   b4 * b3 = (the rmult of b2) .(b4,b3);

:: VECTSP_2:exreg 14
registration
  let a1, a2 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster non empty right_complementable Abelian add-associative right_zeroed strict BiModStr over a1,a2;
end;

:: VECTSP_2:funcnot 7 => VECTSP_2:func 6
definition
  let a1, a2 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  func BiModule(A1,A2) -> non empty right_complementable Abelian add-associative right_zeroed strict BiModStr over a1,a2 equals
    BiModStr(#1,op2,op0,pr2(the carrier of a1,1),pr1(1,the carrier of a2)#);
end;

:: VECTSP_2:def 21
theorem
for b1, b2 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
BiModule(b1,b2) = BiModStr(#1,op2,op0,pr2(the carrier of b1,1),pr1(1,the carrier of b2)#);

:: VECTSP_2:th 71
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of LeftModule b1 holds
b2 * (b4 + b5) = (b2 * b4) + (b2 * b5) &
 (b2 + b3) * b4 = (b2 * b4) + (b3 * b4) &
 (b2 * b3) * b4 = b2 * (b3 * b4) &
 (1. b1) * b4 = b4;

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

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

:: VECTSP_2:funcreg 3
registration
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster LeftModule a1 -> non empty right_complementable strict VectSp-like Abelian add-associative right_zeroed;
end;

:: VECTSP_2:th 77
theorem
for b1 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of RightModule b1 holds
(b4 + b5) * b2 = (b4 * b2) + (b5 * b2) &
 b4 * (b2 + b3) = (b4 * b2) + (b4 * b3) &
 b4 * (b3 * b2) = (b4 * b3) * b2 &
 b4 * 1_ b1 = b4;

:: VECTSP_2:attrnot 4 => VECTSP_2:attr 4
definition
  let a1 be non empty doubleLoopStr;
  let a2 be non empty RightModStr over a1;
  attr a2 is RightMod-like means
    for b1, b2 being Element of the carrier of a1
    for b3, b4 being Element of the carrier of a2 holds
    (b3 + b4) * b1 = (b3 * b1) + (b4 * b1) &
     b3 * (b1 + b2) = (b3 * b1) + (b3 * b2) &
     b3 * (b2 * b1) = (b3 * b2) * b1 &
     b3 * 1_ a1 = b3;
end;

:: VECTSP_2:dfs 9
definiens
  let a1 be non empty doubleLoopStr;
  let a2 be non empty RightModStr over a1;
To prove
     a2 is RightMod-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
    (b3 + b4) * b1 = (b3 * b1) + (b4 * b1) &
     b3 * (b1 + b2) = (b3 * b1) + (b3 * b2) &
     b3 * (b2 * b1) = (b3 * b2) * b1 &
     b3 * 1_ a1 = b3;

:: VECTSP_2:def 23
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty RightModStr over b1 holds
      b2 is RightMod-like(b1)
   iff
      for b3, b4 being Element of the carrier of b1
      for b5, b6 being Element of the carrier of b2 holds
      (b5 + b6) * b3 = (b5 * b3) + (b6 * b3) &
       b5 * (b3 + b4) = (b5 * b3) + (b5 * b4) &
       b5 * (b4 * b3) = (b5 * b4) * b3 &
       b5 * 1_ b1 = b5;

:: VECTSP_2:exreg 16
registration
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster non empty right_complementable Abelian add-associative right_zeroed strict RightMod-like RightModStr over a1;
end;

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

:: VECTSP_2:funcreg 4
registration
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster RightModule a1 -> non empty right_complementable Abelian add-associative right_zeroed strict RightMod-like;
end;

:: VECTSP_2:attrnot 5 => VECTSP_2:attr 5
definition
  let a1, a2 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a3 be non empty BiModStr over a1,a2;
  attr a3 is BiMod-like means
    for b1 being Element of the carrier of a1
    for b2 being Element of the carrier of a2
    for b3 being Element of the carrier of a3 holds
       b1 * (b3 * b2) = (b1 * b3) * b2;
end;

:: VECTSP_2:dfs 10
definiens
  let a1, a2 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a3 be non empty BiModStr over a1,a2;
To prove
     a3 is BiMod-like
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being Element of the carrier of a2
    for b3 being Element of the carrier of a3 holds
       b1 * (b3 * b2) = (b1 * b3) * b2;

:: VECTSP_2:def 24
theorem
for b1, b2 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b3 being non empty BiModStr over b1,b2 holds
      b3 is BiMod-like(b1, b2)
   iff
      for b4 being Element of the carrier of b1
      for b5 being Element of the carrier of b2
      for b6 being Element of the carrier of b3 holds
         b4 * (b6 * b5) = (b4 * b6) * b5;

:: VECTSP_2:exreg 17
registration
  let a1, a2 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster non empty right_complementable VectSp-like Abelian add-associative right_zeroed strict RightMod-like BiMod-like BiModStr over a1,a2;
end;

:: VECTSP_2:modenot 8
definition
  let a1, a2 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  mode BiMod of a1,a2 is non empty right_complementable VectSp-like Abelian add-associative right_zeroed RightMod-like BiMod-like BiModStr over a1,a2;
end;

:: VECTSP_2:th 83
theorem
for b1, b2 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b3 being non empty BiModStr over b1,b2 holds
      for b4, b5 being Element of the carrier of b1
      for b6, b7 being Element of the carrier of b2
      for b8, b9 being Element of the carrier of b3 holds
      b4 * (b8 + b9) = (b4 * b8) + (b4 * b9) &
       (b4 + b5) * b8 = (b4 * b8) + (b5 * b8) &
       (b4 * b5) * b8 = b4 * (b5 * b8) &
       (1_ b1) * b8 = b8 &
       (b8 + b9) * b6 = (b8 * b6) + (b9 * b6) &
       b8 * (b6 + b7) = (b8 * b6) + (b8 * b7) &
       b8 * (b7 * b6) = (b8 * b7) * b6 &
       b8 * 1_ b2 = b8 &
       b4 * (b8 * b6) = (b4 * b8) * b6
   iff
      b3 is RightMod-like(b2) & b3 is VectSp-like(b1) & b3 is BiMod-like(b1, b2);

:: VECTSP_2:th 84
theorem
for b1, b2 being non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
BiModule(b1,b2) is non empty right_complementable VectSp-like Abelian add-associative right_zeroed RightMod-like BiMod-like BiModStr over b1,b2;

:: VECTSP_2:funcreg 5
registration
  let a1, a2 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster BiModule(a1,a2) -> non empty right_complementable VectSp-like Abelian add-associative right_zeroed strict RightMod-like BiMod-like;
end;

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