GAP distinguishs between parent groups and subgroups of parent groups. Each subgroup belongs to a unique parent group. We say that this parent group is the parent of the subgroup. We also say that a parent group is its own parent.
Parent groups are constructed by Group and subgroups are constructed by
Subgroup. The first argument of Subgroup must be a parent group,
i.e., it must not be a subgroup of a parent group, and this parent group
will be the parent of the constructed subgroup.
Those group functions that take more than one argument require that the
arguments have a common parent. Take for instance CommutatorSubgroup. It
takes two arguments, a group G and a group H, and returns the
commutator subgroup of H with G. So either G is a parent group,
and H is a
subgroup of this parent group, or G and H are subgroups of a common
parent group P.
gap> s4 := Group( (1,2), (1,2,3,4) );
Group( (1,2), (1,2,3,4) )
gap> c3 := Subgroup( s4, [ (1,2,3) ] );
Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3) ] )
gap> CommutatorSubgroup( s4, c3 );
Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,3,2), (1,2,4) ] )
# ok, 'c3' is a subgroup of the parent group 's4'
gap> a4 := Subgroup( s4, [ (1,2,3), (2,3,4) ] );
Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3), (2,3,4) ] )
gap> CommutatorSubgroup( a4, c3 );
Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,4)(2,3), (1,3)(2,4) ] )
# also ok, 'c3' and 'a4' are subgroups of the parent group 's4'
gap> x3 := Group( (1,2,3) );
Group( (1,2,3) )
gap> CommutatorSubgroup( s4, x3 );
Error, <G> and <H> must have the same parent group
# not ok, 's4' is its own parent and 'x3' is its own parent
Those functions that return new subgroups, as with CommutatorSubgroup
above,
return this subgroup as a subgroup of the common parent of their
arguments. Note especially that the commutator subgroup of c3 with
a4 is
returned as a subgroup of their common parent group s4, not as a
subgroup of a4. It can not be a subgroup of a4, because subgroups
must be subgroups of parent groups, and a4 is not a parent group. Of
course, mathematically the commutator subgroup is a subgroup of a4.
Note that a subgroup of a parent group need not be a proper subgroup, as can be seen in the following example.
gap> s4 := Group( (1,2), (1,2,3,4) );
Group( (1,2), (1,2,3,4) )
gap> x4 := Subgroup( s4, [ (1,2,3,4), (3,4) ] );
Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3,4), (3,4) ] )
gap> Index( s4, x4 );
1
One exception to the rule are functions that construct new groups such as
DirectProduct. They accept groups with different parents. If you want
rename the function DirectProduct to OuterDirectProduct.
Another exception is Intersection (see Intersection), which allows
groups with different parent groups, it computes the intersection in such
cases as if the groups were sets of elements. This is because
Intersection is not a group function, but a domain function, i.e., it
accepts two (or more) arbitrary domains as arguments.
Whenever you have two subgroups which have different parent groups but
have a common supergroup G you can use AsSubgroup (see AsSubgroup)
in order to construct new subgroups which have a common parent group G.
gap> s4 := Group( (1,2), (1,2,3,4) );
Group( (1,2), (1,2,3,4) )
gap> x3 := Group( (1,2,3) );
Group( (1,2,3) )
gap> CommutatorSubgroup( s4, x3 );
Error, <G> and <H> must have the same parent group
# not ok, 's4' is its own parent and 'x3' is its own parent
gap> c3 := AsSubgroup( s4, x3 );
Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,2,3) ] )
gap> CommutatorSubgroup( s4, c3 );
Subgroup( Group( (1,2), (1,2,3,4) ), [ (1,3,2), (1,2,4) ] )
The following sections describe the functions related to this concept (see IsParent, Parent, Group, AsGroup, IsGroup, Subgroup, AsSubgroup).
GAP 3.4.4