:: GRCAT_1 semantic presentation

theorem Th1: :: GRCAT_1:1
canceled;

theorem Th2: :: GRCAT_1:2
for X, Y, A, z being set st z in A & A c= [:X,Y:] holds
ex x being Element of X ex y being Element of Y st z = [x,y]
proof end;

theorem Th3: :: GRCAT_1:3
for UN being Universe
for u1, u2, u3, u4 being Element of UN holds
( [u1,u2,u3] is Element of UN & [u1,u2,u3,u4] is Element of UN )
proof end;

theorem Th4: :: GRCAT_1:4
for UN being Universe
for x, y being set st x in y & y in UN holds
x in UN
proof end;

scheme :: GRCAT_1:sch 36
s36{ F1() -> set , F2() -> set , F3() -> set , F4( set , set ) -> set , P1[ set , set ] } :
ex f being PartFunc of [:F1(),F2():],F3() st
( ( for x, y being set holds
( [x,y] in dom f iff ( x in F1() & y in F2() & P1[x,y] ) ) ) & ( for x, y being set st [x,y] in dom f holds
f . [x,y] = F4(x,y) ) )
provided
E29: for x, y being set st x in F1() & y in F2() & P1[x,y] holds
F4(x,y) in F3()
proof end;

scheme :: GRCAT_1:sch 45
s45{ F1() -> non empty set , F2() -> non empty set , F3() -> set , F4( set , set ) -> set , P1[ set , set ] } :
ex f being PartFunc of [:F1(),F2():],F3() st
( ( for x being Element of F1()
for y being Element of F2() holds
( [x,y] in dom f iff P1[x,y] ) ) & ( for x being Element of F1()
for y being Element of F2() st [x,y] in dom f holds
f . [x,y] = F4(x,y) ) )
provided
E29: for x being Element of F1()
for y being Element of F2() st P1[x,y] holds
F4(x,y) in F3()
proof end;

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

theorem Th6: :: GRCAT_1:6
for UN being Universe holds
( {{} } in UN & [{{} },{{} }] in UN & [:{{} },{{} }:] in UN & op2 in UN & op1 in UN )
proof end;

