Homomorphisms

Let M and N be A-modules where A is an algebra defined over a field K. Then HomA(M, N) consists of all K-homomorphisms from M to N which commute with the action of A. The type of such (matrix) homomorphisms, called A-homs, is ModMatGrpElt.

Contents

Creating Homomorphisms and Hom Spaces

hom< M -> N | X > : ModRng, ModRng, ModMatElt -> Map
Given A-modules M and N, create the (map) homomorphism from M to N given by matrix X.
Hom(M, N) : ModRng, ModRng -> ModMatRng
Given a matrix algebra A defined over a field and A-modules M and N, construct the vector space of homomorphisms, HomK(M, N).
GHom(M, N) : ModGrp, ModGrp -> ModMatGrp
Given K[G] modules M and N, where K is a finite field or number field, construct the space of all KG-homomorphisms from M to N. Note that GHom(M,N) = Fix(HomMod(M,N)).
GHomOverCentralizingField(M, N) : ModGrp, ModGrp -> ModMatGrp
GHomOverCentralizingField(M, N) : ModRng, ModRng -> ModRng
Let A be a matrix algebra defined over a finite field or number field. Given A-modules M and N, construct HomL[G](M, N) as a subspace of HomK(M, N), where L is the centralizing field of M.
AHom(M, N) : ModRng, ModRng -> ModMatRng
Let A be a matrix algebra defined over a finite field or number field. Given A-modules M and N, construct the vector space of homomorphisms, HomA(M, N), as a submodule of HomK(M, N).
HomMod(M, N) : ModGrp, ModGrp -> ModGrp
Let M and N be two K[G]-modules where K is a finite field or a number field. This function constructs the K[G]-module of all K-homomorphisms from M to N. The action of G on the module is given by (m)(α * g) := ((m * g - 1)α) * g for m ∈M, g ∈G, and α ∈Hom(M,N).
H ! f : ModMatRng, Map -> ModMatRngElt
Given the matrix space H, which is HomA(M, N) for A-modules M and N, together with a homomorphism f from M to N, create the matrix corresponding to the map f.
IsModuleHomomorphism(X) : ModMatFldElt -> BoolElt
Given a matrix X belonging to HomK(M, N), where M and N are A-modules, return true if X is an A-homomorphism.

Example ModAlg_EndoRing (H97E25)

We construct a 12-dimensional module M and a 9-dimensional submodule P of M for a soluble group of order 648 over GF(3). We then construct H = HomA(M, N) and perform map operations on elements of H. 
> G := PermutationGroup< 12 |
>         (1,6,7)(2,5,8,3,4,9)(11,12),
>         (1,3)(4,9,12)(5,8,10,6,7,11) >;
> K := GF(3);
> P := PermutationModule(G, K);
> M := sub< P | [1,0,0,0,0,1,0,0,1,0,0,1] >;
> M;
GModule M of dimension 9 over GF(3)
> H := AHom(P, M);
> H: Maximal;
KMatrixSpace of 12 by 9 GHom matrices and dimension 2 over GF(3)
Echelonized basis:
[1 1 1 0 0 0 0 0 0]
[1 1 1 0 0 0 0 0 0]
[1 1 1 0 0 0 0 0 0]
[0 0 0 1 1 0 0 0 0]
[0 0 0 1 1 0 0 0 0]
[0 0 0 1 1 0 0 0 0]
[0 0 0 0 0 1 1 0 0]
[0 0 0 0 0 1 1 0 0]
[0 0 0 0 0 1 1 0 0]
[0 0 0 0 0 0 0 1 1]
[0 0 0 0 0 0 0 1 1]
[0 0 0 0 0 0 0 1 1]
[0 0 0 1 1 1 1 1 1]
[0 0 0 1 1 1 1 1 1]
[0 0 0 1 1 1 1 1 1]
[1 1 1 0 0 1 1 1 1]
[1 1 1 0 0 1 1 1 1]
[1 1 1 0 0 1 1 1 1]
[1 1 1 1 1 0 0 1 1]
[1 1 1 1 1 0 0 1 1]
[1 1 1 1 1 0 0 1 1]
[1 1 1 1 1 1 1 0 0]
[1 1 1 1 1 1 1 0 0]
[1 1 1 1 1 1 1 0 0]
> // We write down a random homomorphism from M to P.
> f := 2*H.1 + H.2;
> f;
[2 2 2 1 1 1 1 1 1]
[2 2 2 1 1 1 1 1 1]
[2 2 2 1 1 1 1 1 1]
[1 1 1 2 2 1 1 1 1]
[1 1 1 2 2 1 1 1 1]
[1 1 1 2 2 1 1 1 1]
[1 1 1 1 1 2 2 1 1]
[1 1 1 1 1 2 2 1 1]
[1 1 1 1 1 2 2 1 1]
[1 1 1 1 1 1 1 2 2]
[1 1 1 1 1 1 1 2 2]
[1 1 1 1 1 1 1 2 2]
> Ker := Kernel(f);
> Ker;
GModule Ker of dimension 8 with base ring GF(3)

