Article GROUP_7, MML version 4.99.1005

:: GROUP_7:th 1
theorem
for b1, b2 being set
      st <*b1*> = <*b2*>
   holds b1 = b2;

:: GROUP_7:th 2
theorem
for b1, b2, b3, b4 being set
      st <*b1,b2*> = <*b3,b4*>
   holds b1 = b3 & b2 = b4;

:: GROUP_7:th 3
theorem
for b1, b2, b3, b4, b5, b6 being set
      st <*b1,b2,b3*> = <*b4,b5,b6*>
   holds b1 = b4 & b2 = b5 & b3 = b6;

:: GROUP_7:attrnot 1 => GROUP_7:attr 1
definition
  let a1 be Relation-like set;
  attr a1 is HGrStr-yielding means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is non empty multMagma;
end;

:: GROUP_7:dfs 1
definiens
  let a1 be Relation-like set;
To prove
     a1 is HGrStr-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is non empty multMagma;

:: GROUP_7:def 1
theorem
for b1 being Relation-like set holds
      b1 is HGrStr-yielding
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is non empty multMagma;

:: GROUP_7:condreg 1
registration
  cluster Relation-like Function-like HGrStr-yielding -> 1-sorted-yielding (set);
end;

:: GROUP_7:exreg 1
registration
  let a1 be set;
  cluster Relation-like Function-like HGrStr-yielding ManySortedSet of a1;
end;

:: GROUP_7:exreg 2
registration
  cluster Relation-like Function-like HGrStr-yielding set;
end;

:: GROUP_7:modenot 1
definition
  let a1 be set;
  mode HGrStr-Family of a1 is HGrStr-yielding ManySortedSet of a1;
end;

:: GROUP_7:funcnot 1 => GROUP_7:func 1
definition
  let a1 be non empty set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  let a3 be Element of a1;
  redefine func a2 . a3 -> non empty multMagma;
end;

:: GROUP_7:funcreg 1
registration
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  cluster Carrier a2 -> non-empty;
end;

:: GROUP_7:funcnot 2 => GROUP_7:func 2
definition
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  func product A2 -> strict multMagma means
    the carrier of it = product Carrier a2 &
     (for b1, b2 being Element of product Carrier a2
     for b3 being set
           st b3 in a1
        holds ex b4 being non empty multMagma st
           ex b5 being Relation-like Function-like set st
              b4 = a2 . b3 &
               b5 = (the multF of it) .(b1,b2) &
               b5 . b3 = (the multF of b4) .(b1 . b3,b2 . b3));
end;

:: GROUP_7:def 2
theorem
for b1 being set
for b2 being HGrStr-yielding ManySortedSet of b1
for b3 being strict multMagma holds
      b3 = product b2
   iff
      the carrier of b3 = product Carrier b2 &
       (for b4, b5 being Element of product Carrier b2
       for b6 being set
             st b6 in b1
          holds ex b7 being non empty multMagma st
             ex b8 being Relation-like Function-like set st
                b7 = b2 . b6 &
                 b8 = (the multF of b3) .(b4,b5) &
                 b8 . b6 = (the multF of b7) .(b4 . b6,b5 . b6));

:: GROUP_7:funcreg 2
registration
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  cluster product a2 -> non empty strict constituted-Functions;
end;

:: GROUP_7:th 4
theorem
for b1, b2 being set
for b3, b4, b5 being Relation-like Function-like set
for b6 being HGrStr-yielding ManySortedSet of b1
for b7 being non empty multMagma
for b8, b9 being Element of the carrier of product b6
for b10, b11 being Element of the carrier of b7
      st b2 in b1 & b7 = b6 . b2 & b3 = b8 & b4 = b9 & b5 = b8 * b9 & b3 . b2 = b10 & b4 . b2 = b11
   holds b10 * b11 = b5 . b2;

:: GROUP_7:attrnot 2 => GROUP_7:attr 2
definition
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  attr a2 is Group-like means
    for b1 being set
          st b1 in a1
       holds ex b2 being non empty Group-like multMagma st
          b2 = a2 . b1;
end;

:: GROUP_7:dfs 3
definiens
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
To prove
     a2 is Group-like
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds ex b2 being non empty Group-like multMagma st
          b2 = a2 . b1;

