Article GRCAT_1, MML version 4.99.1005

:: GRCAT_1:th 2
theorem
for b1, b2, b3, b4 being set
      st b4 in b3 & b3 c= [:b1,b2:]
   holds ex b5 being Element of b1 st
      ex b6 being Element of b2 st
         b4 = [b5,b6];

:: GRCAT_1:th 3
theorem
for b1 being non empty universal set
for b2, b3, b4, b5 being Element of b1 holds
[b2,b3,b4] in b1 & [b2,b3,b4,b5] in b1;

:: GRCAT_1:th 4
theorem
for b1 being non empty universal set
for b2, b3 being set
      st b2 in b3 & b3 in b1
   holds b2 in b1;

:: GRCAT_1:th 5
theorem
op2 .({},{}) = {} & op1 . {} = {} & op0 = {};

:: GRCAT_1:th 6
theorem
for b1 being non empty universal set holds
   {{}} in b1 &
    [{{}},{{}}] in b1 &
    [:{{}},{{}}:] in b1 &
    op2 in b1 &
    op1 in b1;

:: GRCAT_1:th 7
theorem
addLoopStr(#1,op2,op0#) is midpoint_operator;

:: GRCAT_1:funcreg 1
registration
  cluster Trivial-addLoopStr -> midpoint_operator;
end;

:: GRCAT_1:th 8
theorem
(for b1 being Element of the carrier of Trivial-addLoopStr holds
    b1 = {}) &
 (for b1, b2 being Element of the carrier of Trivial-addLoopStr holds
 b1 + b2 = {}) &
 (for b1 being Element of the carrier of Trivial-addLoopStr holds
    - b1 = {}) &
 0. Trivial-addLoopStr = {};

:: GRCAT_1:funcnot 1 => GRCAT_1:func 1
definition
  let a1 be non void Category-like CatStr;
  let a2 be non empty Element of bool the Vertices of a1;
  func Morphs A2 -> Element of bool the Edges of a1 equals
    union {Hom(b1,b2) where b1 is Element of the Vertices of a1, b2 is Element of the Vertices of a1: b1 in a2 & b2 in a2};
end;

:: GRCAT_1:def 5
theorem
for b1 being non void Category-like CatStr
for b2 being non empty Element of bool the Vertices of b1 holds
   Morphs b2 = union {Hom(b3,b4) where b3 is Element of the Vertices of b1, b4 is Element of the Vertices of b1: b3 in b2 & b4 in b2};

:: GRCAT_1:funcreg 2
registration
  let a1 be non void Category-like CatStr;
  let a2 be non empty Element of bool the Vertices of a1;
  cluster Morphs a2 -> non empty;
end;

:: GRCAT_1:funcnot 2 => GRCAT_1:func 2
definition
  let a1 be non void Category-like CatStr;
  let a2 be non empty Element of bool the Vertices of a1;
  func dom A2 -> Function-like quasi_total Relation of Morphs a2,a2 equals
    (the Source of a1) | Morphs a2;
end;

:: GRCAT_1:def 6
theorem
for b1 being non void Category-like CatStr
for b2 being non empty Element of bool the Vertices of b1 holds
   dom b2 = (the Source of b1) | Morphs b2;

:: GRCAT_1:funcnot 3 => GRCAT_1:func 3
definition
  let a1 be non void Category-like CatStr;
  let a2 be non empty Element of bool the Vertices of a1;
  func cod A2 -> Function-like quasi_total Relation of Morphs a2,a2 equals
    (the Target of a1) | Morphs a2;
end;

:: GRCAT_1:def 7
theorem
for b1 being non void Category-like CatStr
for b2 being non empty Element of bool the Vertices of b1 holds
   cod b2 = (the Target of b1) | Morphs b2;

:: GRCAT_1:funcnot 4 => GRCAT_1:func 4
definition
  let a1 be non void Category-like CatStr;
  let a2 be non empty Element of bool the Vertices of a1;
  func comp A2 -> Function-like Relation of [:Morphs a2,Morphs a2:],Morphs a2 equals
    (the Comp of a1) || Morphs a2;
end;

:: GRCAT_1:def 8
theorem
for b1 being non void Category-like CatStr
for b2 being non empty Element of bool the Vertices of b1 holds
   comp b2 = (the Comp of b1) || Morphs b2;

:: GRCAT_1:funcnot 5 => GRCAT_1:func 5
definition
  let a1 be non void Category-like CatStr;
  let a2 be non empty Element of bool the Vertices of a1;
  func ID A2 -> Function-like quasi_total Relation of a2,Morphs a2 equals
    (the Id of a1) | a2;
end;

:: GRCAT_1:def 9
theorem
for b1 being non void Category-like CatStr
for b2 being non empty Element of bool the Vertices of b1 holds
   ID b2 = (the Id of b1) | b2;

:: GRCAT_1:funcnot 6 => GRCAT_1:func 6
definition
  let a1 be non void Category-like CatStr;
  let a2 be non empty Element of bool the Vertices of a1;
  func cat A2 -> Subcategory of a1 equals
    CatStr(#a2,Morphs a2,dom a2,cod a2,comp a2,ID a2#);
end;

:: GRCAT_1:def 10
theorem
for b1 being non void Category-like CatStr
for b2 being non empty Element of bool the Vertices of b1 holds
   cat b2 = CatStr(#b2,Morphs b2,dom b2,cod b2,comp b2,ID b2#);

:: GRCAT_1:funcreg 3
registration
  let a1 be non void Category-like CatStr;
  let a2 be non empty Element of bool the Vertices of a1;
  cluster cat a2 -> strict;
end;

:: GRCAT_1:th 10
theorem
for b1 being non void Category-like CatStr
for b2 being non empty Element of bool the Vertices of b1 holds
   the Vertices of cat b2 = b2;

:: GRCAT_1:th 12
theorem
for b1, b2 being 1-sorted
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
   b3 * id b1 = b3 & (id b2) * b3 = b3;

:: GRCAT_1:funcnot 7 => GRCAT_1:func 7
definition
  let a1 be non empty 1-sorted;
  let a2 be non empty ZeroStr;
  func ZeroMap(A1,A2) -> Function-like quasi_total Relation of the carrier of a1,the carrier of a2 equals
    (the carrier of a1) --> 0. a2;
end;

:: GRCAT_1:def 12
theorem
for b1 being non empty 1-sorted
for b2 being non empty ZeroStr holds
   ZeroMap(b1,b2) = (the carrier of b1) --> 0. b2;

:: GRCAT_1:attrnot 1 => GRCAT_1:attr 1
definition
  let a1, a2 be non empty addLoopStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  attr a3 is additive means
    for b1, b2 being Element of the carrier of a1 holds
    a3 . (b1 + b2) = (a3 . b1) + (a3 . b2);
end;

:: GRCAT_1:dfs 8
definiens
  let a1, a2 be non empty addLoopStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
To prove
     a3 is additive
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    a3 . (b1 + b2) = (a3 . b1) + (a3 . b2);

:: GRCAT_1:def 13
theorem
for b1, b2 being non empty addLoopStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 holds
      b3 is additive(b1, b2)
   iff
      for b4, b5 being Element of the carrier of b1 holds
      b3 . (b4 + b5) = (b3 . b4) + (b3 . b5);

:: GRCAT_1:th 13
theorem
comp Trivial-addLoopStr = op1;

:: GRCAT_1:th 14
theorem
for b1, b2, b3 being non empty addLoopStr
for b4 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
for b5 being Function-like quasi_total Relation of the carrier of b2,the carrier of b3
      st b4 is additive(b1, b2) & b5 is additive(b2, b3)
   holds b5 * b4 is additive(b1, b3);

:: GRCAT_1:th 16
theorem
for b1 being non empty addLoopStr
for b2 being non empty right_zeroed addLoopStr holds
   ZeroMap(b1,b2) is additive(b1, b2);

:: GRCAT_1:structnot 1 => GRCAT_1:struct 1
definition
  struct() GroupMorphismStr(#
    Source -> non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr,
    Target -> non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr,
    Fun -> Function-like quasi_total Relation of the carrier of the Source of it,the carrier of the Target of it
  #);
end;

:: GRCAT_1:attrnot 2 => GRCAT_1:attr 2
definition
  let a1 be GroupMorphismStr;
  attr a1 is strict;
end;

:: GRCAT_1:exreg 1
registration
  cluster strict GroupMorphismStr;
end;

:: GRCAT_1:aggrnot 1 => GRCAT_1:aggr 1
definition
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  let a3 be Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
  aggr GroupMorphismStr(#a1,a2,a3#) -> strict GroupMorphismStr;
end;

:: GRCAT_1:selnot 1 => GRCAT_1:sel 1
definition
  let a1 be GroupMorphismStr;
  sel the Source of a1 -> non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
end;

:: GRCAT_1:selnot 2 => GRCAT_1:sel 2
definition
  let a1 be GroupMorphismStr;
  sel the Target of a1 -> non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
end;

:: GRCAT_1:selnot 3 => GRCAT_1:sel 3
definition
  let a1 be GroupMorphismStr;
  sel the Fun of a1 -> Function-like quasi_total Relation of the carrier of the Source of a1,the carrier of the Target of a1;
end;

:: GRCAT_1:funcnot 8 => GRCAT_1:func 8
definition
  let a1 be GroupMorphismStr;
  func dom A1 -> non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr equals
    the Source of a1;
end;

:: GRCAT_1:def 14
theorem
for b1 being GroupMorphismStr holds
   dom b1 = the Source of b1;

:: GRCAT_1:funcnot 9 => GRCAT_1:func 9
definition
  let a1 be GroupMorphismStr;
  func cod A1 -> non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr equals
    the Target of a1;
end;

:: GRCAT_1:def 15
theorem
for b1 being GroupMorphismStr holds
   cod b1 = the Target of b1;

:: GRCAT_1:funcnot 10 => GRCAT_1:func 10
definition
  let a1 be GroupMorphismStr;
  func fun A1 -> Function-like quasi_total Relation of the carrier of dom a1,the carrier of cod a1 equals
    the Fun of a1;
end;

:: GRCAT_1:def 16
theorem
for b1 being GroupMorphismStr holds
   fun b1 = the Fun of b1;

:: GRCAT_1:th 17
theorem
for b1 being GroupMorphismStr
for b2, b3 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b3
      st b1 = GroupMorphismStr(#b2,b3,b4#)
   holds dom b1 = b2 & cod b1 = b3 & fun b1 = b4;

:: GRCAT_1:funcnot 11 => GRCAT_1:func 11
definition
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  func ZERO(A1,A2) -> GroupMorphismStr equals
    GroupMorphismStr(#a1,a2,ZeroMap(a1,a2)#);
end;

:: GRCAT_1:def 17
theorem
for b1, b2 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr holds
ZERO(b1,b2) = GroupMorphismStr(#b1,b2,ZeroMap(b1,b2)#);

:: GRCAT_1:funcreg 4
registration
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  cluster ZERO(a1,a2) -> strict;
end;

:: GRCAT_1:attrnot 3 => GRCAT_1:attr 3
definition
  let a1 be GroupMorphismStr;
  attr a1 is GroupMorphism-like means
    fun a1 is additive(dom a1, cod a1);
end;

:: GRCAT_1:dfs 13
definiens
  let a1 be GroupMorphismStr;
To prove
     a1 is GroupMorphism-like
it is sufficient to prove
  thus fun a1 is additive(dom a1, cod a1);

:: GRCAT_1:def 18
theorem
for b1 being GroupMorphismStr holds
      b1 is GroupMorphism-like
   iff
      fun b1 is additive(dom b1, cod b1);

:: GRCAT_1:exreg 2
registration
  cluster strict GroupMorphism-like GroupMorphismStr;
end;

:: GRCAT_1:modenot 1
definition
  mode GroupMorphism is GroupMorphism-like GroupMorphismStr;
end;

:: GRCAT_1:th 18
theorem
for b1 being GroupMorphism-like GroupMorphismStr holds
   the Fun of b1 is additive(the Source of b1, the Target of b1);

:: GRCAT_1:funcreg 5
registration
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  cluster ZERO(a1,a2) -> GroupMorphism-like;
end;

:: GRCAT_1:modenot 2 => GRCAT_1:mode 1
definition
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  mode Morphism of A1,A2 -> GroupMorphism-like GroupMorphismStr means
    dom it = a1 & cod it = a2;
end;

:: GRCAT_1:dfs 14
definiens
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  let a3 be GroupMorphism-like GroupMorphismStr;
To prove
     a3 is Morphism of a1,a2
it is sufficient to prove
  thus dom a3 = a1 & cod a3 = a2;

:: GRCAT_1:def 19
theorem
for b1, b2 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b3 being GroupMorphism-like GroupMorphismStr holds
      b3 is Morphism of b1,b2
   iff
      dom b3 = b1 & cod b3 = b2;

:: GRCAT_1:exreg 3
registration
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  cluster strict GroupMorphism-like Morphism of a1,a2;
end;

:: GRCAT_1:th 19
theorem
for b1, b2 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b3 being strict GroupMorphismStr
      st dom b3 = b1 & cod b3 = b2 & fun b3 is additive(dom b3, cod b3)
   holds b3 is strict Morphism of b1,b2;

:: GRCAT_1:th 20
theorem
for b1, b2 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st b3 is additive(b1, b2)
   holds GroupMorphismStr(#b1,b2,b3#) is strict Morphism of b1,b2;

:: GRCAT_1:th 21
theorem
for b1 being non empty addLoopStr holds
   id b1 is additive(b1, b1);

:: GRCAT_1:funcnot 12 => GRCAT_1:func 12
definition
  let a1 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  func ID A1 -> Morphism of a1,a1 equals
    GroupMorphismStr(#a1,a1,id a1#);
end;

:: GRCAT_1:def 20
theorem
for b1 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr holds
   ID b1 = GroupMorphismStr(#b1,b1,id b1#);

:: GRCAT_1:funcreg 6
registration
  let a1 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  cluster ID a1 -> strict;
end;

:: GRCAT_1:funcnot 13 => GRCAT_1:func 13
definition
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  redefine func ZERO(a1,a2) -> strict Morphism of a1,a2;
end;

:: GRCAT_1:th 22
theorem
for b1, b2 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b3 being Morphism of b1,b2 holds
   ex b4 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 st
      GroupMorphismStr(#the Source of b3,the Target of b3,the Fun of b3#) = GroupMorphismStr(#b1,b2,b4#) &
       b4 is additive(b1, b2);

:: GRCAT_1:th 23
theorem
for b1, b2 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b3 being strict Morphism of b1,b2 holds
   ex b4 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 st
      b3 = GroupMorphismStr(#b1,b2,b4#);

:: GRCAT_1:th 24
theorem
for b1 being GroupMorphism-like GroupMorphismStr holds
   ex b2, b3 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr st
      b1 is Morphism of b2,b3;

:: GRCAT_1:th 25
theorem
for b1 being strict GroupMorphism-like GroupMorphismStr holds
   ex b2, b3 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr st
      ex b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b3 st
         b1 is Morphism of b2,b3 & b1 = GroupMorphismStr(#b2,b3,b4#) & b4 is additive(b2, b3);

:: GRCAT_1:th 26
theorem
for b1, b2 being GroupMorphism-like GroupMorphismStr
      st dom b1 = cod b2
   holds ex b3, b4, b5 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr st
      b1 is Morphism of b4,b5 & b2 is Morphism of b3,b4;

:: GRCAT_1:funcnot 14 => GRCAT_1:func 14
definition
  let a1, a2 be GroupMorphism-like GroupMorphismStr;
  assume dom a1 = cod a2;
  func A1 * A2 -> strict GroupMorphism-like GroupMorphismStr means
    for b1, b2, b3 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
    for b4 being Function-like quasi_total Relation of the carrier of b2,the carrier of b3
    for b5 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
          st GroupMorphismStr(#the Source of a1,the Target of a1,the Fun of a1#) = GroupMorphismStr(#b2,b3,b4#) &
             GroupMorphismStr(#the Source of a2,the Target of a2,the Fun of a2#) = GroupMorphismStr(#b1,b2,b5#)
       holds it = GroupMorphismStr(#b1,b3,b4 * b5#);
end;

:: GRCAT_1:def 21
theorem
for b1, b2 being GroupMorphism-like GroupMorphismStr
   st dom b1 = cod b2
for b3 being strict GroupMorphism-like GroupMorphismStr holds
      b3 = b1 * b2
   iff
      for b4, b5, b6 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
      for b7 being Function-like quasi_total Relation of the carrier of b5,the carrier of b6
      for b8 being Function-like quasi_total Relation of the carrier of b4,the carrier of b5
            st GroupMorphismStr(#the Source of b1,the Target of b1,the Fun of b1#) = GroupMorphismStr(#b5,b6,b7#) &
               GroupMorphismStr(#the Source of b2,the Target of b2,the Fun of b2#) = GroupMorphismStr(#b4,b5,b8#)
         holds b3 = GroupMorphismStr(#b4,b6,b7 * b8#);

:: GRCAT_1:th 28
theorem
for b1, b2, b3 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b4 being Morphism of b2,b3
for b5 being Morphism of b1,b2 holds
   b4 * b5 is Morphism of b1,b3;

:: GRCAT_1:funcnot 15 => GRCAT_1:func 15
definition
  let a1, a2, a3 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  let a4 be Morphism of a2,a3;
  let a5 be Morphism of a1,a2;
  redefine func a4 * a5 -> strict Morphism of a1,a3;
end;

:: GRCAT_1:th 29
theorem
for b1, b2, b3 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b4 being Morphism of b2,b3
for b5 being Morphism of b1,b2
for b6 being Function-like quasi_total Relation of the carrier of b2,the carrier of b3
for b7 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st b4 = GroupMorphismStr(#b2,b3,b6#) & b5 = GroupMorphismStr(#b1,b2,b7#)
   holds b4 * b5 = GroupMorphismStr(#b1,b3,b6 * b7#);

:: GRCAT_1:th 30
theorem
for b1, b2 being strict GroupMorphism-like GroupMorphismStr
      st dom b2 = cod b1
   holds ex b3, b4, b5 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr st
      ex b6 being Function-like quasi_total Relation of the carrier of b3,the carrier of b4 st
         ex b7 being Function-like quasi_total Relation of the carrier of b4,the carrier of b5 st
            b1 = GroupMorphismStr(#b3,b4,b6#) & b2 = GroupMorphismStr(#b4,b5,b7#) & b2 * b1 = GroupMorphismStr(#b3,b5,b7 * b6#);

:: GRCAT_1:th 31
theorem
for b1, b2 being strict GroupMorphism-like GroupMorphismStr
      st dom b2 = cod b1
   holds dom (b2 * b1) = dom b1 & cod (b2 * b1) = cod b2;

:: GRCAT_1:th 32
theorem
for b1, b2, b3, b4 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b5 being strict Morphism of b1,b2
for b6 being strict Morphism of b2,b3
for b7 being strict Morphism of b3,b4 holds
   b7 * (b6 * b5) = (b7 * b6) * b5;

:: GRCAT_1:th 33
theorem
for b1, b2, b3 being strict GroupMorphism-like GroupMorphismStr
      st dom b3 = cod b2 & dom b2 = cod b1
   holds b3 * (b2 * b1) = (b3 * b2) * b1;

:: GRCAT_1:th 34
theorem
for b1 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr holds
   dom ID b1 = b1 &
    cod ID b1 = b1 &
    (for b2 being strict GroupMorphism-like GroupMorphismStr
          st cod b2 = b1
       holds (ID b1) * b2 = b2) &
    (for b2 being strict GroupMorphism-like GroupMorphismStr
          st dom b2 = b1
       holds b2 * ID b1 = b2);

:: GRCAT_1:attrnot 4 => GRCAT_1:attr 4
definition
  let a1 be set;
  attr a1 is Group_DOMAIN-like means
    for b1 being set
          st b1 in a1
       holds b1 is non empty strict add-associative right_zeroed left_zeroed Loop-like addLoopStr;
end;

:: GRCAT_1:dfs 17
definiens
  let a1 be set;
To prove
     a1 is Group_DOMAIN-like
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is non empty strict add-associative right_zeroed left_zeroed Loop-like addLoopStr;

:: GRCAT_1:def 22
theorem
for b1 being set holds
      b1 is Group_DOMAIN-like
   iff
      for b2 being set
            st b2 in b1
         holds b2 is non empty strict add-associative right_zeroed left_zeroed Loop-like addLoopStr;

:: GRCAT_1:exreg 4
registration
  cluster non empty Group_DOMAIN-like set;
end;

:: GRCAT_1:modenot 3
definition
  mode Group_DOMAIN is non empty Group_DOMAIN-like set;
end;

:: GRCAT_1:modenot 4 => GRCAT_1:mode 2
definition
  let a1 be non empty Group_DOMAIN-like set;
  redefine mode Element of a1 -> non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
end;

:: GRCAT_1:exreg 5
registration
  let a1 be non empty Group_DOMAIN-like set;
  cluster non empty left_add-cancelable right_add-cancelable add-cancelable strict add-associative right_zeroed left_zeroed add-left-invertible add-right-invertible Loop-like Element of a1;
end;

:: GRCAT_1:attrnot 5 => GRCAT_1:attr 5
definition
  let a1 be set;
  attr a1 is GroupMorphism_DOMAIN-like means
    for b1 being set
          st b1 in a1
       holds b1 is strict GroupMorphism-like GroupMorphismStr;
end;

:: GRCAT_1:dfs 18
definiens
  let a1 be set;
To prove
     a1 is GroupMorphism_DOMAIN-like
it is sufficient to prove
  thus for b1 being set
          st b1 in a1
       holds b1 is strict GroupMorphism-like GroupMorphismStr;

:: GRCAT_1:def 23
theorem
for b1 being set holds
      b1 is GroupMorphism_DOMAIN-like
   iff
      for b2 being set
            st b2 in b1
         holds b2 is strict GroupMorphism-like GroupMorphismStr;

:: GRCAT_1:exreg 6
registration
  cluster non empty GroupMorphism_DOMAIN-like set;
end;

:: GRCAT_1:modenot 5
definition
  mode GroupMorphism_DOMAIN is non empty GroupMorphism_DOMAIN-like set;
end;

:: GRCAT_1:modenot 6 => GRCAT_1:mode 3
definition
  let a1 be non empty GroupMorphism_DOMAIN-like set;
  redefine mode Element of a1 -> GroupMorphism-like GroupMorphismStr;
end;

:: GRCAT_1:exreg 7
registration
  let a1 be non empty GroupMorphism_DOMAIN-like set;
  cluster strict GroupMorphism-like Element of a1;
end;

:: GRCAT_1:th 37
theorem
for b1 being strict GroupMorphism-like GroupMorphismStr holds
   {b1} is non empty GroupMorphism_DOMAIN-like set;

:: GRCAT_1:modenot 7 => GRCAT_1:mode 4
definition
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  mode GroupMorphism_DOMAIN of A1,A2 -> non empty GroupMorphism_DOMAIN-like set means
    for b1 being Element of it holds
       b1 is strict Morphism of a1,a2;
end;

:: GRCAT_1:dfs 19
definiens
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  let a3 be non empty GroupMorphism_DOMAIN-like set;
To prove
     a3 is GroupMorphism_DOMAIN of a1,a2
it is sufficient to prove
  thus for b1 being Element of a3 holds
       b1 is strict Morphism of a1,a2;

:: GRCAT_1:def 24
theorem
for b1, b2 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b3 being non empty GroupMorphism_DOMAIN-like set holds
      b3 is GroupMorphism_DOMAIN of b1,b2
   iff
      for b4 being Element of b3 holds
         b4 is strict Morphism of b1,b2;

:: GRCAT_1:th 38
theorem
for b1 being non empty set
for b2, b3 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr holds
   b1 is GroupMorphism_DOMAIN of b2,b3
iff
   for b4 being Element of b1 holds
      b4 is strict Morphism of b2,b3;

:: GRCAT_1:th 39
theorem
for b1, b2 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b3 being strict Morphism of b1,b2 holds
   {b3} is GroupMorphism_DOMAIN of b1,b2;

:: GRCAT_1:modenot 8 => GRCAT_1:mode 5
definition
  let a1, a2 be 1-sorted;
  mode MapsSet of A1,A2 means
    for b1 being set
          st b1 in it
       holds b1 is Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
end;

:: GRCAT_1:dfs 20
definiens
  let a1, a2 be 1-sorted;
  let a3 be set;
To prove
     a3 is MapsSet of a1,a2
it is sufficient to prove
  thus for b1 being set
          st b1 in a3
       holds b1 is Function-like quasi_total Relation of the carrier of a1,the carrier of a2;

:: GRCAT_1:def 25
theorem
for b1, b2 being 1-sorted
for b3 being set holds
      b3 is MapsSet of b1,b2
   iff
      for b4 being set
            st b4 in b3
         holds b4 is Function-like quasi_total Relation of the carrier of b1,the carrier of b2;

:: GRCAT_1:funcnot 16 => GRCAT_1:func 16
definition
  let a1, a2 be 1-sorted;
  func Maps(A1,A2) -> MapsSet of a1,a2 equals
    Funcs(the carrier of a1,the carrier of a2);
end;

:: GRCAT_1:def 26
theorem
for b1, b2 being 1-sorted holds
Maps(b1,b2) = Funcs(the carrier of b1,the carrier of b2);

:: GRCAT_1:funcreg 7
registration
  let a1 be 1-sorted;
  let a2 be non empty 1-sorted;
  cluster Maps(a1,a2) -> non empty;
end;

:: GRCAT_1:exreg 8
registration
  let a1 be 1-sorted;
  let a2 be non empty 1-sorted;
  cluster non empty MapsSet of a1,a2;
end;

:: GRCAT_1:modenot 9 => GRCAT_1:mode 6
definition
  let a1 be 1-sorted;
  let a2 be non empty 1-sorted;
  let a3 be non empty MapsSet of a1,a2;
  redefine mode Element of a3 -> Function-like quasi_total Relation of the carrier of a1,the carrier of a2;
end;

:: GRCAT_1:funcnot 17 => GRCAT_1:func 17
definition
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  func Morphs(A1,A2) -> GroupMorphism_DOMAIN of a1,a2 means
    for b1 being set holds
          b1 in it
       iff
          b1 is strict Morphism of a1,a2;
end;

:: GRCAT_1:def 27
theorem
for b1, b2 being non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr
for b3 being GroupMorphism_DOMAIN of b1,b2 holds
      b3 = Morphs(b1,b2)
   iff
      for b4 being set holds
            b4 in b3
         iff
            b4 is strict Morphism of b1,b2;

:: GRCAT_1:modenot 10 => GRCAT_1:mode 7
definition
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  let a3 be GroupMorphism_DOMAIN of a1,a2;
  redefine mode Element of a3 -> Morphism of a1,a2;
end;

:: GRCAT_1:exreg 9
registration
  let a1, a2 be non empty add-associative right_zeroed left_zeroed Loop-like addLoopStr;
  let a3 be GroupMorphism_DOMAIN of a1,a2;
  cluster strict GroupMorphism-like Element of a3;
end;

:: GRCAT_1:prednot 1 => GRCAT_1:pred 1
definition
  let a1, a2 be set;
  pred GO A1,A2 means
    ex b1, b2, b3, b4 being set st
       a1 = [b1,b2,b3,b4] &
        (ex b5 being non empty strict add-associative right_zeroed left_zeroed Loop-like addLoopStr st
           a2 = b5 & b1 = the carrier of b5 & b2 = the addF of b5 & b3 = comp b5 & b4 = 0. b5);
end;

:: GRCAT_1:dfs 23
definiens
  let a1, a2 be set;
To prove
     GO a1,a2
it is sufficient to prove
  thus ex b1, b2, b3, b4 being set st
       a1 = [b1,b2,b3,b4] &
        (ex b5 being non empty strict add-associative right_zeroed left_zeroed Loop-like addLoopStr st
           a2 = b5 & b1 = the carrier of b5 & b2 = the addF of b5 & b3 = comp b5 & b4 = 0. b5);

:: GRCAT_1:def 28
theorem
for b1, b2 being set holds
   GO b1,b2
iff
   ex b3, b4, b5, b6 being set st
      b1 = [b3,b4,b5,b6] &
       (ex b7 being non empty strict add-associative right_zeroed left_zeroed Loop-like addLoopStr st
          b2 = b7 & b3 = the carrier of b7 & b4 = the addF of b7 & b5 = comp b7 & b6 = 0. b7);

:: GRCAT_1:th 40
theorem
for b1, b2, b3 being set
      st GO b1,b2 & GO b1,b3
   holds b2 = b3;

:: GRCAT_1:th 41
theorem
for b1 being non empty universal set holds
   ex b2 being set st
      b2 in b1 & GO b2,Trivial-addLoopStr;

:: GRCAT_1:funcnot 18 => GRCAT_1:func 18
definition
  let a1 be non empty universal set;
  func GroupObjects A1 -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being set st
             b2 in a1 & GO b2,b1;
end;

:: GRCAT_1:def 29
theorem
for b1 being non empty universal set
for b2 being set holds
      b2 = GroupObjects b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            ex b4 being set st
               b4 in b1 & GO b4,b3;

:: GRCAT_1:th 42
theorem
for b1 being non empty universal set holds
   Trivial-addLoopStr in GroupObjects b1;

:: GRCAT_1:funcreg 8
registration
  let a1 be non empty universal set;
  cluster GroupObjects a1 -> non empty;
end;

:: GRCAT_1:th 43
theorem
for b1 being non empty universal set
for b2 being Element of GroupObjects b1 holds
   b2 is non empty strict add-associative right_zeroed left_zeroed Loop-like addLoopStr;

:: GRCAT_1:funcreg 9
registration
  let a1 be non empty universal set;
  cluster GroupObjects a1 -> Group_DOMAIN-like;
end;

:: GRCAT_1:funcnot 19 => GRCAT_1:func 19
definition
  let a1 be non empty Group_DOMAIN-like set;
  func Morphs A1 -> non empty GroupMorphism_DOMAIN-like set means
    for b1 being set holds
          b1 in it
       iff
          ex b2, b3 being strict Element of a1 st
             b1 is strict Morphism of b2,b3;
end;

:: GRCAT_1:def 30
theorem
for b1 being non empty Group_DOMAIN-like set
for b2 being non empty GroupMorphism_DOMAIN-like set holds
      b2 = Morphs b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            ex b4, b5 being strict Element of b1 st
               b3 is strict Morphism of b4,b5;

:: GRCAT_1:funcnot 20 => GRCAT_1:func 20
definition
  let a1 be non empty Group_DOMAIN-like set;
  let a2 be Element of Morphs a1;
  redefine func dom a2 -> strict Element of a1;
end;

:: GRCAT_1:funcnot 21 => GRCAT_1:func 21
definition
  let a1 be non empty Group_DOMAIN-like set;
  let a2 be Element of Morphs a1;
  redefine func cod a2 -> strict Element of a1;
end;

:: GRCAT_1:funcnot 22 => GRCAT_1:func 22
definition
  let a1 be non empty Group_DOMAIN-like set;
  let a2 be Element of a1;
  func ID A2 -> strict Element of Morphs a1 equals
    ID a2;
end;

:: GRCAT_1:def 31
theorem
for b1 being non empty Group_DOMAIN-like set
for b2 being Element of b1 holds
   ID b2 = ID b2;

:: GRCAT_1:funcnot 23 => GRCAT_1:func 23
definition
  let a1 be non empty Group_DOMAIN-like set;
  func dom A1 -> Function-like quasi_total Relation of Morphs a1,a1 means
    for b1 being Element of Morphs a1 holds
       it . b1 = dom b1;
end;

:: GRCAT_1:def 32
theorem
for b1 being non empty Group_DOMAIN-like set
for b2 being Function-like quasi_total Relation of Morphs b1,b1 holds
      b2 = dom b1
   iff
      for b3 being Element of Morphs b1 holds
         b2 . b3 = dom b3;

:: GRCAT_1:funcnot 24 => GRCAT_1:func 24
definition
  let a1 be non empty Group_DOMAIN-like set;
  func cod A1 -> Function-like quasi_total Relation of Morphs a1,a1 means
    for b1 being Element of Morphs a1 holds
       it . b1 = cod b1;
end;

:: GRCAT_1:def 33
theorem
for b1 being non empty Group_DOMAIN-like set
for b2 being Function-like quasi_total Relation of Morphs b1,b1 holds
      b2 = cod b1
   iff
      for b3 being Element of Morphs b1 holds
         b2 . b3 = cod b3;

:: GRCAT_1:funcnot 25 => GRCAT_1:func 25
definition
  let a1 be non empty Group_DOMAIN-like set;
  func ID A1 -> Function-like quasi_total Relation of a1,Morphs a1 means
    for b1 being Element of a1 holds
       it . b1 = ID b1;
end;

:: GRCAT_1:def 34
theorem
for b1 being non empty Group_DOMAIN-like set
for b2 being Function-like quasi_total Relation of b1,Morphs b1 holds
      b2 = ID b1
   iff
      for b3 being Element of b1 holds
         b2 . b3 = ID b3;

:: GRCAT_1:th 44
theorem
for b1 being non empty Group_DOMAIN-like set
for b2, b3 being Element of Morphs b1
      st dom b2 = cod b3
   holds ex b4, b5, b6 being strict Element of b1 st
      b2 is Morphism of b5,b6 & b3 is Morphism of b4,b5;

:: GRCAT_1:th 45
theorem
for b1 being non empty Group_DOMAIN-like set
for b2, b3 being Element of Morphs b1
      st dom b2 = cod b3
   holds b2 * b3 in Morphs b1;

:: GRCAT_1:funcnot 26 => GRCAT_1:func 26
definition
  let a1 be non empty Group_DOMAIN-like set;
  func comp A1 -> Function-like Relation of [:Morphs a1,Morphs a1:],Morphs a1 means
    (for b1, b2 being Element of Morphs a1 holds
        [b1,b2] in proj1 it
     iff
        dom b1 = cod b2) &
     (for b1, b2 being Element of Morphs a1
           st [b1,b2] in proj1 it
        holds it .(b1,b2) = b1 * b2);
end;

:: GRCAT_1:def 35
theorem
for b1 being non empty Group_DOMAIN-like set
for b2 being Function-like Relation of [:Morphs b1,Morphs b1:],Morphs b1 holds
      b2 = comp b1
   iff
      (for b3, b4 being Element of Morphs b1 holds
          [b3,b4] in proj1 b2
       iff
          dom b3 = cod b4) &
       (for b3, b4 being Element of Morphs b1
             st [b3,b4] in proj1 b2
          holds b2 .(b3,b4) = b3 * b4);

:: GRCAT_1:funcnot 27 => GRCAT_1:func 27
definition
  let a1 be non empty universal set;
  func GroupCat A1 -> CatStr equals
    CatStr(#GroupObjects a1,Morphs GroupObjects a1,dom GroupObjects a1,cod GroupObjects a1,comp GroupObjects a1,ID GroupObjects a1#);
end;

:: GRCAT_1:def 36
theorem
for b1 being non empty universal set holds
   GroupCat b1 = CatStr(#GroupObjects b1,Morphs GroupObjects b1,dom GroupObjects b1,cod GroupObjects b1,comp GroupObjects b1,ID GroupObjects b1#);

:: GRCAT_1:funcreg 10
registration
  let a1 be non empty universal set;
  cluster GroupCat a1 -> strict non void;
end;

:: GRCAT_1:th 46
theorem
for b1 being non empty universal set
for b2, b3 being Element of the Edges of GroupCat b1 holds
   [b3,b2] in proj1 the Comp of GroupCat b1
iff
   dom b3 = cod b2;

:: GRCAT_1:th 47
theorem
for b1 being non empty universal set
for b2 being Element of the Edges of GroupCat b1
for b3 being Element of Morphs GroupObjects b1
for b4 being Element of the Vertices of GroupCat b1
for b5 being Element of GroupObjects b1 holds
   b2 is strict Element of Morphs GroupObjects b1 & b3 is Element of the Edges of GroupCat b1 & b4 is strict Element of GroupObjects b1 & b5 is Element of the Vertices of GroupCat b1;

:: GRCAT_1:th 48
theorem
for b1 being non empty universal set
for b2 being Element of the Vertices of GroupCat b1
for b3 being Element of GroupObjects b1
      st b2 = b3
   holds id b2 = ID b3;

:: GRCAT_1:th 49
theorem
for b1 being non empty universal set
for b2 being Element of the Edges of GroupCat b1
for b3 being Element of Morphs GroupObjects b1
      st b2 = b3
   holds dom b2 = dom b3 & cod b2 = cod b3;

:: GRCAT_1:th 50
theorem
for b1 being non empty universal set
for b2, b3 being Element of the Edges of GroupCat b1
for b4, b5 being Element of Morphs GroupObjects b1
      st b2 = b4 & b3 = b5
   holds (dom b3 = cod b2 implies dom b5 = cod b4) &
    (dom b5 = cod b4 implies dom b3 = cod b2) &
    (dom b3 = cod b2 implies [b5,b4] in proj1 comp GroupObjects b1) &
    ([b5,b4] in proj1 comp GroupObjects b1 implies dom b3 = cod b2) &
    (dom b3 = cod b2 implies b3 * b2 = b5 * b4) &
    (dom b2 = dom b3 implies dom b4 = dom b5) &
    (dom b4 = dom b5 implies dom b2 = dom b3) &
    (cod b2 = cod b3 implies cod b4 = cod b5) &
    (cod b4 = cod b5 implies cod b2 = cod b3);

:: GRCAT_1:funcreg 11
registration
  let a1 be non empty universal set;
  cluster GroupCat a1 -> Category-like;
end;

:: GRCAT_1:funcnot 28 => GRCAT_1:func 28
definition
  let a1 be non empty universal set;
  func AbGroupObjects A1 -> Element of bool the Vertices of GroupCat a1 equals
    {b1 where b1 is Element of the Vertices of GroupCat a1: ex b2 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr st
       b1 = b2};
end;

:: GRCAT_1:def 37
theorem
for b1 being non empty universal set holds
   AbGroupObjects b1 = {b2 where b2 is Element of the Vertices of GroupCat b1: ex b3 being non empty right_complementable Abelian add-associative right_zeroed addLoopStr st
      b2 = b3};

:: GRCAT_1:th 51
theorem
for b1 being non empty universal set holds
   Trivial-addLoopStr in AbGroupObjects b1;

:: GRCAT_1:funcreg 12
registration
  let a1 be non empty universal set;
  cluster AbGroupObjects a1 -> non empty;
end;

:: GRCAT_1:funcnot 29 => GRCAT_1:func 29
definition
  let a1 be non empty universal set;
  func AbGroupCat A1 -> Subcategory of GroupCat a1 equals
    cat AbGroupObjects a1;
end;

:: GRCAT_1:def 38
theorem
for b1 being non empty universal set holds
   AbGroupCat b1 = cat AbGroupObjects b1;

:: GRCAT_1:funcreg 13
registration
  let a1 be non empty universal set;
  cluster AbGroupCat a1 -> strict;
end;

:: GRCAT_1:th 52
theorem
for b1 being non empty universal set holds
   the Vertices of AbGroupCat b1 = AbGroupObjects b1;

:: GRCAT_1:funcnot 30 => GRCAT_1:func 30
definition
  let a1 be non empty universal set;
  func MidOpGroupObjects A1 -> Element of bool the Vertices of AbGroupCat a1 equals
    {b1 where b1 is Element of the Vertices of AbGroupCat a1: ex b2 being non empty right_complementable Abelian add-associative right_zeroed midpoint_operator addLoopStr st
       b1 = b2};
end;

:: GRCAT_1:def 39
theorem
for b1 being non empty universal set holds
   MidOpGroupObjects b1 = {b2 where b2 is Element of the Vertices of AbGroupCat b1: ex b3 being non empty right_complementable Abelian add-associative right_zeroed midpoint_operator addLoopStr st
      b2 = b3};

:: GRCAT_1:funcreg 14
registration
  let a1 be non empty universal set;
  cluster MidOpGroupObjects a1 -> non empty;
end;

:: GRCAT_1:funcnot 31 => GRCAT_1:func 31
definition
  let a1 be non empty universal set;
  func MidOpGroupCat A1 -> Subcategory of AbGroupCat a1 equals
    cat MidOpGroupObjects a1;
end;

:: GRCAT_1:def 40
theorem
for b1 being non empty universal set holds
   MidOpGroupCat b1 = cat MidOpGroupObjects b1;

:: GRCAT_1:funcreg 15
registration
  let a1 be non empty universal set;
  cluster MidOpGroupCat a1 -> strict;
end;

:: GRCAT_1:th 53
theorem
for b1 being non empty universal set holds
   the Vertices of MidOpGroupCat b1 = MidOpGroupObjects b1;

:: GRCAT_1:th 54
theorem
for b1 being non empty universal set holds
   Trivial-addLoopStr in MidOpGroupObjects b1;

:: GRCAT_1:th 56
theorem
for b1, b2 being non empty 1-sorted
for b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2
      st b3 is one-to-one & b3 is onto(the carrier of b1, the carrier of b2)
   holds b3 * (b3 /") = id b2 & b3 /" * b3 = id b1 & b3 /" is one-to-one & b3 /" is onto(the carrier of b2, the carrier of b1);