Article PRVECT_1, MML version 4.99.1005

:: PRVECT_1:th 3
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr holds
   0. b1 is_a_unity_wrt the addF of b1;

:: PRVECT_1:th 4
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr holds
   comp b1 is_an_inverseOp_wrt the addF of b1;

:: PRVECT_1:th 5
theorem
for b1 being non empty addLoopStr
      st the addF of b1 is commutative(the carrier of b1) & the addF of b1 is associative(the carrier of b1) & 0. b1 is_a_unity_wrt the addF of b1 & comp b1 is_an_inverseOp_wrt the addF of b1
   holds b1 is non empty right_complementable Abelian add-associative right_zeroed addLoopStr;

:: PRVECT_1:th 10
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
   0. b1 is_a_unity_wrt the addF of b1;

:: PRVECT_1:th 11
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
   1_ b1 is_a_unity_wrt the multF of b1;

:: PRVECT_1:funcnot 1 => PRVECT_1:func 1
definition
  let a1 be non empty set;
  let a2 be natural set;
  let a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4, a5 be Element of a2 -tuples_on a1;
  redefine func a3 .:(a4,a5) -> Element of a2 -tuples_on a1;
end;

:: PRVECT_1:funcnot 2 => PRVECT_1:func 2
definition
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3 be natural set;
  func product(A2,A3) -> Function-like quasi_total Relation of [:a3 -tuples_on a1,a3 -tuples_on a1:],a3 -tuples_on a1 means
    for b1, b2 being Element of a3 -tuples_on a1 holds
    it .(b1,b2) = a2 .:(b1,b2);
end;

:: PRVECT_1:def 1
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:b1,b1:],b1
for b3 being natural set
for b4 being Function-like quasi_total Relation of [:b3 -tuples_on b1,b3 -tuples_on b1:],b3 -tuples_on b1 holds
      b4 = product(b2,b3)
   iff
      for b5, b6 being Element of b3 -tuples_on b1 holds
      b4 .(b5,b6) = b2 .:(b5,b6);

:: PRVECT_1:funcnot 3 => PRVECT_1:func 3
definition
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of a1,a1;
  let a3 be natural set;
  func product(A2,A3) -> Function-like quasi_total Relation of a3 -tuples_on a1,a3 -tuples_on a1 means
    for b1 being Element of a3 -tuples_on a1 holds
       it . b1 = a2 * b1;
end;

:: PRVECT_1:def 2
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of b1,b1
for b3 being natural set
for b4 being Function-like quasi_total Relation of b3 -tuples_on b1,b3 -tuples_on b1 holds
      b4 = product(b2,b3)
   iff
      for b5 being Element of b3 -tuples_on b1 holds
         b4 . b5 = b2 * b5;

:: PRVECT_1:funcnot 4 => FINSEQ_2:func 2
notation
  let a1 be non empty set;
  let a2 be natural set;
  let a3 be Element of a1;
  synonym a2 .--> a3 for a1 |-> a2;
end;

:: PRVECT_1:funcnot 5 => PRVECT_1:func 4
definition
  let a1 be non empty set;
  let a2 be natural set;
  let a3 be Element of a1;
  redefine func a2 .--> a3 -> Element of a2 -tuples_on a1;
end;

:: PRVECT_1:th 14
theorem
for b1 being natural set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of [:b2,b2:],b2
      st b3 is commutative(b2)
   holds product(b3,b1) is commutative(b1 -tuples_on b2);

:: PRVECT_1:th 15
theorem
for b1 being natural set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of [:b2,b2:],b2
      st b3 is associative(b2)
   holds product(b3,b1) is associative(b1 -tuples_on b2);

:: PRVECT_1:th 16
theorem
for b1 being natural set
for b2 being non empty set
for b3 being Element of b2
for b4 being Function-like quasi_total Relation of [:b2,b2:],b2
      st b3 is_a_unity_wrt b4
   holds b1 .--> b3 is_a_unity_wrt product(b4,b1);

:: PRVECT_1:th 17
theorem
for b1 being natural set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of [:b2,b2:],b2
for b4 being Function-like quasi_total Relation of b2,b2
      st b3 is having_a_unity(b2) & b3 is associative(b2) & b4 is_an_inverseOp_wrt b3
   holds product(b4,b1) is_an_inverseOp_wrt product(b3,b1);

