:: GROUP_7 semantic presentation

theorem Th1: :: GROUP_7:1
for a, b being set st <*a*> = <*b*> holds
a = b
proof end;

theorem Th2: :: GROUP_7:2
for a, b, c, d being set st <*a,b*> = <*c,d*> holds
( a = c & b = d )
proof end;

theorem Th3: :: GROUP_7:3
for a, b, c, d, e, f being set st <*a,b,c*> = <*d,e,f*> holds
( a = d & b = e & c = f )
proof end;

definition
let R be Relation;
attr a1 is HGrStr-yielding means :Def1: :: GROUP_7:def 1
for y being set st y in rng R holds
y is non empty HGrStr ;
end;

:: deftheorem Def1 defines HGrStr-yielding GROUP_7:def 1 :
for R being Relation holds
( R is HGrStr-yielding iff for y being set st y in rng R holds
y is non empty HGrStr );

registration
cluster HGrStr-yielding -> 1-sorted-yielding set ;
coherence
for b1 being Function st b1 is HGrStr-yielding holds
b1 is 1-sorted-yielding
proof end;
end;

registration
let I be set ;
cluster 1-sorted-yielding HGrStr-yielding ManySortedSet of a1;
existence
ex b1 being ManySortedSet of I st b1 is HGrStr-yielding
proof end;
end;

registration
cluster 1-sorted-yielding HGrStr-yielding set ;
existence
ex b1 being Function st b1 is HGrStr-yielding
proof end;
end;

definition
let I be set ;
mode HGrStr-Family of a1 is HGrStr-yielding ManySortedSet of a1;
end;

definition
let I be non empty set ;
let F be HGrStr-Family of I;
let i be Element of I;
redefine func . as c2 . c3 -> non empty HGrStr ;
coherence
F . i is non empty HGrStr
proof end;
end;

registration
let I be set ;
let F be HGrStr-Family of I;
cluster Carrier a2 -> V2 ;
coherence
Carrier F is non-empty
proof end;
end;

E42: now
let I be non empty set ;
let i be Element of I;
let F be HGrStr-yielding ManySortedSet of I;
let f be Element of product (Carrier F);
E29: ex R being 1-sorted st
( R = F . i & (Carrier F) . i = the carrier of R ) by PRALG_1:def 13;
dom (Carrier F) = I by PBOOLE:def 3;
hence f . i in the carrier of (F . i) by , CARD_3:18;
end;