:: GROUP_7:def 3
theorem
for b1 being set
for b2 being HGrStr-yielding ManySortedSet of b1 holds
      b2 is Group-like(b1)
   iff
      for b3 being set
            st b3 in b1
         holds ex b4 being non empty Group-like multMagma st
            b4 = b2 . b3;

:: GROUP_7:attrnot 3 => GROUP_7:attr 3
definition
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  attr a2 is associative means
    for b1 being set
          st b1 in a1
       holds ex b2 being non empty associative multMagma st
          b2 = a2 . b1;
end;

:: GROUP_7:dfs 4
definiens
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
To prove
     a2 is associative
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds ex b2 being non empty associative multMagma st
          b2 = a2 . b1;

:: GROUP_7:def 4
theorem
for b1 being set
for b2 being HGrStr-yielding ManySortedSet of b1 holds
      b2 is associative(b1)
   iff
      for b3 being set
            st b3 in b1
         holds ex b4 being non empty associative multMagma st
            b4 = b2 . b3;

:: GROUP_7:attrnot 4 => GROUP_7:attr 4
definition
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  attr a2 is commutative means
    for b1 being set
          st b1 in a1
       holds ex b2 being non empty commutative multMagma st
          b2 = a2 . b1;
end;

:: GROUP_7:dfs 5
definiens
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
To prove
     a2 is commutative
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds ex b2 being non empty commutative multMagma st
          b2 = a2 . b1;

:: GROUP_7:def 5
theorem
for b1 being set
for b2 being HGrStr-yielding ManySortedSet of b1 holds
      b2 is commutative(b1)
   iff
      for b3 being set
            st b3 in b1
         holds ex b4 being non empty commutative multMagma st
            b4 = b2 . b3;

:: GROUP_7:attrnot 5 => GROUP_7:attr 2
definition
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  attr a2 is Group-like means
    for b1 being Element of a1 holds
       a2 . b1 is Group-like;
end;

:: GROUP_7:dfs 6
definiens
  let a1 be non empty set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
To prove
     a2 is Group-like
it is sufficient to prove
  thus for b1 being Element of a1 holds
       a2 . b1 is Group-like;

:: GROUP_7:def 6
theorem
for b1 being non empty set
for b2 being HGrStr-yielding ManySortedSet of b1 holds
      b2 is Group-like(b1)
   iff
      for b3 being Element of b1 holds
         b2 . b3 is Group-like;

:: GROUP_7:attrnot 6 => GROUP_7:attr 3
definition
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  attr a2 is associative means
    for b1 being Element of a1 holds
       a2 . b1 is associative;
end;

:: GROUP_7:dfs 7
definiens
  let a1 be non empty set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
To prove
     a2 is associative
it is sufficient to prove
  thus for b1 being Element of a1 holds
       a2 . b1 is associative;

:: GROUP_7:def 7
theorem
for b1 being non empty set
for b2 being HGrStr-yielding ManySortedSet of b1 holds
      b2 is associative(b1)
   iff
      for b3 being Element of b1 holds
         b2 . b3 is associative;

:: GROUP_7:attrnot 7 => GROUP_7:attr 4
definition
  let a1 be set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
  attr a2 is commutative means
    for b1 being Element of a1 holds
       a2 . b1 is commutative;
end;

:: GROUP_7:dfs 8
definiens
  let a1 be non empty set;
  let a2 be HGrStr-yielding ManySortedSet of a1;
To prove
     a2 is commutative
it is sufficient to prove
  thus for b1 being Element of a1 holds
       a2 . b1 is commutative;

:: GROUP_7:def 8
theorem
for b1 being non empty set
for b2 being HGrStr-yielding ManySortedSet of b1 holds
      b2 is commutative(b1)
   iff
      for b3 being Element of b1 holds
         b2 . b3 is commutative;

:: GROUP_7:exreg 3
registration
  let a1 be set;
  cluster Relation-like Function-like 1-sorted-yielding HGrStr-yielding Group-like associative commutative ManySortedSet of a1;
end;

:: GROUP_7:funcreg 3
registration
  let a1 be set;
  let a2 be HGrStr-yielding Group-like ManySortedSet of a1;
  cluster product a2 -> strict Group-like;
end;

:: GROUP_7:funcreg 4
registration
  let a1 be set;
  let a2 be HGrStr-yielding associative ManySortedSet of a1;
  cluster product a2 -> strict associative;
