Products, embeddings, quotients

Goal

Build a direct product, recover each factor through its Embedding, take images and kernels of a homomorphism, and form a quotient. We're exploring the plumbing behind building A × B and reading how the factors sit inside it.

Concept

DirectProduct(A, B) builds A × B as a single group; the factors come back inside it via Embedding(dp, 1) and Embedding(dp, 2), which are injective homomorphisms. Image(hom, x) pushes elements forward, Image(hom) gives the whole image, Kernel(hom) the elements sent to the identity. FactorGroup(G, N) forms G/N for a normal N. These are how you construct a product like A5 × C3 and read the centralizer structure that shows the factors centralise each other.

Commands to try

A := SymmetricGroup(3);;
B := CyclicGroup(IsPermGroup, 2);;
dp := DirectProduct(A, B);
Size(dp);

Expect 12. DirectProduct of S3 (order 6) and C2 (order 2). Asking for the permutation version of C2 keeps everything a permutation group, so the product is too.

e1 := Embedding(dp, 1);;
e2 := Embedding(dp, 2);;
A_in := Image(e1);;
B_in := Image(e2);;
Size(A_in);  Size(B_in);

Expect 6 and 2. Embedding(dp, i) is the map factor_i ↪ dp; Image of it is that factor sitting inside the product.

IsSubgroup(dp, A_in);
Centralizer(dp, A_in) = B_in;

Predict the second: in a direct product, each factor centralises the other, so C_dp(A) = B. Expect true. Of course, in a direct product each factor is exactly the other's centralizer.

A homomorphism with a kernel

S4 := SymmetricGroup(4);;
sgn := GroupHomomorphismByImages( S4, SymmetricGroup(2),
         [ (1,2), (1,2,3,4) ], [ (1,2), (1,2) ] );
Image(sgn, (1,2,3) );
Size(Kernel(sgn));

This is the sign homomorphism S4 → S2. Predict: (1,2,3) is even, so its image is the identity (); the kernel is A4, order 12. GroupHomomorphismByImages(G, H, gens, imgs) defines a map by where generators go (GAP checks it's well-defined).

Q := FactorGroup(S4, Kernel(sgn));
Size(Q);
StructureDescription(Q);

Expect 2 and "C2". S4 / A4 ≅ C2. That's the the sign quotient. StructureDescription names the isomorphism type of a small group.

Predict-then-check

dp := DirectProduct( AlternatingGroup(5), CyclicGroup(IsPermGroup, 3) );;
Size(dp);
Size( Image( Embedding(dp, 1) ) );
Size( Centralizer( dp, Image(Embedding(dp,1)) ) );

Predict all three: the product order, the size of the A5 factor's image, and - since the other factor is C3, the centralizer of the A5 factor. (What centralises A5 in A5 × C3?)

Exercise

1. Build dp := DirectProduct(SymmetricGroup(3), SymmetricGroup(3)). Recover both factors via embeddings and confirm each centralises the other.
2. Define the sign map on S3 with GroupHomomorphismByImages, then compute its kernel's size (predict: A3, order 3) and the quotient's StructureDescription.
3. For your S4 sign map, verify Size(Image(sgn)) * Size(Kernel(sgn)) = Size(S4) - the first isomorphism theorem as arithmetic.
4. Foreshadow: build DirectProduct(AlternatingGroup(5), SymmetricGroup(3)) and check Size(Centralizer(dp, Image(Embedding(dp,1)))) = 6. Why 6?

Pitfalls

• Embedding(dp, i) is a homomorphism, not a subgroup - wrap it in Image to get the subgroup. Projection(dp, i) is the complementary map out of the product.
• GroupHomomorphismByImages returns fail (not an error) if the assignment isn't a well-defined homomorphism. Always check it didn't come back fail.
• FactorGroup(G, N) requires N normal in G; otherwise it fails. Kernels are always normal, so quotient-by-kernel is safe.
• Image(hom) (whole image) vs Image(hom, x) (one element): same function, arity-dependent. PreImages goes the other way.
• Mixing a permutation factor with a pc-group factor (the default CyclicGroup) yields a less convenient product; pass IsPermGroup to CyclicGroup to keep the product a permutation group, as above.