|
Arbitrary homomorphisms can be defined between pc-groups by using
the hom<> constructor. For pc-groups, this constructor has
features not generally available for user-defined homomorphisms.
In addition to defining the map by giving images for the pc-generators,
a homomorphism can be defined by giving images for any generating
set of the domain. Magma will verify that the specified images
define a homomorphism and will compute the kernel and inverse images
for the defined map. Note that the value returned for an inverse
image of an element is simply one element from the preimage, not
the complete coset.
Check: BoolElt Default: true
Construct a homomorphism φ:G -> H defined by the images
specified by the list L.
The list L must be one of the following:
- (a)
- a list, set, or sequence of 2-tuples <gi, hi> (order not important);
- (b)
- a list, set, or sequence of arrow pairs gi - > hi (order not important);
- (c)
- a list or sequence of images h1, ..., hn (order is important).
The elements gi and hi must be elements of G and H, respectively,
in each case. For the cases (a) and (b), the elements gi must generate
G and the homomorphism will satisfy φ(gi) = hi. For case (c),
n must be the number of pc-generators of G and the gi are implicitly
defined to be the pc-generators. However, if G is a p-group which has p-Quotient
definitions set (see HaspQuotientDefinitions), then n can be the number of
generators of G (the result of Ngens(G)) and the gi are implicitly defined
to be the first n pc-generators.
The parameter Check can be set to false in order to turn off
the check that the map defined is a homomorphism. This should only
be done when one is certain that the map is a homomorphism, since
later results will most likely be incorrect if it is not.
IsHomomorphism(G, H, L) : GrpPC, GrpPC, SetEnum[Tup] -> BoolElt, Map
This is a conditional form of the hom-constructor. The argument
L must be a set or sequence of pairs (as in case (a) of the
hom-constructor), or a sequence of images in H for the
pc-generators of G (as in case (c) of the hom-constructor).
If the specified images define a homomorphism, the value true and
the resulting map are returned. Otherwise, false is returned.
The identity map from G to G.
Given a homomorphism f from one pc-group to another, return the
kernel of f. This will be a pc-group which is a subgroup of the
domain of f.
Given finite abelian groups G and H, return a sequence containing
all elements of (Hom)(G, H). The elements
are returned as actual (Magma map type) homomorphisms.
Note that this function simply uses Hom, transferring each
element of the returned group to the actual Magma map type homomorphism.
Let G be a pc-representation of the symmetric group S 4, and N be
O 2(G).
> G := PCGroup(Sym(4));
> G;
GrpPC : G of order 24 = 2^3 * 3
PC-Relations:
G.1^2 = Id(G),
G.2^3 = Id(G),
G.3^2 = Id(G),
G.4^2 = Id(G),
G.2^G.1 = G.2^2,
G.3^G.1 = G.3 * G.4,
G.3^G.2 = G.4,
G.4^G.2 = G.3 * G.4
> N := pCore(G,2);
> Order(N);
4
Let us define H to be a complement of N in G.
> H := sub<G|G.1*G.4,G.2*G.4>;
> Order(H);
6
> H meet N;
GrpPC of order 1
PC-Relations:
We now wish to define the projection homomorphism from G to H.
This will map each element of N to the identity and each element
of H to itself. We can define the map directly using these
properties.
> pairs := [];
> for n in Generators(N) do
> pairs cat:= [<G!n,Id(H)>];
> end for;
> for h in Generators(H) do
> pairs cat:= [<G!h, h>];
> end for;
> proj := hom<G -> H|pairs>;
> proj;
Mapping from: GrpPC: G to GrpPC: H
> proj(G.1);
H.1
> proj(N);
GrpPC of order 1
PC-Relations:
We can also compute inverse images and can verify that
N is the kernel of the map.
Note that the preimage of a single element is just
one element from the preimage, not the complete coset.
Of course, one can use the kernel to compute the full
coset if desired.
> y := (H.1)@@proj;
> y;
G.1
> Kernel(proj) eq N;
true
> {y*k: k in Kernel(proj)};
{ G.1 * G.3 * G.4, G.1 * G.4, G.1, G.1 * G.3 }
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|