end;

:: GROUP_7:funcreg 5
registration
  let a1 be set;
  let a2 be HGrStr-yielding commutative ManySortedSet of a1;
  cluster product a2 -> strict commutative;
end;

:: GROUP_7:th 5
theorem
for b1, b2 being set
for b3 being HGrStr-yielding ManySortedSet of b1
for b4 being non empty multMagma
      st b2 in b1 & b4 = b3 . b2 & product b3 is Group-like
   holds b4 is Group-like;

:: GROUP_7:th 6
theorem
for b1, b2 being set
for b3 being HGrStr-yielding ManySortedSet of b1
for b4 being non empty multMagma
      st b2 in b1 & b4 = b3 . b2 & product b3 is associative
   holds b4 is associative;

:: GROUP_7:th 7
theorem
for b1, b2 being set
for b3 being HGrStr-yielding ManySortedSet of b1
for b4 being non empty multMagma
      st b2 in b1 & b4 = b3 . b2 & product b3 is commutative
   holds b4 is commutative;

:: GROUP_7:th 8
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being HGrStr-yielding Group-like ManySortedSet of b1
      st for b4 being set
              st b4 in b1
           holds ex b5 being non empty Group-like multMagma st
              b5 = b3 . b4 & b2 . b4 = 1_ b5
   holds b2 = 1_ product b3;

:: GROUP_7:th 9
theorem
for b1, b2 being set
for b3 being Relation-like Function-like set
for b4 being HGrStr-yielding Group-like ManySortedSet of b1
for b5 being non empty Group-like multMagma
      st b2 in b1 & b5 = b4 . b2 & b3 = 1_ product b4
   holds b3 . b2 = 1_ b5;