theorem Th7: :: GRCAT_1:7
LoopStr(# {{} },op2 ,(Extract {} ) #) is midpoint_operator
proof end;

registration
cluster L_Trivial -> midpoint_operator ;
coherence
L_Trivial is midpoint_operator
by , ALGSTR_1:def 4;
end;

theorem Th8: :: GRCAT_1:8
( ( for x being Element of L_Trivial holds x = {} ) & ( for x, y being Element of L_Trivial holds x + y = {} ) & ( for x being Element of L_Trivial holds - x = {} ) & 0. L_Trivial = {} ) by ALGSTR_1:def 4, TARSKI:def 1;

definition
let C be Category;
let O be non empty Subset of the Objects of C;
canceled;
canceled;
canceled;
canceled;
func Morphs c2 -> Subset of the Morphisms of a1 equals :: GRCAT_1:def 5
union { (Hom a,b) where a is Object of C, b is Object of C : ( a in O & b in O ) } ;
coherence
union { (Hom a,b) where a is Object of C, b is Object of C : ( a in O & b in O ) } is Subset of the Morphisms of C
by CAT_2:28;
end;

:: deftheorem Def1 GRCAT_1:def 1 :
canceled;

:: deftheorem Def2 GRCAT_1:def 2 :
canceled;

:: deftheorem Def3 GRCAT_1:def 3 :
canceled;

:: deftheorem Def4 GRCAT_1:def 4 :
canceled;

:: deftheorem Def5 defines Morphs GRCAT_1:def 5 :
for C being Category
for O being non empty Subset of the Objects of C holds Morphs O = union { (Hom a,b) where a is Object of C, b is Object of C : ( a in O & b in O ) } ;

registration
let C be Category;
let O be non empty Subset of the Objects of C;
cluster Morphs a2 -> non empty ;
coherence
not Morphs O is empty
by CAT_2:28;
end;

definition
let C be Category;
let O be non empty Subset of the Objects of C;
func dom c2 -> Function of Morphs a2,a2 equals :: GRCAT_1:def 6
the Dom of C | (Morphs O);
coherence
the Dom of C | (Morphs O) is Function of Morphs O,O
by CAT_2:29;
func cod c2 -> Function of Morphs a2,a2 equals :: GRCAT_1:def 7
the Cod of C | (Morphs O);
coherence
the Cod of C | (Morphs O) is Function of Morphs O,O
by CAT_2:29;
func comp c2 -> PartFunc of [:(Morphs a2),(Morphs a2):], Morphs a2 equals :: GRCAT_1:def 8
the Comp of C || (Morphs O);
coherence
the Comp of C || (Morphs O) is PartFunc of [:(Morphs O),(Morphs O):], Morphs O
by CAT_2:29;
func ID c2 -> Function of a2, Morphs a2 equals :: GRCAT_1:def 9
the Id of C | O;
coherence
the Id of C | O is Function of O, Morphs O
by CAT_2:29;
end;

:: deftheorem Def6 defines dom GRCAT_1:def 6 :
for C being Category
for O being non empty Subset of the Objects of C holds dom O = the Dom of C | (Morphs O);

:: deftheorem Def7 defines cod GRCAT_1:def 7 :
for C being Category
for O being non empty Subset of the Objects of C holds cod O = the Cod of C | (Morphs O);

:: deftheorem Def8 defines comp GRCAT_1:def 8 :
for C being Category
for O being non empty Subset of the Objects of C holds comp O = the Comp of C || (Morphs O);

:: deftheorem Def9 defines ID GRCAT_1:def 9 :
for C being Category
for O being non empty Subset of the Objects of C holds ID O = the Id of C | O;

theorem Th9: :: GRCAT_1:9
for C being Category
for O being non empty Subset of the Objects of C holds CatStr(# O,(Morphs O),(dom O),(cod O),(comp O),(ID O) #) is_full_subcategory_of C by CAT_2:30;

definition
let C be Category;
let O be non empty Subset of the Objects of C;
func cat c2 -> Subcategory of a1 equals :: GRCAT_1:def 10
CatStr(# O,(Morphs O),(dom O),(cod O),(comp O),(ID O) #);
coherence
CatStr(# O,(Morphs O),(dom O),(cod O),(comp O),(ID O) #) is Subcategory of C
proof end;
end;

:: deftheorem Def10 defines cat GRCAT_1:def 10 :
for C being Category
for O being non empty Subset of the Objects of C holds cat O = CatStr(# O,(Morphs O),(dom O),(cod O),(comp O),(ID O) #);

registration
let C be Category;
let O be non empty Subset of the Objects of C;
cluster cat a2 -> strict ;
coherence
cat O is strict
;
end;

theorem Th10: :: GRCAT_1:10
for C being Category
for O being non empty Subset of the Objects of C holds the Objects of (cat O) = O ;

definition
let G be 1-sorted ;
func id c1 -> Function of a1,a1 equals :: GRCAT_1:def 11
id the carrier of G;
coherence
id the carrier of G is Function of G,G
;
end;

:: deftheorem Def11 defines id GRCAT_1:def 11 :
for G being 1-sorted holds id G = id the carrier of G;

registration
let G be 1-sorted ;
cluster id a1 -> one-to-one ;
coherence
id G is one-to-one
;
end;

theorem Th11: :: GRCAT_1:11
for G being non empty 1-sorted
for x being Element of G holds (id G) . x = x by FUNCT_1:35;

theorem Th12: :: GRCAT_1:12
for G being 1-sorted
for H being non empty 1-sorted
for f being Function of G,H holds
( f * (id G) = f & (id H) * f = f )
proof end;

definition
let G be non empty ZeroStr , H be non empty ZeroStr ;
func ZeroMap c1,c2 -> Function of a1,a2 equals :: GRCAT_1:def 12
the carrier of G --> (0. H);
coherence
the carrier of G --> (0. H) is Function of G,H
proof end;
end;

:: deftheorem Def12 defines ZeroMap GRCAT_1:def 12 :
for G, H being non empty ZeroStr holds ZeroMap G,H = the carrier of G --> (0. H);

definition
let G be non empty LoopStr , H be non empty LoopStr ;
let f be Function of G,H;
attr a3 is additive means :Def13: :: GRCAT_1:def 13
for x, y being Element of G holds f . (x + y) = (f . x) + (f . y);
end;

:: deftheorem Def13 defines additive GRCAT_1:def 13 :
for G, H being non empty LoopStr
for f being Function of G,H holds
( f is additive iff for x, y being Element of G holds f . (x + y) = (f . x) + (f . y) );

theorem Th13: :: GRCAT_1:13
comp L_Trivial = op1
proof end;

theorem Th14: :: GRCAT_1:14
for G1, G2, G3 being non empty LoopStr
for f being Function of G1,G2
for g being Function of G2,G3 st f is additive & g is additive holds
g * f is additive
proof end;

theorem Th15: :: GRCAT_1:15
for G being non empty ZeroStr
for H being non empty LoopStr
for x being Element of G holds (ZeroMap G,H) . x = 0. H by FUNCOP_1:13;

theorem Th16: :: GRCAT_1:16
for G being non empty LoopStr
for H being non empty right_zeroed LoopStr holds ZeroMap G,H is additive
proof end;

definition
attr a1 is strict;
struct GroupMorphismStr -> ;
aggr GroupMorphismStr(# Dom, Cod, Fun #) -> GroupMorphismStr ;
sel Dom c1 -> AddGroup;
sel Cod c1 -> AddGroup;
sel Fun c1 -> Function of the Dom of a1,the Cod of a1;
end;

definition
let f be GroupMorphismStr ;
func dom c1 -> AddGroup equals :: GRCAT_1:def 14
the Dom of f;
coherence
the Dom of f is AddGroup
;
func cod c1 -> AddGroup equals :: GRCAT_1:def 15
the Cod of f;
coherence
the Cod of f is AddGroup
;
end;

:: deftheorem Def14 defines dom GRCAT_1:def 14 :
for f being GroupMorphismStr holds dom f = the Dom of f;

:: deftheorem Def15 defines cod GRCAT_1:def 15 :
for f being GroupMorphismStr holds cod f = the Cod of f;

definition
let f be GroupMorphismStr ;
func fun c1 -> Function of (dom a1),(cod a1) equals :: GRCAT_1:def 16
the Fun of f;
coherence
the Fun of f is Function of (dom f),(cod f)
;
end;

:: deftheorem Def16 defines fun GRCAT_1:def 16 :
for f being GroupMorphismStr holds fun f = the Fun of f;

theorem Th17: :: GRCAT_1:17
for f being GroupMorphismStr
for G1, G2 being AddGroup
for f0 being Function of G1,G2 st f = GroupMorphismStr(# G1,G2,f0 #) holds
( dom f = G1 & cod f = G2 & fun f = f0 ) ;

definition
let G be AddGroup;
let H be AddGroup;
func ZERO c1,c2 -> GroupMorphismStr equals :: GRCAT_1:def 17
GroupMorphismStr(# G,H,(ZeroMap G,H) #);
coherence
GroupMorphismStr(# G,H,(ZeroMap G,H) #) is GroupMorphismStr
;
end;

:: deftheorem Def17 defines ZERO GRCAT_1:def 17 :
for G, H being AddGroup holds ZERO G,H = GroupMorphismStr(# G,H,(ZeroMap G,H) #);

registration
let G be AddGroup;
let H be AddGroup;
cluster ZERO a1,a2 -> strict ;
coherence
ZERO G,H is strict
;
end;

definition
let IT be GroupMorphismStr ;
attr a1 is GroupMorphism-like means :Def18: :: GRCAT_1:def 18
fun IT is additive;
end;

:: deftheorem Def18 defines GroupMorphism-like GRCAT_1:def 18 :
for IT being GroupMorphismStr holds
( IT is GroupMorphism-like iff fun IT is additive );

registration
cluster strict GroupMorphism-like GroupMorphismStr ;
existence
ex b1 being GroupMorphismStr st
( b1 is strict & b1 is GroupMorphism-like )
proof end;
end;

definition
mode GroupMorphism is GroupMorphism-like GroupMorphismStr ;
end;

theorem Th18: :: GRCAT_1:18
for F being GroupMorphism holds the Fun of F is additive
proof end;

registration
let G be AddGroup;
let H be AddGroup;
cluster ZERO a1,a2 -> strict GroupMorphism-like ;
coherence
ZERO G,H is GroupMorphism-like
proof end;
end;

definition
let G be AddGroup;
let H be AddGroup;
mode Morphism of c1,c2 -> GroupMorphism means :Def19: :: GRCAT_1:def 19
( dom it = G & cod it = H );
existence
ex b1 being GroupMorphism st
( dom b1 = G & cod b1 = H )
proof end;
end;

:: deftheorem Def19 defines Morphism GRCAT_1:def 19 :
for G, H being AddGroup
for b3 being GroupMorphism holds
( b3 is Morphism of G,H iff ( dom b3 = G & cod b3 = H ) );

registration
let G be AddGroup;
let H be AddGroup;
cluster strict Morphism of a1,a2;
existence
ex b1 being Morphism of G,H st b1 is strict
proof end;
end;

theorem Th19: :: GRCAT_1:19
for G, H being AddGroup
for f being strict GroupMorphismStr st dom f = G & cod f = H & fun f is additive holds
f is strict Morphism of G,H
proof end;

theorem Th20: :: GRCAT_1:20
for G, H being AddGroup
for f being Function of G,H st f is additive holds
GroupMorphismStr(# G,H,f #) is strict Morphism of G,H
proof end;

theorem Th21: :: GRCAT_1:21
for G being non empty LoopStr holds id G is additive
proof end;

definition
let G be AddGroup;
func ID c1 -> Morphism of a1,a1 equals :: GRCAT_1:def 20
GroupMorphismStr(# G,G,(id G) #);
coherence
GroupMorphismStr(# G,G,(id G) #) is Morphism of G,G
proof end;
end;

:: deftheorem Def20 defines ID GRCAT_1:def 20 :
for G being AddGroup holds ID G = GroupMorphismStr(# G,G,(id G) #);

registration
let G be AddGroup;
cluster ID a1 -> strict ;
coherence
ID G is strict
;
end;

definition
let G be AddGroup;
let H be AddGroup;
redefine func ZERO as ZERO c1,c2 -> strict Morphism of a1,a2;
coherence
ZERO G,H is strict Morphism of G,H
proof end;
end;

theorem Th22: :: GRCAT_1:22
for G, H being AddGroup
for F being Morphism of G,H ex f being Function of G,H st
( GroupMorphismStr(# the Dom of F,the Cod of F,the Fun of F #) = GroupMorphismStr(# G,H,f #) & f is additive )
proof end;

theorem Th23: :: GRCAT_1:23
for G, H being AddGroup
for F being strict Morphism of G,H ex f being Function of G,H st F = GroupMorphismStr(# G,H,f #)
proof end;

theorem Th24: :: GRCAT_1:24
for F being GroupMorphism ex G, H being AddGroup st F is Morphism of G,H
proof end;

theorem Th25: :: GRCAT_1:25
for F being strict GroupMorphism ex G, H being AddGroup ex f being Function of G,H st
( F is Morphism of G,H & F = GroupMorphismStr(# G,H,f #) & f is additive )
proof end;

theorem Th26: :: GRCAT_1:26
for g, f being GroupMorphism st dom g = cod f holds
ex G1, G2, G3 being AddGroup st
( g is Morphism of G2,G3 & f is Morphism of G1,G2 )
proof end;

definition
let G be GroupMorphism, F be GroupMorphism;
assume E29: dom G = cod F ;
func c1 * c2 -> strict GroupMorphism means :Def21: :: GRCAT_1:def 21
for G1, G2, G3 being AddGroup
for g being Function of G2,G3
for f being Function of G1,G2 st GroupMorphismStr(# the Dom of G,the Cod of G,the Fun of G #) = GroupMorphismStr(# G2,G3,g #) & GroupMorphismStr(# the Dom of F,the Cod of F,the Fun of F #) = GroupMorphismStr(# G1,G2,f #) holds
it = GroupMorphismStr(# G1,G3,(g * f) #);
existence
ex b1 being strict GroupMorphism st
for G1, G2, G3 being AddGroup
for g being Function of G2,G3
for f being Function of G1,G2 st GroupMorphismStr(# the Dom of G,the Cod of G,the Fun of G #) = GroupMorphismStr(# G2,G3,g #) & GroupMorphismStr(# the Dom of F,the Cod of F,the Fun of F #) = GroupMorphismStr(# G1,G2,f #) holds
b1 = GroupMorphismStr(# G1,G3,(g * f) #)
proof end;
uniqueness
for b1, b2 being strict GroupMorphism st ( for G1, G2, G3 being AddGroup
for g being Function of G2,G3
for f being Function of G1,G2 st GroupMorphismStr(# the Dom of G,the Cod of G,the Fun of G #) = GroupMorphismStr(# G2,G3,g #) & GroupMorphismStr(# the Dom of F,the Cod of F,the Fun of F #) = GroupMorphismStr(# G1,G2,f #) holds
b1 = GroupMorphismStr(# G1,G3,(g * f) #) ) & ( for G1, G2, G3 being AddGroup
for g being Function of G2,G3
for f being Function of G1,G2 st GroupMorphismStr(# the Dom of G,the Cod of G,the Fun of G #) = GroupMorphismStr(# G2,G3,g #) & GroupMorphismStr(# the Dom of F,the Cod of F,the Fun of F #) = GroupMorphismStr(# G1,G2,f #) holds
b2 = GroupMorphismStr(# G1,G3,(g * f) #) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def21 defines * GRCAT_1:def 21 :
for G, F being GroupMorphism st dom G = cod F holds
for b3 being strict GroupMorphism holds
( b3 = G * F iff for G1, G2, G3 being AddGroup
for g being Function of G2,G3
for f being Function of G1,G2 st GroupMorphismStr(# the Dom of G,the Cod of G,the Fun of G #) = GroupMorphismStr(# G2,G3,g #) & GroupMorphismStr(# the Dom of F,the Cod of F,the Fun of F #) = GroupMorphismStr(# G1,G2,f #) holds
b3 = GroupMorphismStr(# G1,G3,(g * f) #) );

theorem Th27: :: GRCAT_1:27
canceled;

theorem Th28: :: GRCAT_1:28
for G1, G2, G3 being AddGroup
for G being Morphism of G2,G3
for F being Morphism of G1,G2 holds G * F is Morphism of G1,G3
proof end;

definition
let G1 be AddGroup, G2 be AddGroup, G3 be AddGroup;
let G be Morphism of G2,G3;
let F be Morphism of G1,G2;
redefine func * as c4 * c5 -> strict Morphism of a1,a3;
coherence
G * F is strict Morphism of G1,G3
by ;
end;

theorem Th29: :: GRCAT_1:29
for G1, G2, G3 being AddGroup
for G being Morphism of G2,G3
for F being Morphism of G1,G2
for g being Function of G2,G3
for f being Function of G1,G2 st G = GroupMorphismStr(# G2,G3,g #) & F = GroupMorphismStr(# G1,G2,f #) holds
G * F = GroupMorphismStr(# G1,G3,(g * f) #)
proof end;

theorem Th30: :: GRCAT_1:30
for f, g being strict GroupMorphism st dom g = cod f holds
ex G1, G2, G3 being AddGroup ex f0 being Function of G1,G2 ex g0 being Function of G2,G3 st
( f = GroupMorphismStr(# G1,G2,f0 #) & g = GroupMorphismStr(# G2,G3,g0 #) & g * f = GroupMorphismStr(# G1,G3,(g0 * f0) #) )
proof end;

theorem Th31: :: GRCAT_1:31
for f, g being strict GroupMorphism st dom g = cod f holds
( dom (g * f) = dom f & cod (g * f) = cod g )
proof end;

theorem Th32: :: GRCAT_1:32
for G1, G2, G3, G4 being AddGroup
for f being strict Morphism of G1,G2
for g being strict Morphism of G2,G3
for h being strict Morphism of G3,G4 holds h * (g * f) = (h * g) * f
proof end;

theorem Th33: :: GRCAT_1:33
for f, g, h being strict GroupMorphism st dom h = cod g & dom g = cod f holds
h * (g * f) = (h * g) * f
proof end;

theorem Th34: :: GRCAT_1:34
for G being AddGroup holds
( dom (ID G) = G & cod (ID G) = G & ( for f being strict GroupMorphism st cod f = G holds
(ID G) * f = f ) & ( for g being strict GroupMorphism st dom g = G holds
g * (ID G) = g ) )
proof end;

definition
let IT be set ;
attr a1 is Group_DOMAIN-like means :Def22: :: GRCAT_1:def 22
for x being set st x in IT holds
x is strict AddGroup;
end;

:: deftheorem Def22 defines Group_DOMAIN-like GRCAT_1:def 22 :
for IT being set holds
( IT is Group_DOMAIN-like iff for x being set st x in IT holds
x is strict AddGroup );

registration
cluster non empty Group_DOMAIN-like set ;
existence
ex b1 being set st
( b1 is Group_DOMAIN-like & not b1 is empty )
proof end;
end;

definition
mode Group_DOMAIN is non empty Group_DOMAIN-like set ;
end;

definition
let V be Group_DOMAIN;
redefine mode Element as Element of c1 -> AddGroup;
coherence
for b1 being Element of V holds b1 is AddGroup
by ;
end;

registration
let V be Group_DOMAIN;
cluster strict Element of a1;
existence
ex b1 being Element of V st b1 is strict
proof end;
end;

definition
let IT be set ;
attr a1 is GroupMorphism_DOMAIN-like means :Def23: :: GRCAT_1:def 23
for x being set st x in IT holds
x is strict GroupMorphism;
end;

:: deftheorem Def23 defines GroupMorphism_DOMAIN-like GRCAT_1:def 23 :
for IT being set holds
( IT is GroupMorphism_DOMAIN-like iff for x being set st x in IT holds
x is strict GroupMorphism );

registration
cluster non empty GroupMorphism_DOMAIN-like set ;
existence
ex b1 being set st
( b1 is GroupMorphism_DOMAIN-like & not b1 is empty )
proof end;
end;

definition
mode GroupMorphism_DOMAIN is non empty GroupMorphism_DOMAIN-like set ;
end;

definition
let M be GroupMorphism_DOMAIN;
redefine mode Element as Element of c1 -> GroupMorphism;
coherence
for b1 being Element of M holds b1 is GroupMorphism
by ;
end;

registration
let M be GroupMorphism_DOMAIN;
cluster strict Element of a1;
existence
ex b1 being Element of M st b1 is strict
proof end;
end;

theorem Th35: :: GRCAT_1:35
canceled;

theorem Th36: :: GRCAT_1:36
canceled;

theorem Th37: :: GRCAT_1:37
for f being strict GroupMorphism holds {f} is GroupMorphism_DOMAIN
proof end;

definition
let G be AddGroup;
let H be AddGroup;
mode GroupMorphism_DOMAIN of c1,c2 -> GroupMorphism_DOMAIN means :Def24: :: GRCAT_1:def 24
for x being Element of it holds x is strict Morphism of G,H;
existence
ex b1 being GroupMorphism_DOMAIN st
for x being Element of b1 holds x is strict Morphism of G,H
proof end;
end;

:: deftheorem Def24 defines GroupMorphism_DOMAIN GRCAT_1:def 24 :
for G, H being AddGroup
for b3 being GroupMorphism_DOMAIN holds
( b3 is GroupMorphism_DOMAIN of G,H iff for x being Element of b3 holds x is strict Morphism of G,H );

theorem Th38: :: GRCAT_1:38
for D being non empty set
for G, H being AddGroup holds
( D is GroupMorphism_DOMAIN of G,H iff for x being Element of D holds x is strict Morphism of G,H )
proof end;

theorem Th39: :: GRCAT_1:39
for G, H being AddGroup
for f being strict Morphism of G,H holds {f} is GroupMorphism_DOMAIN of G,H
proof end;

definition
let G be 1-sorted , H be 1-sorted ;
mode MapsSet of c1,c2 -> set means :Def25: :: GRCAT_1:def 25
for x being set st x in it holds
x is Function of G,H;
existence
ex b1 being set st
for x being set st x in b1 holds
x is Function of G,H
proof end;
end;

:: deftheorem Def25 defines MapsSet GRCAT_1:def 25 :
for G, H being 1-sorted
for b3 being set holds
( b3 is MapsSet of G,H iff for x being set st x in b3 holds
x is Function of G,H );

definition
let G be 1-sorted , H be 1-sorted ;
func Maps c1,c2 -> MapsSet of a1,a2 equals :: GRCAT_1:def 26
Funcs the carrier of G,the carrier of H;
coherence
Funcs the carrier of G,the carrier of H is MapsSet of G,H
proof end;
end;

:: deftheorem Def26 defines Maps GRCAT_1:def 26 :
for G, H being 1-sorted holds Maps G,H = Funcs the carrier of G,the carrier of H;

registration
let G be 1-sorted ;
let H be non empty 1-sorted ;
cluster Maps a1,a2 -> non empty ;
coherence
not Maps G,H is empty
;
end;

registration
let G be 1-sorted ;
let H be non empty 1-sorted ;
cluster non empty MapsSet of a1,a2;
existence
not for b1 being MapsSet of G,H holds b1 is empty
proof end;
end;

definition
let G be 1-sorted ;
let H be non empty 1-sorted ;
let M be non empty MapsSet of G,H;
redefine mode Element as Element of c3 -> Function of a1,a2;
coherence
for b1 being Element of M holds b1 is Function of G,H
by ;
end;

definition
let G be AddGroup;
let H be AddGroup;
func Morphs c1,c2 -> GroupMorphism_DOMAIN of a1,a2 means :Def27: :: GRCAT_1:def 27
for x being set holds
( x in it iff x is strict Morphism of G,H );
existence
ex b1 being GroupMorphism_DOMAIN of G,H st
for x being set holds
( x in b1 iff x is strict Morphism of G,H )
proof end;
uniqueness
for b1, b2 being GroupMorphism_DOMAIN of G,H st ( for x being set holds
( x in b1 iff x is strict Morphism of G,H ) ) & ( for x being set holds
( x in b2 iff x is strict Morphism of G,H ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def27 defines Morphs GRCAT_1:def 27 :
for G, H being AddGroup
for b3 being GroupMorphism_DOMAIN of G,H holds
( b3 = Morphs G,H iff for x being set holds
( x in b3 iff x is strict Morphism of G,H ) );

definition
let G be AddGroup;
let H be AddGroup;
let M be GroupMorphism_DOMAIN of G,H;
redefine mode Element as Element of c3 -> Morphism of a1,a2;
coherence
for b1 being Element of M holds b1 is Morphism of G,H
by ;
end;

registration
let G be AddGroup;
let H be AddGroup;
let M be GroupMorphism_DOMAIN of G,H;
cluster strict Element of a3;
existence
ex b1 being Element of M st b1 is strict
proof end;
end;

definition
let x be set ;
let y be set ;
pred GO c1,c2 means :Def28: :: GRCAT_1:def 28
ex x1, x2, x3, x4 being set st
( x = [x1,x2,x3,x4] & ex G being strict AddGroup st
( y = G & x1 = the carrier of G & x2 = the add of G & x3 = comp G & x4 = the Zero of G ) );
end;

:: deftheorem Def28 defines GO GRCAT_1:def 28 :
for x, y being set holds
( GO x,y iff ex x1, x2, x3, x4 being set st
( x = [x1,x2,x3,x4] & ex G being strict AddGroup st
( y = G & x1 = the carrier of G & x2 = the add of G & x3 = comp G & x4 = the Zero of G ) ) );

theorem Th40: :: GRCAT_1:40
for x, y1, y2 being set st GO x,y1 & GO x,y2 holds
y1 = y2
proof end;

theorem Th41: :: GRCAT_1:41
for UN being Universe ex x being set st
( x in UN & GO x, L_Trivial )
proof end;

definition
let UN be Universe;
func GroupObjects c1 -> set means :Def29: :: GRCAT_1:def 29
for y being set holds
( y in it iff ex x being set st
( x in UN & GO x,y ) );
existence
ex b1 being set st
for y being set holds
( y in b1 iff ex x being set st
( x in UN & GO x,y ) )
proof end;
uniqueness
for b1, b2 being set st ( for y being set holds
( y in b1 iff ex x being set st
( x in UN & GO x,y ) ) ) & ( for y being set holds
( y in b2 iff ex x being set st
( x in UN & GO x,y ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def29 defines GroupObjects GRCAT_1:def 29 :
for UN being Universe
for b2 being set holds
( b2 = GroupObjects UN iff for y being set holds
( y in b2 iff ex x being set st
( x in UN & GO x,y ) ) );

theorem Th42: :: GRCAT_1:42
for UN being Universe holds L_Trivial in GroupObjects UN
proof end;

registration
let UN be Universe;
cluster GroupObjects a1 -> non empty ;
coherence
not GroupObjects UN is empty
by ;
end;

theorem Th43: :: GRCAT_1:43
for UN being Universe
for x being Element of GroupObjects UN holds x is strict AddGroup
proof end;

registration
let UN be Universe;
cluster GroupObjects a1 -> non empty Group_DOMAIN-like ;
coherence
GroupObjects UN is Group_DOMAIN-like
proof end;
end;

definition
let V be Group_DOMAIN;
func Morphs c1 -> GroupMorphism_DOMAIN means :Def30: :: GRCAT_1:def 30
for x being set holds
( x in it iff ex G, H being strict Element of V st x is strict Morphism of G,H );
existence
ex b1 being GroupMorphism_DOMAIN st
for x being set holds
( x in b1 iff ex G, H being strict Element of V st x is strict Morphism of G,H )
proof end;
uniqueness
for b1, b2 being GroupMorphism_DOMAIN st ( for x being set holds
( x in b1 iff ex G, H being strict Element of V st x is strict Morphism of G,H ) ) & ( for x being set holds
( x in b2 iff ex G, H being strict Element of V st x is strict Morphism of G,H ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def30 defines Morphs GRCAT_1:def 30 :
for V being Group_DOMAIN
for b2 being GroupMorphism_DOMAIN holds
( b2 = Morphs V iff for x being set holds
( x in b2 iff ex G, H being strict Element of V st x is strict Morphism of G,H ) );

definition
let V be Group_DOMAIN;
let F be Element of Morphs V;
redefine func dom as dom c2 -> strict Element of a1;
coherence
dom F is strict Element of V
proof end;
redefine func cod as cod c2 -> strict Element of a1;
coherence
cod F is strict Element of V
proof end;
end;

definition
let V be Group_DOMAIN;
let G be Element of V;
func ID c2 -> strict Element of Morphs a1 equals :: GRCAT_1:def 31
ID G;
coherence
ID G is strict Element of Morphs V
proof end;
end;

:: deftheorem Def31 defines ID GRCAT_1:def 31 :
for V being Group_DOMAIN
for G being Element of V holds ID G = ID G;

definition
let V be Group_DOMAIN;
func dom c1 -> Function of Morphs a1,a1 means :Def32: :: GRCAT_1:def 32
for f being Element of Morphs V holds it . f = dom f;
existence
ex b1 being Function of Morphs V,V st
for f being Element of Morphs V holds b1 . f = dom f
proof end;
uniqueness
for b1, b2 being Function of Morphs V,V st ( for f being Element of Morphs V holds b1 . f = dom f ) & ( for f being Element of Morphs V holds b2 . f = dom f ) holds
b1 = b2
proof end;
func cod c1 -> Function of Morphs a1,a1 means :Def33: :: GRCAT_1:def 33
for f being Element of Morphs V holds it . f = cod f;
existence
ex b1 being Function of Morphs V,V st
for f being Element of Morphs V holds b1 . f = cod f
proof end;
uniqueness
for b1, b2 being Function of Morphs V,V st ( for f being Element of Morphs V holds b1 . f = cod f ) & ( for f being Element of Morphs V holds b2 . f = cod f ) holds
b1 = b2
proof end;
func ID c1 -> Function of a1, Morphs a1 means :Def34: :: GRCAT_1:def 34
for G being Element of V holds it . G = ID G;
existence
ex b1 being Function of V, Morphs V st
for G being Element of V holds b1 . G = ID G
proof end;
uniqueness
for b1, b2 being Function of V, Morphs V st ( for G being Element of V holds b1 . G = ID G ) & ( for G being Element of V holds b2 . G = ID G ) holds
b1 = b2
proof end;
end;

:: deftheorem Def32 defines dom GRCAT_1:def 32 :
for V being Group_DOMAIN
for b2 being Function of Morphs V,V holds
( b2 = dom V iff for f being Element of Morphs V holds b2 . f = dom f );

:: deftheorem Def33 defines cod GRCAT_1:def 33 :
for V being Group_DOMAIN
for b2 being Function of Morphs V,V holds
( b2 = cod V iff for f being Element of Morphs V holds b2 . f = cod f );

:: deftheorem Def34 defines ID GRCAT_1:def 34 :
for V being Group_DOMAIN
for b2 being Function of V, Morphs V holds
( b2 = ID V iff for G being Element of V holds b2 . G = ID G );

theorem Th44: :: GRCAT_1:44
for V being Group_DOMAIN
for g, f being Element of Morphs V st dom g = cod f holds
ex G1, G2, G3 being strict Element of V st
( g is Morphism of G2,G3 & f is Morphism of G1,G2 )
proof end;

theorem Th45: :: GRCAT_1:45
for V being Group_DOMAIN
for g, f being Element of Morphs V st dom g = cod f holds
g * f in Morphs V
proof end;

definition
let V be Group_DOMAIN;
func comp c1 -> PartFunc of [:(Morphs a1),(Morphs a1):], Morphs a1 means :Def35: :: GRCAT_1:def 35
( ( for g, f being Element of Morphs V holds
( [g,f] in dom it iff dom g = cod f ) ) & ( for g, f being Element of Morphs V st [g,f] in dom it holds
it . [g,f] = g * f ) );
existence
ex b1 being PartFunc of [:(Morphs V),(Morphs V):], Morphs V st
( ( for g, f being Element of Morphs V holds
( [g,f] in dom b1 iff dom g = cod f ) ) & ( for g, f being Element of Morphs V st [g,f] in dom b1 holds
b1 . [g,f] = g * f ) )
proof end;
uniqueness
for b1, b2 being PartFunc of [:(Morphs V),(Morphs V):], Morphs V st ( for g, f being Element of Morphs V holds
( [g,f] in dom b1 iff dom g = cod f ) ) & ( for g, f being Element of Morphs V st [g,f] in dom b1 holds
b1 . [g,f] = g * f ) & ( for g, f being Element of Morphs V holds
( [g,f] in dom b2 iff dom g = cod f ) ) & ( for g, f being Element of Morphs V st [g,f] in dom b2 holds
b2 . [g,f] = g * f ) holds
b1 = b2
proof end;
end;

:: deftheorem Def35 defines comp GRCAT_1:def 35 :
for V being Group_DOMAIN
for b2 being PartFunc of [:(Morphs V),(Morphs V):], Morphs V holds
( b2 = comp V iff ( ( for g, f being Element of Morphs V holds
( [g,f] in dom b2 iff dom g = cod f ) ) & ( for g, f being Element of Morphs V st [g,f] in dom b2 holds
b2 . [g,f] = g * f ) ) );

definition
let UN be Universe;
func GroupCat c1 -> CatStr equals :: GRCAT_1:def 36
CatStr(# (GroupObjects UN),(Morphs (GroupObjects UN)),(dom (GroupObjects UN)),(cod (GroupObjects UN)),(comp (GroupObjects UN)),(ID (GroupObjects UN)) #);
coherence
CatStr(# (GroupObjects UN),(Morphs (GroupObjects UN)),(dom (GroupObjects UN)),(cod (GroupObjects UN)),(comp (GroupObjects UN)),(ID (GroupObjects UN)) #) is CatStr
;
end;

:: deftheorem Def36 defines GroupCat GRCAT_1:def 36 :
for UN being Universe holds GroupCat UN = CatStr(# (GroupObjects UN),(Morphs (GroupObjects UN)),(dom (GroupObjects UN)),(cod (GroupObjects UN)),(comp (GroupObjects UN)),(ID (GroupObjects UN)) #);

registration
let UN be Universe;
cluster GroupCat a1 -> strict ;
coherence
GroupCat UN is strict
;
end;

theorem Th46: :: GRCAT_1:46
for UN being Universe
for f, g being Morphism of (GroupCat UN) holds
( [g,f] in dom the Comp of (GroupCat UN) iff dom g = cod f )
proof end;

theorem Th47: :: GRCAT_1:47
for UN being Universe
for f being Morphism of (GroupCat UN)
for f' being Element of Morphs (GroupObjects UN)
for b being Object of (GroupCat UN)
for b' being Element of GroupObjects UN holds
( f is strict Element of Morphs (GroupObjects UN) & f' is Morphism of (GroupCat UN) & b is strict Element of GroupObjects UN & b' is Object of (GroupCat UN) )
proof end;

theorem Th48: :: GRCAT_1:48
for UN being Universe
for b being Object of (GroupCat UN)
for b' being Element of GroupObjects UN st b = b' holds
id b = ID b'
proof end;

theorem Th49: :: GRCAT_1:49
for UN being Universe
for f being Morphism of (GroupCat UN)
for f' being Element of Morphs (GroupObjects UN) st f = f' holds
( dom f = dom f' & cod f = cod f' )
proof end;

theorem Th50: :: GRCAT_1:50
for UN being Universe
for f, g being Morphism of (GroupCat UN)
for f', g' being Element of Morphs (GroupObjects UN) st f = f' & g = g' holds
( ( dom g = cod f implies dom g' = cod f' ) & ( dom g' = cod f' implies dom g = cod f ) & ( dom g = cod f implies [g',f'] in dom (comp (GroupObjects UN)) ) & ( [g',f'] in dom (comp (GroupObjects UN)) implies dom g = cod f ) & ( dom g = cod f implies g * f = g' * f' ) & ( dom f = dom g implies dom f' = dom g' ) & ( dom f' = dom g' implies dom f = dom g ) & ( cod f = cod g implies cod f' = cod g' ) & ( cod f' = cod g' implies cod f = cod g ) )
proof end;

Lemma175: for UN being Universe
for f, g being Morphism of (GroupCat UN) st dom g = cod f holds
( dom (g * f) = dom f & cod (g * f) = cod g )
proof end;

Lemma177: for UN being Universe
for f, g, h being Morphism of (GroupCat UN) st dom h = cod g & dom g = cod f holds
h * (g * f) = (h * g) * f
proof end;

Lemma179: for UN being Universe
for b being Object of (GroupCat UN) holds
( dom (id b) = b & cod (id b) = b & ( for f being Morphism of (GroupCat UN) st cod f = b holds
(id b) * f = f ) & ( for g being Morphism of (GroupCat UN) st dom g = b holds
g * (id b) = g ) )
proof end;

registration
let UN be Universe;
cluster GroupCat a1 -> strict Category-like ;
coherence
GroupCat UN is Category-like
proof end;
end;

definition
let UN be Universe;
func AbGroupObjects c1 -> Subset of the Objects of (GroupCat a1) equals :: GRCAT_1:def 37
{ G where G is Element of the Objects of (GroupCat UN) : ex H being AbGroup st G = H } ;
coherence
{ G where G is Element of the Objects of (GroupCat UN) : ex H being AbGroup st G = H } is Subset of the Objects of (GroupCat UN)
proof end;
end;

:: deftheorem Def37 defines AbGroupObjects GRCAT_1:def 37 :
for UN being Universe holds AbGroupObjects UN = { G where G is Element of the Objects of (GroupCat UN) : ex H being AbGroup st G = H } ;

theorem Th51: :: GRCAT_1:51
for UN being Universe holds L_Trivial in AbGroupObjects UN
proof end;

registration
let UN be Universe;
cluster AbGroupObjects a1 -> non empty ;
coherence
not AbGroupObjects UN is empty
by Def13;
end;

definition
let UN be Universe;
func AbGroupCat c1 -> Subcategory of GroupCat a1 equals :: GRCAT_1:def 38
cat (AbGroupObjects UN);
coherence
cat (AbGroupObjects UN) is Subcategory of GroupCat UN
;
end;

:: deftheorem Def38 defines AbGroupCat GRCAT_1:def 38 :
for UN being Universe holds AbGroupCat UN = cat (AbGroupObjects UN);

registration
let UN be Universe;
cluster AbGroupCat a1 -> strict ;
coherence
AbGroupCat UN is strict
;
end;

theorem Th52: :: GRCAT_1:52
for UN being Universe holds the Objects of (AbGroupCat UN) = AbGroupObjects UN ;

definition
let UN be Universe;
func MidOpGroupObjects c1 -> Subset of the Objects of (AbGroupCat a1) equals :: GRCAT_1:def 39
{ G where G is Element of the Objects of (AbGroupCat UN) : ex H being midpoint_operator AbGroup st G = H } ;
coherence
{ G where G is Element of the Objects of (AbGroupCat UN) : ex H being midpoint_operator AbGroup st G = H } is Subset of the Objects of (AbGroupCat UN)
proof end;
end;

:: deftheorem Def39 defines MidOpGroupObjects GRCAT_1:def 39 :
for UN being Universe holds MidOpGroupObjects UN = { G where G is Element of the Objects of (AbGroupCat UN) : ex H being midpoint_operator AbGroup st G = H } ;

registration
let UN be Universe;
cluster MidOpGroupObjects a1 -> non empty ;
coherence
not MidOpGroupObjects UN is empty
proof end;
end;

definition
let UN be Universe;
func MidOpGroupCat c1 -> Subcategory of AbGroupCat a1 equals :: GRCAT_1:def 40
cat (MidOpGroupObjects UN);
coherence
cat (MidOpGroupObjects UN) is Subcategory of AbGroupCat UN
;
end;

:: deftheorem Def40 defines MidOpGroupCat GRCAT_1:def 40 :
for UN being Universe holds MidOpGroupCat UN = cat (MidOpGroupObjects UN);

registration
let UN be Universe;
cluster MidOpGroupCat a1 -> strict ;
coherence
MidOpGroupCat UN is strict
;
end;

theorem Th53: :: GRCAT_1:53
for UN being Universe holds the Objects of (MidOpGroupCat UN) = MidOpGroupObjects UN ;

theorem Th54: :: GRCAT_1:54
for UN being Universe holds L_Trivial in MidOpGroupObjects UN
proof end;

theorem Th55: :: GRCAT_1:55
for S, T being non empty 1-sorted
for f being Function of T,S
for g being Function of S,T st f * g = id S holds
rng f = the carrier of S by FUNCT_2:29;

theorem Th56: :: GRCAT_1:56
for S, T being non empty 1-sorted
for f being Function of S,T st f is one-to-one & f is onto holds
( f * (f " ) = id T & (f " ) * f = id S & f " is one-to-one & f " is onto )
proof end;