If we print the morphism associated with Ker, we see generators for Ker as a submodule of P. 

> Morphism(Ker, P);
[1 0 2 0 0 0 0 0 0 0 0 0]
[0 1 2 0 0 0 0 0 0 0 0 0]
[0 0 0 1 0 2 0 0 0 0 0 0]
[0 0 0 0 1 2 0 0 0 0 0 0]
[0 0 0 0 0 0 1 0 2 0 0 0]
[0 0 0 0 0 0 0 1 2 0 0 0]
[0 0 0 0 0 0 0 0 0 1 0 2]
[0 0 0 0 0 0 0 0 0 0 1 2]
> // Examine the image of f and its morphism to P.
> Im := Image(f);
> Im;
GModule Im of dimension 4 with base ring GF(3)
> Morphism(Im, P);
[1 1 1 0 0 0 0 0 0 0 0 0]
[0 0 0 1 1 1 0 0 0 0 0 0]
[0 0 0 0 0 0 1 1 1 0 0 0]
[0 0 0 0 0 0 0 0 0 1 1 1]

Example ModAlg_CreateHomGHom (H97E26)

We construct a G-homomorphism module H1 for a G-module and then the homomorphism module H = Hom(H1, H1) with right matrix action which is equivalent to (the right representation of) the endomorphism module of H. 
> P := GModule(CyclicGroup(11), GF(3));
> F := Constituents(P);
> F;
[
    GModule of dimension 1 over GF(3),
    GModule of dimension 5 over GF(3),
    GModule of dimension 5 over GF(3)
]
> H1 := GHom(P, F[2]);
> H1;
KMatrixSpace of 2 by 3 matrices and dimension 1 over Rational Field
> H := Hom(H1, H1, "right");
> H: Maximal;
KMatrixSpace of 5 by 5 matrices and dimension 5 over GF(3)
Echelonized basis:
[1 0 0 0 0]
[0 1 0 0 0]
[0 0 1 0 0]
[0 0 0 1 0]
[0 0 0 0 1]
[0 1 0 0 0]
[1 1 1 2 1]
[2 0 2 1 1]
[2 1 0 0 0]
[0 2 1 0 0]
[0 0 1 0 0]
[2 0 2 1 1]
[2 2 2 2 2]
[2 0 1 0 2]
[1 0 1 2 1]
[0 0 0 1 0]
[2 1 0 0 0]
[2 0 1 0 2]
[2 2 1 2 2]
[2 1 1 0 1]
[0 0 0 0 1]
[0 2 1 0 0]
[1 0 1 2 1]
[2 1 1 0 1]
[2 1 0 0 2]

Isomorphism and Similarity

Isomorphism
IsIsomorphic(M, N) : ModRng, ModRng -> ModRng, ModRng, BoolElt, AlgMatElt
Let A be a matrix algebra over a finite field or a number field. This intrinsic returns true if the A-modules M and N are isomorphic, false otherwise. If M and N are isomorphic, the function also returns a matrix T such that MT = N. Note that the action generators of M and N must match, so the function effectively determines whether there is an invertible matrix T such that T^-1*ActionGenerator(M, i)*T equals ActionGenerator(N, i) for each i. This test uses a fast algorithm due to Brooksbank and Luks.
SummandIsomorphism(M, N) : ModRng, ModRng -> ModRng, ModRng, Map, Map
Let A be a matrix algebra over a finite field or a number field and let M and N be A-modules. This intrinsic determines the unique maximal, isomorphic summands of module M and N. These are returned together with the inverse isomorphisms between them. The algorithm used is due to Brooksbank and Luks.
Similarity of Cyclic Algebras and their Modules

