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);