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:
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.
- (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 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.
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.
> 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 }