Magma supports similarity testing of modules over cyclic associative rings and cyclic groups. Module similarity over general rings and groups is graph isomorphism hard. The algorithms used are based on [BW15].

IsCyclic(R) : AlgAss -> BoolElt, AlgAssElt
Let A be a matrix algebra over a finite field and let M be an A-module. This intrinsic decides if the algebra is generated by a single element and, if so, return such a generator.
IsSimilar(M, N) : ModRng, ModRng -> BoolElt, Map
Let A be a matrix algebra over a finite field or a number field and let M and N be A-modules. This intrinsic decides if modules M and N are similar. Note that one of the two modules must have a cyclic coefficient ring.

Example ModAlg_Star_Alg (H97E27)

In Magma modules of a group or algebra are defined by the action of a fixed generating set of the algebra. Therefore isomorphism of modules in Magma assumes the given modules have been specified by the same generating set. This can lead to a stricter interpretation of isomorphism than perhaps intended in some situations. Consider the following example comparing two 1-dimensional vector spaces over the field GF(9). 
> SetSeed(1);
> R := MatrixAlgebra(GF(3),2);
> A := sub<R| [R!1, R![0,1,2,0]]>;
> B := sub<R| [R!1, R![1,1,2,1]]>;
> A eq B;   // Both are a field GF(9).
true
> M := RModule(A); // A 1-dim. GF(9) vector space.
> N := RModule(B); // A 1-dim. GF(9) vector space.
> IsIsomorphic(M,N);
false
> MinimalPolynomial(A.2);
$.1^2 + 1
> MinimalPolynomial(B.2);
$.1^2 + $.1 + 2
Isomorphism of the two modules M and N failed because the two vector spaces are specified by different generators of GF(9), as confirmed by the minimum polynomials of the generators. Module similarity allows the comparison of modules specified by different generating sets, so in this example theses to vector spaces can be proven equivalent. 
> IsSimilar(M,N);
true
[2 0]
[0 2]
Similarity can be used to compare modules given by algebras that are conjugate, but perhaps not equal. 
> p := RandomIrreduciblePolynomial(GF(101), 10);
> q := RandomIrreduciblePolynomial(GF(101), 10);
> X := CompanionMatrix(p);
> Y := CompanionMatrix(q);
> A := sub<Parent(X)|[X]>;      // Finite field of size 101^10
> B := sub<Parent(Y)|[Y]>;      // Finite field of size 101^10
> M := RModule(A);              // 1-dim vector space over A.
> N := RModule(B);              // 1-dim vector space over B.
> IsIsomorphic(M,N);            // Not isomorphic as A and B are distinct.
false
> cyc, f := IsSimilar(M,N);     // But similar as A is isomorphic to B.
> // f conjugates A into B?
> forall { a : a in Generators (A) | f * a * f^-1 in B };
true
> // and f is a semilinear transform M->N ?
> forall{ i : i in [1..Ngens (M)] | forall { j : j in [1..Ngens (A)] | (Vector
> (M.i * A.j) * f) eq (Vector(M.i)*f)*(f^(-1)*A.j*f) } };
true
Similarity is presently available for cyclic algebras. This can be tested and a generator returned. 
> M := RandomMatrix(GF(9), 100, 100);
> A := sub< Parent(M) | [ M^(Random(50)) : i in [1..10]] >;
> Ngens(A);
> IsCyclic(A);
true
...

The Endomorphism Ring

EndomorphismAlgebra(M) : ModRng -> AlgMat
EndomorphismRing(M) : ModRng -> AlgMat
    Direct: BoolElt                     Default: false