definition
let I be set ;
let F be HGrStr-Family of I;
func product c2 -> strict HGrStr means :Def2: :: GROUP_7:def 2
( the carrier of it = product (Carrier F) & ( for f, g being Element of product (Carrier F)
for i being set st i in I holds
ex Fi being non empty HGrStr ex h being Function st
( Fi = F . i & h = the mult of it . f,g & h . i = the mult of Fi . (f . i),(g . i) ) ) );
existence
ex b1 being strict HGrStr st
( the carrier of b1 = product (Carrier F) & ( for f, g being Element of product (Carrier F)
for i being set st i in I holds
ex Fi being non empty HGrStr ex h being Function st
( Fi = F . i & h = the mult of b1 . f,g & h . i = the mult of Fi . (f . i),(g . i) ) ) )
proof end;
uniqueness
for b1, b2 being strict HGrStr st the carrier of b1 = product (Carrier F) & ( for f, g being Element of product (Carrier F)
for i being set st i in I holds
ex Fi being non empty HGrStr ex h being Function st
( Fi = F . i & h = the mult of b1 . f,g & h . i = the mult of Fi . (f . i),(g . i) ) ) & the carrier of b2 = product (Carrier F) & ( for f, g being Element of product (Carrier F)
for i being set st i in I holds
ex Fi being non empty HGrStr ex h being Function st
( Fi = F . i & h = the mult of b2 . f,g & h . i = the mult of Fi . (f . i),(g . i) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def2 defines product GROUP_7:def 2 :
for I being set
for F being HGrStr-Family of I
for b3 being strict HGrStr holds
( b3 = product F iff ( the carrier of b3 = product (Carrier F) & ( for f, g being Element of product (Carrier F)
for i being set st i in I holds
ex Fi being non empty HGrStr ex h being Function st
( Fi = F . i & h = the mult of b3 . f,g & h . i = the mult of Fi . (f . i),(g . i) ) ) ) );

registration
let I be set ;
let F be HGrStr-Family of I;
cluster product a2 -> non empty strict constituted-Functions ;
coherence
( not product F is empty & product F is constituted-Functions )
proof end;
end;

theorem Th4: :: GROUP_7:4
for I, i being set
for f, g, h being Function
for F being HGrStr-Family of I
for G being non empty HGrStr
for p, q being Element of (product F)
for x, y being Element of G st i in I & G = F . i & f = p & g = q & h = p * q & f . i = x & g . i = y holds
x * y = h . i
proof end;

definition
let I be set ;
let F be HGrStr-Family of I;
attr a2 is Group-like means :Def3: :: GROUP_7:def 3
for i being set st i in I holds
ex Fi being non empty Group-like HGrStr st Fi = F . i;
attr a2 is associative means :Def4: :: GROUP_7:def 4
for i being set st i in I holds
ex Fi being non empty associative HGrStr st Fi = F . i;
attr a2 is commutative means :Def5: :: GROUP_7:def 5
for i being set st i in I holds
ex Fi being non empty commutative HGrStr st Fi = F . i;
end;

:: deftheorem Def3 defines Group-like GROUP_7:def 3 :
for I being set
for F being HGrStr-Family of I holds
( F is Group-like iff for i being set st i in I holds
ex Fi being non empty Group-like HGrStr st Fi = F . i );

:: deftheorem Def4 defines associative GROUP_7:def 4 :
for I being set
for F being HGrStr-Family of I holds
( F is associative iff for i being set st i in I holds
ex Fi being non empty associative HGrStr st Fi = F . i );

:: deftheorem Def5 defines commutative GROUP_7:def 5 :
for I being set
for F being HGrStr-Family of I holds
( F is commutative iff for i being set st i in I holds
ex Fi being non empty commutative HGrStr st Fi = F . i );

definition
let I be non empty set ;
let F be HGrStr-Family of I;
redefine attr a2 is Group-like means :Def6: :: GROUP_7:def 6
for i being Element of I holds F . i is Group-like;
compatibility
( F is Group-like iff for i being Element of I holds F . i is Group-like )
proof end;
redefine attr a2 is associative means :Def7: :: GROUP_7:def 7
for i being Element of I holds F . i is associative;
compatibility
( F is associative iff for i being Element of I holds F . i is associative )
proof end;
redefine attr a2 is commutative means :: GROUP_7:def 8
for i being Element of I holds F . i is commutative;
compatibility
( F is commutative iff for i being Element of I holds F . i is commutative )
proof end;
end;

:: deftheorem Def6 defines Group-like GROUP_7:def 6 :
for I being non empty set
for F being HGrStr-Family of I holds
( F is Group-like iff for i being Element of I holds F . i is Group-like );

:: deftheorem Def7 defines associative GROUP_7:def 7 :
for I being non empty set
for F being HGrStr-Family of I holds
( F is associative iff for i being Element of I holds F . i is associative );

:: deftheorem Def8 defines commutative GROUP_7:def 8 :
for I being non empty set
for F being HGrStr-Family of I holds
( F is commutative iff for i being Element of I holds F . i is commutative );

registration
let I be set ;
cluster Group-like associative commutative ManySortedSet of a1;
existence
ex b1 being HGrStr-Family of I st
( b1 is Group-like & b1 is associative & b1 is commutative )
proof end;
end;

registration
let I be set ;
let F be Group-like HGrStr-Family of I;
cluster product a2 -> non empty strict Group-like constituted-Functions ;
coherence
product F is Group-like
proof end;
end;

registration
let I be set ;
let F be associative HGrStr-Family of I;
cluster product a2 -> non empty strict associative constituted-Functions ;
coherence
product F is associative
proof end;
end;

registration
let I be set ;
let F be commutative HGrStr-Family of I;
cluster product a2 -> non empty strict commutative constituted-Functions ;
coherence
product F is commutative
proof end;
end;

theorem Th5: :: GROUP_7:5
for I, i being set
for F being HGrStr-Family of I
for G being non empty HGrStr st i in I & G = F . i & product F is Group-like holds
G is Group-like
proof end;

theorem Th6: :: GROUP_7:6
for I, i being set
for F being HGrStr-Family of I
for G being non empty HGrStr st i in I & G = F . i & product F is associative holds
G is associative
proof end;

theorem Th7: :: GROUP_7:7
for I, i being set
for F being HGrStr-Family of I
for G being non empty HGrStr st i in I & G = F . i & product F is commutative holds
G is commutative
proof end;

theorem Th8: :: GROUP_7:8
for I being set
for s being ManySortedSet of I
for F being Group-like HGrStr-Family of I st ( for i being set st i in I holds
ex G being non empty Group-like HGrStr st
( G = F . i & s . i = 1. G ) ) holds
s = 1. (product F)
proof end;

theorem Th9: :: GROUP_7:9
for I, i being set
for f being Function
for F being Group-like HGrStr-Family of I
for G being non empty Group-like HGrStr st i in I & G = F . i & f = 1. (product F) holds
f . i = 1. G
proof end;

theorem Th10: :: GROUP_7:10
for I being set
for g being Function
for s being ManySortedSet of I
for F being Group-like associative HGrStr-Family of I
for x being Element of (product F) st x = g & ( for i being set st i in I holds
ex G being Group ex y being Element of G st
( G = F . i & s . i = y " & y = g . i ) ) holds
s = x "
proof end;

theorem Th11: :: GROUP_7:11
for I, i being set
for f, g being Function
for F being Group-like associative HGrStr-Family of I
for x being Element of (product F)
for G being Group
for y being Element of G st i in I & G = F . i & f = x & g = x " & f . i = y holds
g . i = y "
proof end;

definition
let I be set ;
let F be Group-like associative HGrStr-Family of I;
func sum c2 -> strict Subgroup of product a2 means :Def9: :: GROUP_7:def 9
for x being set holds
( x in the carrier of it iff ex g being Element of product (Carrier F) ex J being finite Subset of I ex f being ManySortedSet of J st
( g = 1. (product F) & x = g +* f & ( for j being set st j in J holds
ex G being non empty Group-like HGrStr st
( G = F . j & f . j in the carrier of G & f . j <> 1. G ) ) ) );
existence
ex b1 being strict Subgroup of product F st
for x being set holds
( x in the carrier of b1 iff ex g being Element of product (Carrier F) ex J being finite Subset of I ex f being ManySortedSet of J st
( g = 1. (product F) & x = g +* f & ( for j being set st j in J holds
ex G being non empty Group-like HGrStr st
( G = F . j & f . j in the carrier of G & f . j <> 1. G ) ) ) )
proof end;
uniqueness
for b1, b2 being strict Subgroup of product F st ( for x being set holds
( x in the carrier of b1 iff ex g being Element of product (Carrier F) ex J being finite Subset of I ex f being ManySortedSet of J st
( g = 1. (product F) & x = g +* f & ( for j being set st j in J holds
ex G being non empty Group-like HGrStr st
( G = F . j & f . j in the carrier of G & f . j <> 1. G ) ) ) ) ) & ( for x being set holds
( x in the carrier of b2 iff ex g being Element of product (Carrier F) ex J being finite Subset of I ex f being ManySortedSet of J st
( g = 1. (product F) & x = g +* f & ( for j being set st j in J holds
ex G being non empty Group-like HGrStr st
( G = F . j & f . j in the carrier of G & f . j <> 1. G ) ) ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def9 defines sum GROUP_7:def 9 :
for I being set
for F being Group-like associative HGrStr-Family of I
for b3 being strict Subgroup of product F holds
( b3 = sum F iff for x being set holds
( x in the carrier of b3 iff ex g being Element of product (Carrier F) ex J being finite Subset of I ex f being ManySortedSet of J st
( g = 1. (product F) & x = g +* f & ( for j being set st j in J holds
ex G being non empty Group-like HGrStr st
( G = F . j & f . j in the carrier of G & f . j <> 1. G ) ) ) ) );

registration
let I be set ;
let F be Group-like associative HGrStr-Family of I;
let f be Element of (sum F), g be Element of (sum F);
cluster the mult of (sum a2) . a3,a4 -> Relation-like Function-like ;
coherence
( the mult of (sum F) . f,g is Function-like & the mult of (sum F) . f,g is Relation-like )
proof end;
end;

theorem Th12: :: GROUP_7:12
for I being finite set
for F being Group-like associative HGrStr-Family of I holds product F = sum F
proof end;

theorem Th13: :: GROUP_7:13
for G1 being non empty HGrStr holds <*G1*> is HGrStr-Family of {1}
proof end;

definition
let G1 be non empty HGrStr ;
redefine func <* as <*c1*> -> HGrStr-Family of {1};
coherence
<*G1*> is HGrStr-Family of {1}
by ;
end;

theorem Th14: :: GROUP_7:14
for G1 being non empty Group-like HGrStr holds <*G1*> is Group-like HGrStr-Family of {1}
proof end;

definition
let G1 be non empty Group-like HGrStr ;
redefine func <* as <*c1*> -> Group-like HGrStr-Family of {1};
coherence
<*G1*> is Group-like HGrStr-Family of {1}
by ;
end;

theorem Th15: :: GROUP_7:15
for G1 being non empty associative HGrStr holds <*G1*> is associative HGrStr-Family of {1}
proof end;

definition
let G1 be non empty associative HGrStr ;
redefine func <* as <*c1*> -> associative HGrStr-Family of {1};
coherence
<*G1*> is associative HGrStr-Family of {1}
by ;
end;

theorem Th16: :: GROUP_7:16
for G1 being non empty commutative HGrStr holds <*G1*> is commutative HGrStr-Family of {1}
proof end;

definition
let G1 be non empty commutative HGrStr ;
redefine func <* as <*c1*> -> commutative HGrStr-Family of {1};
coherence
<*G1*> is commutative HGrStr-Family of {1}
by ;
end;

theorem Th17: :: GROUP_7:17
for G1 being Group holds <*G1*> is Group-like associative HGrStr-Family of {1}
proof end;

definition
let G1 be Group;
redefine func <* as <*c1*> -> Group-like associative HGrStr-Family of {1};
coherence
<*G1*> is Group-like associative HGrStr-Family of {1}
by ;
end;

theorem Th18: :: GROUP_7:18
for G1 being commutative Group holds <*G1*> is Group-like associative commutative HGrStr-Family of {1}
proof end;

definition
let G1 be commutative Group;
redefine func <* as <*c1*> -> Group-like associative commutative HGrStr-Family of {1};
coherence
<*G1*> is Group-like associative commutative HGrStr-Family of {1}
by ;
end;

registration
let G1 be non empty HGrStr ;
cluster -> FinSequence-like Element of product (Carrier <*a1*>);
coherence
for b1 being Element of product (Carrier <*G1*>) holds b1 is FinSequence-like
proof end;
end;

registration
let G1 be non empty HGrStr ;
cluster -> FinSequence-like Element of the carrier of (product <*a1*>);
coherence
for b1 being Element of (product <*G1*>) holds b1 is FinSequence-like
proof end;
end;

definition
let G1 be non empty HGrStr ;
let x be Element of G1;
redefine func <* as <*c2*> -> Element of (product <*a1*>);
coherence
<*x*> is Element of (product <*G1*>)
proof end;
end;

theorem Th19: :: GROUP_7:19
for G1, G2 being non empty HGrStr holds <*G1,G2*> is HGrStr-Family of {1,2}
proof end;

definition
let G1 be non empty HGrStr , G2 be non empty HGrStr ;
redefine func <* as <*c1,c2*> -> HGrStr-Family of {1,2};
coherence
<*G1,G2*> is HGrStr-Family of {1,2}
by ;
end;

theorem Th20: :: GROUP_7:20
for G1, G2 being non empty Group-like HGrStr holds <*G1,G2*> is Group-like HGrStr-Family of {1,2}
proof end;

definition
let G1 be non empty Group-like HGrStr , G2 be non empty Group-like HGrStr ;
redefine func <* as <*c1,c2*> -> Group-like HGrStr-Family of {1,2};
coherence
<*G1,G2*> is Group-like HGrStr-Family of {1,2}
by ;
end;

theorem Th21: :: GROUP_7:21
for G1, G2 being non empty associative HGrStr holds <*G1,G2*> is associative HGrStr-Family of {1,2}
proof end;

definition
let G1 be non empty associative HGrStr , G2 be non empty associative HGrStr ;
redefine func <* as <*c1,c2*> -> associative HGrStr-Family of {1,2};
coherence
<*G1,G2*> is associative HGrStr-Family of {1,2}
by ;
end;

theorem Th22: :: GROUP_7:22
for G1, G2 being non empty commutative HGrStr holds <*G1,G2*> is commutative HGrStr-Family of {1,2}
proof end;

definition
let G1 be non empty commutative HGrStr , G2 be non empty commutative HGrStr ;
redefine func <* as <*c1,c2*> -> commutative HGrStr-Family of {1,2};
coherence
<*G1,G2*> is commutative HGrStr-Family of {1,2}
by ;
end;

theorem Th23: :: GROUP_7:23
for G1, G2 being Group holds <*G1,G2*> is Group-like associative HGrStr-Family of {1,2}
proof end;

definition
let G1 be Group, G2 be Group;
redefine func <* as <*c1,c2*> -> Group-like associative HGrStr-Family of {1,2};
coherence
<*G1,G2*> is Group-like associative HGrStr-Family of {1,2}
by ;
end;

theorem Th24: :: GROUP_7:24
for G1, G2 being commutative Group holds <*G1,G2*> is Group-like associative commutative HGrStr-Family of {1,2}
proof end;

definition
let G1 be commutative Group, G2 be commutative Group;
redefine func <* as <*c1,c2*> -> Group-like associative commutative HGrStr-Family of {1,2};
coherence
<*G1,G2*> is Group-like associative commutative HGrStr-Family of {1,2}
by ;
end;

registration
let G1 be non empty HGrStr , G2 be non empty HGrStr ;
cluster -> FinSequence-like Element of product (Carrier <*a1,a2*>);
coherence
for b1 being Element of product (Carrier <*G1,G2*>) holds b1 is FinSequence-like
proof end;
end;

registration
let G1 be non empty HGrStr , G2 be non empty HGrStr ;
cluster -> FinSequence-like Element of the carrier of (product <*a1,a2*>);
coherence
for b1 being Element of (product <*G1,G2*>) holds b1 is FinSequence-like
proof end;
end;

definition
let G1 be non empty HGrStr , G2 be non empty HGrStr ;
let x be Element of G1;
let y be Element of G2;
redefine func <* as <*c3,c4*> -> Element of (product <*a1,a2*>);
coherence
<*x,y*> is Element of (product <*G1,G2*>)
proof end;
end;

theorem Th25: :: GROUP_7:25
for G1, G2, G3 being non empty HGrStr holds <*G1,G2,G3*> is HGrStr-Family of {1,2,3}
proof end;

definition
let G1 be non empty HGrStr , G2 be non empty HGrStr , G3 be non empty HGrStr ;
redefine func <* as <*c1,c2,c3*> -> HGrStr-Family of {1,2,3};
coherence
<*G1,G2,G3*> is HGrStr-Family of {1,2,3}
by Th1;
end;

theorem Th26: :: GROUP_7:26
for G1, G2, G3 being non empty Group-like HGrStr holds <*G1,G2,G3*> is Group-like HGrStr-Family of {1,2,3}
proof end;

definition
let G1 be non empty Group-like HGrStr , G2 be non empty Group-like HGrStr , G3 be non empty Group-like HGrStr ;
redefine func <* as <*c1,c2,c3*> -> Group-like HGrStr-Family of {1,2,3};
coherence
<*G1,G2,G3*> is Group-like HGrStr-Family of {1,2,3}
by ;
end;

theorem Th27: :: GROUP_7:27
for G1, G2, G3 being non empty associative HGrStr holds <*G1,G2,G3*> is associative HGrStr-Family of {1,2,3}
proof end;

definition
let G1 be non empty associative HGrStr , G2 be non empty associative HGrStr , G3 be non empty associative HGrStr ;
redefine func <* as <*c1,c2,c3*> -> associative HGrStr-Family of {1,2,3};
coherence
<*G1,G2,G3*> is associative HGrStr-Family of {1,2,3}
by ;
end;

theorem Th28: :: GROUP_7:28
for G1, G2, G3 being non empty commutative HGrStr holds <*G1,G2,G3*> is commutative HGrStr-Family of {1,2,3}
proof end;

definition
let G1 be non empty commutative HGrStr , G2 be non empty commutative HGrStr , G3 be non empty commutative HGrStr ;
redefine func <* as <*c1,c2,c3*> -> commutative HGrStr-Family of {1,2,3};
coherence
<*G1,G2,G3*> is commutative HGrStr-Family of {1,2,3}
by ;
end;

theorem Th29: :: GROUP_7:29
for G1, G2, G3 being Group holds <*G1,G2,G3*> is Group-like associative HGrStr-Family of {1,2,3}
proof end;

definition
let G1 be Group, G2 be Group, G3 be Group;
redefine func <* as <*c1,c2,c3*> -> Group-like associative HGrStr-Family of {1,2,3};
coherence
<*G1,G2,G3*> is Group-like associative HGrStr-Family of {1,2,3}
by ;
end;

theorem Th30: :: GROUP_7:30
for G1, G2, G3 being commutative Group holds <*G1,G2,G3*> is Group-like associative commutative HGrStr-Family of {1,2,3}
proof end;

definition
let G1 be commutative Group, G2 be commutative Group, G3 be commutative Group;
redefine func <* as <*c1,c2,c3*> -> Group-like associative commutative HGrStr-Family of {1,2,3};
coherence
<*G1,G2,G3*> is Group-like associative commutative HGrStr-Family of {1,2,3}
by ;
end;

registration
let G1 be non empty HGrStr , G2 be non empty HGrStr , G3 be non empty HGrStr ;
cluster -> FinSequence-like Element of product (Carrier <*a1,a2,a3*>);
coherence
for b1 being Element of product (Carrier <*G1,G2,G3*>) holds b1 is FinSequence-like
proof end;
end;

registration
let G1 be non empty HGrStr , G2 be non empty HGrStr , G3 be non empty HGrStr ;
cluster -> FinSequence-like Element of the carrier of (product <*a1,a2,a3*>);
coherence
for b1 being Element of (product <*G1,G2,G3*>) holds b1 is FinSequence-like
proof end;
end;

definition
let G1 be non empty HGrStr , G2 be non empty HGrStr , G3 be non empty HGrStr ;
let x be Element of G1;
let y be Element of G2;
let z be Element of G3;
redefine func <* as <*c4,c5,c6*> -> Element of (product <*a1,a2,a3*>);
coherence
<*x,y,z*> is Element of (product <*G1,G2,G3*>)
proof end;
end;

theorem Th31: :: GROUP_7:31
for G1 being non empty HGrStr
for x1, x2 being Element of G1 holds <*x1*> * <*x2*> = <*(x1 * x2)*>
proof end;

theorem Th32: :: GROUP_7:32
for G1, G2 being non empty HGrStr
for x1, x2 being Element of G1
for y1, y2 being Element of G2 holds <*x1,y1*> * <*x2,y2*> = <*(x1 * x2),(y1 * y2)*>
proof end;

theorem Th33: :: GROUP_7:33
for G1, G2, G3 being non empty HGrStr
for x1, x2 being Element of G1
for y1, y2 being Element of G2
for z1, z2 being Element of G3 holds <*x1,y1,z1*> * <*x2,y2,z2*> = <*(x1 * x2),(y1 * y2),(z1 * z2)*>
proof end;

theorem Th34: :: GROUP_7:34
for G1 being non empty Group-like HGrStr holds 1. (product <*G1*>) = <*(1. G1)*>
proof end;

theorem Th35: :: GROUP_7:35
for G1, G2 being non empty Group-like HGrStr holds 1. (product <*G1,G2*>) = <*(1. G1),(1. G2)*>
proof end;

theorem Th36: :: GROUP_7:36
for G1, G2, G3 being non empty Group-like HGrStr holds 1. (product <*G1,G2,G3*>) = <*(1. G1),(1. G2),(1. G3)*>
proof end;

theorem Th37: :: GROUP_7:37
for G1 being Group
for x being Element of G1 holds <*x*> " = <*(x " )*>
proof end;

theorem Th38: :: GROUP_7:38
for G1, G2 being Group
for x being Element of G1
for y being Element of G2 holds <*x,y*> " = <*(x " ),(y " )*>
proof end;

theorem Th39: :: GROUP_7:39
for G1, G2, G3 being Group
for x being Element of G1
for y being Element of G2
for z being Element of G3 holds <*x,y,z*> " = <*(x " ),(y " ),(z " )*>
proof end;

theorem Th40: :: GROUP_7:40
for G1 being Group
for f being Function of the carrier of G1,the carrier of (product <*G1*>) st ( for x being Element of G1 holds f . x = <*x*> ) holds
f is Homomorphism of G1,(product <*G1*>)
proof end;

theorem Th41: :: GROUP_7:41
for G1 being Group
for f being Homomorphism of G1,(product <*G1*>) st ( for x being Element of G1 holds f . x = <*x*> ) holds
f is_isomorphism
proof end;

theorem Th42: :: GROUP_7:42
for G1 being Group holds G1, product <*G1*> are_isomorphic
proof end;