:: PRVECT_1:funcnot 6 => PRVECT_1:func 5
definition
  let a1 be non empty addLoopStr;
  let a2 be natural set;
  assume a1 is Abelian & a1 is add-associative & a1 is right_zeroed & a1 is right_complementable;
  func A2 -Group_over A1 -> non empty strict right_complementable Abelian add-associative right_zeroed addLoopStr equals
    addLoopStr(#a2 -tuples_on the carrier of a1,product(the addF of a1,a2),a2 .--> 0. a1#);
end;

:: PRVECT_1:def 3
theorem
for b1 being non empty addLoopStr
for b2 being natural set
      st b1 is Abelian & b1 is add-associative & b1 is right_zeroed & b1 is right_complementable
   holds b2 -Group_over b1 = addLoopStr(#b2 -tuples_on the carrier of b1,product(the addF of b1,b2),b2 .--> 0. b1#);

:: PRVECT_1:funcreg 1
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed addLoopStr;
  let a2 be natural set;
  cluster a2 -Group_over a1 -> non empty strict right_complementable Abelian add-associative right_zeroed;
end;

:: PRVECT_1:funcnot 7 => PRVECT_1:func 6
definition
  let a1 be non empty non degenerated right_complementable almost_left_invertible associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be natural set;
  func A2 -Mult_over A1 -> Function-like quasi_total Relation of [:the carrier of a1,a2 -tuples_on the carrier of a1:],a2 -tuples_on the carrier of a1 means
    for b1 being Element of the carrier of a1
    for b2 being Element of a2 -tuples_on the carrier of a1 holds
       it .(b1,b2) = (the multF of a1) [;](b1,b2);
end;

:: PRVECT_1:def 4
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being natural set
for b3 being Function-like quasi_total Relation of [:the carrier of b1,b2 -tuples_on the carrier of b1:],b2 -tuples_on the carrier of b1 holds
      b3 = b2 -Mult_over b1
   iff
      for b4 being Element of the carrier of b1
      for b5 being Element of b2 -tuples_on the carrier of b1 holds
         b3 .(b4,b5) = (the multF of b1) [;](b4,b5);

:: PRVECT_1:funcnot 8 => PRVECT_1:func 7
definition
  let a1 be non empty non degenerated right_complementable almost_left_invertible associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be natural set;
  func A2 -VectSp_over A1 -> strict VectSpStr over a1 means
    addLoopStr(#the carrier of it,the addF of it,the ZeroF of it#) = a2 -Group_over a1 &
     the lmult of it = a2 -Mult_over a1;
end;

:: PRVECT_1:def 5
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being natural set
for b3 being strict VectSpStr over b1 holds
      b3 = b2 -VectSp_over b1
   iff
      addLoopStr(#the carrier of b3,the addF of b3,the ZeroF of b3#) = b2 -Group_over b1 &
       the lmult of b3 = b2 -Mult_over b1;

:: PRVECT_1:funcreg 2
registration
  let a1 be non empty non degenerated right_complementable almost_left_invertible associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be natural set;
  cluster a2 -VectSp_over a1 -> non empty strict;
end;

:: PRVECT_1:th 18
theorem
for b1 being natural set
for b2 being non empty set
for b3, b4 being Function-like quasi_total Relation of [:b2,b2:],b2
for b5 being Element of b2
for b6, b7 being Element of b1 -tuples_on b2
      st b3 is_distributive_wrt b4
   holds b3 [;](b5,b4 .:(b6,b7)) = b4 .:(b3 [;](b5,b6),b3 [;](b5,b7));

:: PRVECT_1:funcnot 9 => PRVECT_1:func 8
definition
  let a1 be non empty set;
  let a2 be natural set;
  let a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4 be Element of a1;
  let a5 be Element of a2 -tuples_on a1;
  redefine func a3 [;](a4,a5) -> Element of a2 -tuples_on a1;
end;

:: PRVECT_1:funcreg 3
registration
  let a1 be non empty non degenerated right_complementable almost_left_invertible associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  let a2 be natural set;
  cluster a2 -VectSp_over a1 -> strict VectSp-like;
end;

:: PRVECT_1:modenot 1
definition
  mode Domain-Sequence is Relation-like non-empty Function-like non empty FinSequence-like set;
end;

:: PRVECT_1:sch 1
scheme PRVECT_1:sch 1
{F1 -> Relation-like Function-like non empty FinSequence-like set,
  F2 -> set}:
ex b1 being Relation-like Function-like non empty FinSequence-like set st
   len b1 = len F1() &
    (for b2 being Element of dom F1() holds
       b1 . b2 = F2(b2))


:: PRVECT_1:funcnot 10 => PRVECT_1:func 9
definition
  let a1 be Relation-like non-empty Function-like non empty set;
  let a2 be Element of product a1;
  let a3 be Element of proj1 a1;
  redefine func a2 . a3 -> Element of a1 . a3;
end;

:: PRVECT_1:modenot 2 => PRVECT_1:mode 1
definition
  let a1 be Relation-like non-empty Function-like non empty set;
  mode BinOps of A1 -> Relation-like Function-like set means
    proj1 it = proj1 a1 &
     (for b1 being Element of proj1 a1 holds
        it . b1 is Function-like quasi_total Relation of [:a1 . b1,a1 . b1:],a1 . b1);
end;

:: PRVECT_1:dfs 6
definiens
  let a1 be Relation-like non-empty Function-like non empty set;
  let a2 be Relation-like Function-like set;
To prove
     a2 is BinOps of a1
it is sufficient to prove
  thus proj1 a2 = proj1 a1 &
     (for b1 being Element of proj1 a1 holds
        a2 . b1 is Function-like quasi_total Relation of [:a1 . b1,a1 . b1:],a1 . b1);

:: PRVECT_1:def 8
theorem
for b1 being Relation-like non-empty Function-like non empty set
for b2 being Relation-like Function-like set holds
      b2 is BinOps of b1
   iff
      proj1 b2 = proj1 b1 &
       (for b3 being Element of proj1 b1 holds
          b2 . b3 is Function-like quasi_total Relation of [:b1 . b3,b1 . b3:],b1 . b3);

:: PRVECT_1:modenot 3 => PRVECT_1:mode 2
definition
  let a1 be Relation-like non-empty Function-like non empty set;
  mode UnOps of A1 -> Relation-like Function-like set means
    proj1 it = proj1 a1 &
     (for b1 being Element of proj1 a1 holds
        it . b1 is Function-like quasi_total Relation of a1 . b1,a1 . b1);
end;

:: PRVECT_1:dfs 7
definiens
  let a1 be Relation-like non-empty Function-like non empty set;
  let a2 be Relation-like Function-like set;
To prove
     a2 is UnOps of a1
it is sufficient to prove
  thus proj1 a2 = proj1 a1 &
     (for b1 being Element of proj1 a1 holds
        a2 . b1 is Function-like quasi_total Relation of a1 . b1,a1 . b1);

:: PRVECT_1:def 9
theorem
for b1 being Relation-like non-empty Function-like non empty set
for b2 being Relation-like Function-like set holds
      b2 is UnOps of b1
   iff
      proj1 b2 = proj1 b1 &
       (for b3 being Element of proj1 b1 holds
          b2 . b3 is Function-like quasi_total Relation of b1 . b3,b1 . b3);

:: PRVECT_1:condreg 1
registration
  let a1 be Relation-like non-empty Function-like non empty FinSequence-like set;
  cluster -> FinSequence-like (BinOps of a1);
end;

:: PRVECT_1:condreg 2
registration
  let a1 be Relation-like non-empty Function-like non empty FinSequence-like set;
  cluster -> FinSequence-like (UnOps of a1);
end;

:: PRVECT_1:th 19
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2 being Relation-like Function-like FinSequence-like set holds
      b2 is BinOps of b1
   iff
      len b2 = len b1 &
       (for b3 being Element of dom b1 holds
          b2 . b3 is Function-like quasi_total Relation of [:b1 . b3,b1 . b3:],b1 . b3);

:: PRVECT_1:th 20
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2 being Relation-like Function-like FinSequence-like set holds
      b2 is UnOps of b1
   iff
      len b2 = len b1 &
       (for b3 being Element of dom b1 holds
          b2 . b3 is Function-like quasi_total Relation of b1 . b3,b1 . b3);

:: PRVECT_1:funcnot 11 => PRVECT_1:func 10
definition
  let a1 be Relation-like non-empty Function-like non empty FinSequence-like set;
  let a2 be BinOps of a1;
  let a3 be Element of dom a1;
  redefine func a2 . a3 -> Function-like quasi_total Relation of [:a1 . a3,a1 . a3:],a1 . a3;
end;

:: PRVECT_1:funcnot 12 => PRVECT_1:func 11
definition
  let a1 be Relation-like non-empty Function-like non empty FinSequence-like set;
  let a2 be UnOps of a1;
  let a3 be Element of dom a1;
  redefine func a2 . a3 -> Function-like quasi_total Relation of a1 . a3,a1 . a3;
end;

:: PRVECT_1:th 21
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2, b3 being Function-like quasi_total Relation of product b1,product b1
      st for b4 being Element of product b1
        for b5 being Element of dom b1 holds
           (b2 . b4) . b5 = (b3 . b4) . b5
   holds b2 = b3;

:: PRVECT_1:th 22
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2 being UnOps of b1 holds
   doms b2 = b1 & product rngs b2 c= product b1;

:: PRVECT_1:funcnot 13 => PRVECT_1:func 12
definition
  let a1 be Relation-like non-empty Function-like non empty FinSequence-like set;
  let a2 be UnOps of a1;
  redefine func Frege a2 -> Function-like quasi_total Relation of product a1,product a1;
end;

:: PRVECT_1:th 23
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2 being UnOps of b1
for b3 being Element of product b1
for b4 being Element of dom b1 holds
   ((Frege b2) . b3) . b4 = (b2 . b4) . (b3 . b4);

:: PRVECT_1:funcnot 14 => PRVECT_1:func 13
definition
  let a1 be non empty functional set;
  let a2 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a3, a4 be Element of a1;
  redefine func a2 .(a3,a4) -> Element of a1;
end;

:: PRVECT_1:th 24
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2, b3 being Function-like quasi_total Relation of [:product b1,product b1:],product b1
      st for b4, b5 being Element of product b1
        for b6 being Element of dom b1 holds
           (b2 .(b4,b5)) . b6 = (b3 .(b4,b5)) . b6
   holds b2 = b3;

:: PRVECT_1:funcnot 15 => PRVECT_1:func 14
definition
  let a1 be Relation-like non-empty Function-like non empty FinSequence-like set;
  let a2 be BinOps of a1;
  func [:A2:] -> Function-like quasi_total Relation of [:product a1,product a1:],product a1 means
    for b1, b2 being Element of product a1
    for b3 being Element of dom a1 holds
       (it .(b1,b2)) . b3 = (a2 . b3) .(b1 . b3,b2 . b3);
end;

:: PRVECT_1:def 10
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2 being BinOps of b1
for b3 being Function-like quasi_total Relation of [:product b1,product b1:],product b1 holds
      b3 = [:b2:]
   iff
      for b4, b5 being Element of product b1
      for b6 being Element of dom b1 holds
         (b3 .(b4,b5)) . b6 = (b2 . b6) .(b4 . b6,b5 . b6);

:: PRVECT_1:th 25
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2 being BinOps of b1
      st for b3 being Element of dom b1 holds
           b2 . b3 is commutative(b1 . b3)
   holds [:b2:] is commutative(product b1);

:: PRVECT_1:th 26
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2 being BinOps of b1
      st for b3 being Element of dom b1 holds
           b2 . b3 is associative(b1 . b3)
   holds [:b2:] is associative(product b1);

:: PRVECT_1:th 27
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2 being BinOps of b1
for b3 being Element of product b1
      st for b4 being Element of dom b1 holds
           b3 . b4 is_a_unity_wrt b2 . b4
   holds b3 is_a_unity_wrt [:b2:];

:: PRVECT_1:th 28
theorem
for b1 being Relation-like non-empty Function-like non empty FinSequence-like set
for b2 being BinOps of b1
for b3 being UnOps of b1
      st for b4 being Element of dom b1 holds
           b3 . b4 is_an_inverseOp_wrt b2 . b4 & b2 . b4 is having_a_unity(b1 . b4)
   holds Frege b3 is_an_inverseOp_wrt [:b2:];

:: PRVECT_1:attrnot 1 => PRVECT_1:attr 1
definition
  let a1 be Relation-like set;
  attr a1 is AbGroup-yielding means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is non empty right_complementable Abelian add-associative right_zeroed addLoopStr;
end;

:: PRVECT_1:dfs 9
definiens
  let a1 be Relation-like set;
To prove
     a1 is AbGroup-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is non empty right_complementable Abelian add-associative right_zeroed addLoopStr;

:: PRVECT_1:def 11
theorem
for b1 being Relation-like set holds
      b1 is AbGroup-yielding
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is non empty right_complementable Abelian add-associative right_zeroed addLoopStr;

:: PRVECT_1:exreg 1
registration
  cluster Relation-like Function-like non empty finite FinSequence-like AbGroup-yielding set;
end;

:: PRVECT_1:modenot 4
definition
  mode Group-Sequence is Relation-like Function-like non empty FinSequence-like AbGroup-yielding set;
end;

:: PRVECT_1:funcnot 16 => PRVECT_1:func 15
definition
  let a1 be Relation-like Function-like non empty FinSequence-like AbGroup-yielding set;
  let a2 be Element of dom a1;
  redefine func a1 . a2 -> non empty right_complementable Abelian add-associative right_zeroed addLoopStr;
end;

:: PRVECT_1:funcnot 17 => PRVECT_1:func 16
definition
  let a1 be Relation-like Function-like non empty FinSequence-like AbGroup-yielding set;
  func carr A1 -> Relation-like non-empty Function-like non empty FinSequence-like set means
    len it = len a1 &
     (for b1 being Element of dom a1 holds
        it . b1 = the carrier of a1 . b1);
end;

:: PRVECT_1:def 12
theorem
for b1 being Relation-like Function-like non empty FinSequence-like AbGroup-yielding set
for b2 being Relation-like non-empty Function-like non empty FinSequence-like set holds
      b2 = carr b1
   iff
      len b2 = len b1 &
       (for b3 being Element of dom b1 holds
          b2 . b3 = the carrier of b1 . b3);

:: PRVECT_1:funcnot 18 => PRVECT_1:func 17
definition
  let a1 be Relation-like Function-like non empty FinSequence-like AbGroup-yielding set;
  let a2 be Element of dom carr a1;
  redefine func a1 . a2 -> non empty right_complementable Abelian add-associative right_zeroed addLoopStr;
end;

:: PRVECT_1:funcnot 19 => PRVECT_1:func 18
definition
  let a1 be Relation-like Function-like non empty FinSequence-like AbGroup-yielding set;
  func addop A1 -> BinOps of carr a1 means
    len it = len carr a1 &
     (for b1 being Element of dom carr a1 holds
        it . b1 = the addF of a1 . b1);
end;

:: PRVECT_1:def 13
theorem
for b1 being Relation-like Function-like non empty FinSequence-like AbGroup-yielding set
for b2 being BinOps of carr b1 holds
      b2 = addop b1
   iff
      len b2 = len carr b1 &
       (for b3 being Element of dom carr b1 holds
          b2 . b3 = the addF of b1 . b3);

:: PRVECT_1:funcnot 20 => PRVECT_1:func 19
definition
  let a1 be Relation-like Function-like non empty FinSequence-like AbGroup-yielding set;
  func complop A1 -> UnOps of carr a1 means
    len it = len carr a1 &
     (for b1 being Element of dom carr a1 holds
        it . b1 = comp (a1 . b1));
end;

:: PRVECT_1:def 14
theorem
for b1 being Relation-like Function-like non empty FinSequence-like AbGroup-yielding set
for b2 being UnOps of carr b1 holds
      b2 = complop b1
   iff
      len b2 = len carr b1 &
       (for b3 being Element of dom carr b1 holds
          b2 . b3 = comp (b1 . b3));

:: PRVECT_1:funcnot 21 => PRVECT_1:func 20
definition
  let a1 be Relation-like Function-like non empty FinSequence-like AbGroup-yielding set;
  func zeros A1 -> Element of product carr a1 means
    for b1 being Element of dom carr a1 holds
       it . b1 = 0. (a1 . b1);
end;

:: PRVECT_1:def 15
theorem
for b1 being Relation-like Function-like non empty FinSequence-like AbGroup-yielding set
for b2 being Element of product carr b1 holds
      b2 = zeros b1
   iff
      for b3 being Element of dom carr b1 holds
         b2 . b3 = 0. (b1 . b3);

:: PRVECT_1:funcnot 22 => PRVECT_1:func 21
definition
  let a1 be Relation-like Function-like non empty FinSequence-like AbGroup-yielding set;
  func product A1 -> non empty strict right_complementable Abelian add-associative right_zeroed addLoopStr equals
    addLoopStr(#product carr a1,[:addop a1:],zeros a1#);
end;

:: PRVECT_1:def 16
theorem
for b1 being Relation-like Function-like non empty FinSequence-like AbGroup-yielding set holds
   product b1 = addLoopStr(#product carr b1,[:addop b1:],zeros b1#);