:: GROUP_7:th 10
theorem
for b1 being set
for b2 being Relation-like Function-like set
for b3 being ManySortedSet of b1
for b4 being HGrStr-yielding Group-like associative ManySortedSet of b1
for b5 being Element of the carrier of product b4
      st b5 = b2 &
         (for b6 being set
               st b6 in b1
            holds ex b7 being non empty Group-like associative multMagma st
               ex b8 being Element of the carrier of b7 st
                  b7 = b4 . b6 & b3 . b6 = b8 " & b8 = b2 . b6)
   holds b3 = b5 ";

:: GROUP_7:th 11
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like set
for b5 being HGrStr-yielding Group-like associative ManySortedSet of b1
for b6 being Element of the carrier of product b5
for b7 being non empty Group-like associative multMagma
for b8 being Element of the carrier of b7
      st b2 in b1 & b7 = b5 . b2 & b3 = b6 & b4 = b6 " & b3 . b2 = b8
   holds b4 . b2 = b8 ";

:: GROUP_7:funcnot 3 => GROUP_7:func 3
definition
  let a1 be set;
  let a2 be HGrStr-yielding Group-like associative ManySortedSet of a1;
  func sum A2 -> strict Subgroup of product a2 means
    for b1 being set holds
          b1 in the carrier of it
       iff
          ex b2 being Element of product Carrier a2 st
             ex b3 being finite Element of bool a1 st
                ex b4 being ManySortedSet of b3 st
                   b2 = 1_ product a2 &
                    b1 = b2 +* b4 &
                    (for b5 being set
                          st b5 in b3
                       holds ex b6 being non empty Group-like multMagma st
                          b6 = a2 . b5 & b4 . b5 in the carrier of b6 & b4 . b5 <> 1_ b6);
end;

:: GROUP_7:def 9
theorem
for b1 being set
for b2 being HGrStr-yielding Group-like associative ManySortedSet of b1
for b3 being strict Subgroup of product b2 holds
      b3 = sum b2
   iff
      for b4 being set holds
            b4 in the carrier of b3
         iff
            ex b5 being Element of product Carrier b2 st
               ex b6 being finite Element of bool b1 st
                  ex b7 being ManySortedSet of b6 st
                     b5 = 1_ product b2 &
                      b4 = b5 +* b7 &
                      (for b8 being set
                            st b8 in b6
                         holds ex b9 being non empty Group-like multMagma st
                            b9 = b2 . b8 & b7 . b8 in the carrier of b9 & b7 . b8 <> 1_ b9);

:: GROUP_7:funcreg 6
registration
  let a1 be set;
  let a2 be HGrStr-yielding Group-like associative ManySortedSet of a1;
  let a3, a4 be Element of the carrier of sum a2;
  cluster (the multF of sum a2) .(a3,a4) -> Relation-like Function-like;
end;

:: GROUP_7:th 12
theorem
for b1 being finite set
for b2 being HGrStr-yielding Group-like associative ManySortedSet of b1 holds
   product b2 = sum b2;

:: GROUP_7:th 13
theorem
for b1 being non empty multMagma holds
   <*b1*> is HGrStr-yielding ManySortedSet of {1};

:: GROUP_7:funcnot 4 => GROUP_7:func 4
definition
  let a1 be non empty multMagma;
  redefine func <*a1*> -> HGrStr-yielding ManySortedSet of {1};
end;

:: GROUP_7:th 14
theorem
for b1 being non empty Group-like multMagma holds
   <*b1*> is HGrStr-yielding Group-like ManySortedSet of {1};

:: GROUP_7:funcnot 5 => GROUP_7:func 5
definition
  let a1 be non empty Group-like multMagma;
  redefine func <*a1*> -> HGrStr-yielding Group-like ManySortedSet of {1};
end;

:: GROUP_7:th 15
theorem
for b1 being non empty associative multMagma holds
   <*b1*> is HGrStr-yielding associative ManySortedSet of {1};

:: GROUP_7:funcnot 6 => GROUP_7:func 6
definition
  let a1 be non empty associative multMagma;
  redefine func <*a1*> -> HGrStr-yielding associative ManySortedSet of {1};
end;

:: GROUP_7:th 16
theorem
for b1 being non empty commutative multMagma holds
   <*b1*> is HGrStr-yielding commutative ManySortedSet of {1};

:: GROUP_7:funcnot 7 => GROUP_7:func 7
definition
  let a1 be non empty commutative multMagma;
  redefine func <*a1*> -> HGrStr-yielding commutative ManySortedSet of {1};
end;

:: GROUP_7:th 17
theorem
for b1 being non empty Group-like associative multMagma holds
   <*b1*> is HGrStr-yielding Group-like associative ManySortedSet of {1};

:: GROUP_7:funcnot 8 => GROUP_7:func 8
definition
  let a1 be non empty Group-like associative multMagma;
  redefine func <*a1*> -> HGrStr-yielding Group-like associative ManySortedSet of {1};
end;

:: GROUP_7:th 18
theorem
for b1 being non empty Group-like associative commutative multMagma holds
   <*b1*> is HGrStr-yielding Group-like associative commutative ManySortedSet of {1};

:: GROUP_7:funcnot 9 => GROUP_7:func 9
definition
  let a1 be non empty Group-like associative commutative multMagma;
  redefine func <*a1*> -> HGrStr-yielding Group-like associative commutative ManySortedSet of {1};
end;

:: GROUP_7:condreg 2
registration
  let a1 be non empty multMagma;
  cluster -> FinSequence-like (Element of product Carrier <*a1*>);
end;

:: GROUP_7:condreg 3
registration
  let a1 be non empty multMagma;
  cluster -> FinSequence-like (Element of the carrier of product <*a1*>);
end;

:: GROUP_7:funcnot 10 => GROUP_7:func 10
definition
  let a1 be non empty multMagma;
  let a2 be Element of the carrier of a1;
  redefine func <*a2*> -> Element of the carrier of product <*a1*>;
end;

:: GROUP_7:th 19
theorem
for b1, b2 being non empty multMagma holds
<*b1,b2*> is HGrStr-yielding ManySortedSet of {1,2};

:: GROUP_7:funcnot 11 => GROUP_7:func 11
definition
  let a1, a2 be non empty multMagma;
  redefine func <*a1, a2*> -> HGrStr-yielding ManySortedSet of {1,2};
end;

:: GROUP_7:th 20
theorem
for b1, b2 being non empty Group-like multMagma holds
<*b1,b2*> is HGrStr-yielding Group-like ManySortedSet of {1,2};

:: GROUP_7:funcnot 12 => GROUP_7:func 12
definition
  let a1, a2 be non empty Group-like multMagma;
  redefine func <*a1, a2*> -> HGrStr-yielding Group-like ManySortedSet of {1,2};
end;

:: GROUP_7:th 21
theorem
for b1, b2 being non empty associative multMagma holds
<*b1,b2*> is HGrStr-yielding associative ManySortedSet of {1,2};

:: GROUP_7:funcnot 13 => GROUP_7:func 13
definition
  let a1, a2 be non empty associative multMagma;
  redefine func <*a1, a2*> -> HGrStr-yielding associative ManySortedSet of {1,2};
end;

:: GROUP_7:th 22
theorem
for b1, b2 being non empty commutative multMagma holds
<*b1,b2*> is HGrStr-yielding commutative ManySortedSet of {1,2};

:: GROUP_7:funcnot 14 => GROUP_7:func 14
definition
  let a1, a2 be non empty commutative multMagma;
  redefine func <*a1, a2*> -> HGrStr-yielding commutative ManySortedSet of {1,2};
end;

:: GROUP_7:th 23
theorem
for b1, b2 being non empty Group-like associative multMagma holds
<*b1,b2*> is HGrStr-yielding Group-like associative ManySortedSet of {1,2};

:: GROUP_7:funcnot 15 => GROUP_7:func 15
definition
  let a1, a2 be non empty Group-like associative multMagma;
  redefine func <*a1, a2*> -> HGrStr-yielding Group-like associative ManySortedSet of {1,2};
end;

:: GROUP_7:th 24
theorem
for b1, b2 being non empty Group-like associative commutative multMagma holds
<*b1,b2*> is HGrStr-yielding Group-like associative commutative ManySortedSet of {1,2};

:: GROUP_7:funcnot 16 => GROUP_7:func 16
definition
  let a1, a2 be non empty Group-like associative commutative multMagma;
  redefine func <*a1, a2*> -> HGrStr-yielding Group-like associative commutative ManySortedSet of {1,2};
end;

:: GROUP_7:condreg 4
registration
  let a1, a2 be non empty multMagma;
  cluster -> FinSequence-like (Element of product Carrier <*a1,a2*>);
end;

:: GROUP_7:condreg 5
registration
  let a1, a2 be non empty multMagma;
  cluster -> FinSequence-like (Element of the carrier of product <*a1,a2*>);
end;

:: GROUP_7:funcnot 17 => GROUP_7:func 17
definition
  let a1, a2 be non empty multMagma;
  let a3 be Element of the carrier of a1;
  let a4 be Element of the carrier of a2;
  redefine func <*a3, a4*> -> Element of the carrier of product <*a1,a2*>;
end;

:: GROUP_7:th 25
theorem
for b1, b2, b3 being non empty multMagma holds
<*b1,b2,b3*> is HGrStr-yielding ManySortedSet of {1,2,3};

:: GROUP_7:funcnot 18 => GROUP_7:func 18
definition
  let a1, a2, a3 be non empty multMagma;
  redefine func <*a1, a2, a3*> -> HGrStr-yielding ManySortedSet of {1,2,3};
end;

:: GROUP_7:th 26
theorem
for b1, b2, b3 being non empty Group-like multMagma holds
<*b1,b2,b3*> is HGrStr-yielding Group-like ManySortedSet of {1,2,3};

:: GROUP_7:funcnot 19 => GROUP_7:func 19
definition
  let a1, a2, a3 be non empty Group-like multMagma;
  redefine func <*a1, a2, a3*> -> HGrStr-yielding Group-like ManySortedSet of {1,2,3};
end;

:: GROUP_7:th 27
theorem
for b1, b2, b3 being non empty associative multMagma holds
<*b1,b2,b3*> is HGrStr-yielding associative ManySortedSet of {1,2,3};

:: GROUP_7:funcnot 20 => GROUP_7:func 20
definition
  let a1, a2, a3 be non empty associative multMagma;
  redefine func <*a1, a2, a3*> -> HGrStr-yielding associative ManySortedSet of {1,2,3};
end;

:: GROUP_7:th 28
theorem
for b1, b2, b3 being non empty commutative multMagma holds
<*b1,b2,b3*> is HGrStr-yielding commutative ManySortedSet of {1,2,3};

:: GROUP_7:funcnot 21 => GROUP_7:func 21
definition
  let a1, a2, a3 be non empty commutative multMagma;
  redefine func <*a1, a2, a3*> -> HGrStr-yielding commutative ManySortedSet of {1,2,3};
end;

:: GROUP_7:th 29
theorem
for b1, b2, b3 being non empty Group-like associative multMagma holds
<*b1,b2,b3*> is HGrStr-yielding Group-like associative ManySortedSet of {1,2,3};

:: GROUP_7:funcnot 22 => GROUP_7:func 22
definition
  let a1, a2, a3 be non empty Group-like associative multMagma;
  redefine func <*a1, a2, a3*> -> HGrStr-yielding Group-like associative ManySortedSet of {1,2,3};
end;

:: GROUP_7:th 30
theorem
for b1, b2, b3 being non empty Group-like associative commutative multMagma holds
<*b1,b2,b3*> is HGrStr-yielding Group-like associative commutative ManySortedSet of {1,2,3};

:: GROUP_7:funcnot 23 => GROUP_7:func 23
definition
  let a1, a2, a3 be non empty Group-like associative commutative multMagma;
  redefine func <*a1, a2, a3*> -> HGrStr-yielding Group-like associative commutative ManySortedSet of {1,2,3};
end;

:: GROUP_7:condreg 6
registration
  let a1, a2, a3 be non empty multMagma;
  cluster -> FinSequence-like (Element of product Carrier <*a1,a2,a3*>);
end;

:: GROUP_7:condreg 7
registration
  let a1, a2, a3 be non empty multMagma;
  cluster -> FinSequence-like (Element of the carrier of product <*a1,a2,a3*>);
end;

:: GROUP_7:funcnot 24 => GROUP_7:func 24
definition
  let a1, a2, a3 be non empty multMagma;
  let a4 be Element of the carrier of a1;
  let a5 be Element of the carrier of a2;
  let a6 be Element of the carrier of a3;
  redefine func <*a4, a5, a6*> -> Element of the carrier of product <*a1,a2,a3*>;
end;

:: GROUP_7:th 31
theorem
for b1 being non empty multMagma
for b2, b3 being Element of the carrier of b1 holds
<*b2*> * <*b3*> = <*b2 * b3*>;

:: GROUP_7:th 32
theorem
for b1, b2 being non empty multMagma
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2 holds
<*b3,b5*> * <*b4,b6*> = <*b3 * b4,b5 * b6*>;

:: GROUP_7:th 33
theorem
for b1, b2, b3 being non empty multMagma
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,b6,b8*> * <*b5,b7,b9*> = <*b4 * b5,b6 * b7,b8 * b9*>;

:: GROUP_7:th 34
theorem
for b1 being non empty Group-like multMagma holds
   1_ product <*b1*> = <*1_ b1*>;

:: GROUP_7:th 35
theorem
for b1, b2 being non empty Group-like multMagma holds
1_ product <*b1,b2*> = <*1_ b1,1_ b2*>;

:: GROUP_7:th 36
theorem
for b1, b2, b3 being non empty Group-like multMagma holds
1_ product <*b1,b2,b3*> = <*1_ b1,1_ b2,1_ b3*>;

:: GROUP_7:th 37
theorem
for b1 being non empty Group-like associative multMagma
for b2 being Element of the carrier of b1 holds
   <*b2*> " = <*b2 "*>;

:: GROUP_7:th 38
theorem
for b1, b2 being non empty Group-like associative multMagma
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2 holds
   <*b3,b4*> " = <*b3 ",b4 "*>;

:: GROUP_7:th 39
theorem
for b1, b2, b3 being non empty Group-like associative multMagma
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,b5,b6*> " = <*b4 ",b5 ",b6 "*>;

:: GROUP_7:th 40
theorem
for b1 being non empty Group-like associative multMagma
for b2 being Function-like quasi_total Relation of the carrier of b1,the carrier of product <*b1*>
      st for b3 being Element of the carrier of b1 holds
           b2 . b3 = <*b3*>
   holds b2 is Function-like quasi_total multiplicative Relation of the carrier of b1,the carrier of product <*b1*>;

:: GROUP_7:th 41
theorem
for b1 being non empty Group-like associative multMagma
for b2 being Function-like quasi_total multiplicative Relation of the carrier of b1,the carrier of product <*b1*>
      st for b3 being Element of the carrier of b1 holds
           b2 . b3 = <*b3*>
   holds b2 is being_isomorphism(b1, product <*b1*>);

:: GROUP_7:th 42
theorem
for b1 being non empty Group-like associative multMagma holds
   b1,product <*b1*> are_isomorphic;