Given an A-module M over K, where K is a finite field or a number field, return the endomorphism ring EndA(M) of M as a subring of the complete matrix ring K(n x n).
CentreOfEndomorphismRing(M) : ModRng -> AlgMat
Given an A-module M with base ring K, where K is a finite field or a number field, return the centre of the endomorphism ring EndA(M) of M as a subring of the complete matrix ring K(n x n). This is equivalent to Centre(EndomorphismRing(M)) but will often be much faster.
AutomorphismGroup(M) : ModRng -> GrpMat
Given an A-module M with base ring K, where K is a finite field or a number field, return the automorphism group Aut(M) of M as a subgroup G of the general linear group GL(n, K). In fact, G is the group of units of End(M).

Example ModAlg_EndoRing (H97E28)

We construct the endomorphism ring for a permutation module over GF(3) for a soluble group of order 648. 

> G := PermutationGroup< 12 |
>         (1,6,7)(2,5,8,3,4,9)(11,12),
>         (1,3)(4,9,12)(5,8,10,6,7,11) >;
> P := PermutationModule(G, GF(3));
> time End := EndomorphismAlgebra(P);
Time: 0.000
> End;
Matrix Algebra of degree 12 and dimension 3 over GF(3)
Thus, the permutation module P has 27 endomorphisms. 
> time Aut := AutomorphismGroup(P);
Time: 0.010
> Aut;
MatrixGroup(12, GF(3))
Generators:
    [1 0 0 1 1 1 1 1 1 1 1 1]
    [0 1 0 1 1 1 1 1 1 1 1 1]
    [0 0 1 1 1 1 1 1 1 1 1 1]
    [1 1 1 1 0 0 1 1 1 1 1 1]
    [1 1 1 0 1 0 1 1 1 1 1 1]
    [1 1 1 0 0 1 1 1 1 1 1 1]
    [1 1 1 1 1 1 1 0 0 1 1 1]
    [1 1 1 1 1 1 0 1 0 1 1 1]
    [1 1 1 1 1 1 0 0 1 1 1 1]
    [1 1 1 1 1 1 1 1 1 1 0 0]
    [1 1 1 1 1 1 1 1 1 0 1 0]
    [1 1 1 1 1 1 1 1 1 0 0 1]
    [2 1 1 0 0 0 0 0 0 0 0 0]
    [1 2 1 0 0 0 0 0 0 0 0 0]
    [1 1 2 0 0 0 0 0 0 0 0 0]
    [0 0 0 2 1 1 0 0 0 0 0 0]
    [0 0 0 1 2 1 0 0 0 0 0 0]
    [0 0 0 1 1 2 0 0 0 0 0 0]
    [0 0 0 0 0 0 2 1 1 0 0 0]
    [0 0 0 0 0 0 1 2 1 0 0 0]
    [0 0 0 0 0 0 1 1 2 0 0 0]
    [0 0 0 0 0 0 0 0 0 2 1 1]
    [0 0 0 0 0 0 0 0 0 1 2 1]
    [0 0 0 0 0 0 0 0 0 1 1 2]
    [0 1 1 0 0 0 0 0 0 0 0 0]
    [1 0 1 0 0 0 0 0 0 0 0 0]
    [1 1 0 0 0 0 0 0 0 0 0 0]
    [0 0 0 0 1 1 0 0 0 0 0 0]
    [0 0 0 1 0 1 0 0 0 0 0 0]
    [0 0 0 1 1 0 0 0 0 0 0 0]
    [0 0 0 0 0 0 0 1 1 0 0 0]
    [0 0 0 0 0 0 1 0 1 0 0 0]
    [0 0 0 0 0 0 1 1 0 0 0 0]
    [0 0 0 0 0 0 0 0 0 0 1 1]
    [0 0 0 0 0 0 0 0 0 1 0 1]
    [0 0 0 0 0 0 0 0 0 1 1 0]
> #Aut;
18
> IsAbelian(Aut);
true
> AbelianInvariants(Aut);
[ 3, 6 ]

Thus, the permutation module P has 18 automorphisms. The automorphism group is isomorphic to the abelian group Z2 x Z3 x Z3.

V2.28, 13 July 2023