Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind
 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 

7 Homomorphisms of Right Modules over Path Algebras
 7.1 Categories and representation of homomorphisms
 7.2 Generalities of homomorphisms
 7.3 Homomorphisms and modules constructed from homomorphisms and modules

7 Homomorphisms of Right Modules over Path Algebras

This chapter describes the categories, representations, attributes, and operations on homomorphisms between representations of quivers.

Given two homorphisms f\colon L\to M and g\colon M\to N, then the composition is written f*g. The elements in the modules or the representations of a quiver are row vectors. Therefore the homomorphisms between two modules are acting on these row vectors, that is, if m_i is in M[i] and g_i\colon M[i]\to N[i] represents the linear map, then the value of g applied to m_i is the matrix product m_i*g_i.

The example used throughout this chapter is the following.

gap> Q := Quiver(3,[[1,2,"a"],[1,2,"b"],[2,2,"c"],[2,3,"d"],[3,1,"e"]]);;
gap> KQ := PathAlgebra(Rationals, Q);;
gap> AssignGeneratorVariables(KQ);;
gap> rels := [d*e,c^2,a*c*d-b*d,e*a];;
gap> A := KQ/rels;;
gap> mat :=[["a",[[1,2],[0,3],[1,5]]],["b",[[2,0],[3,0],[5,0]]],
> ["c",[[0,0],[1,0]]],["d",[[1,2],[0,1]]],["e",[[0,0,0],[0,0,0]]]];;
gap> N := RightModuleOverPathAlgebra(A,mat);; 

7.1 Categories and representation of homomorphisms

7.1-1 IsPathAlgebraModuleHomomorphism
‣ IsPathAlgebraModuleHomomorphism( f )( filter )

Arguments: f - any object in GAP.

Returns: true or false depending on if f belongs to the categories IsPathAlgebraModuleHomomorphism.

This defines the category IsPathAlgebraModuleHomomorphism.

7.1-2 RightModuleHomOverAlgebra
‣ RightModuleHomOverAlgebra( M, N, mats )( operation )

Arguments: M, N - two modules over the same (quotient of a) path algebra, mats - a list of matrices, one for each vertex in the quiver of the path algebra.

Returns: a homomorphism in the category IsPathAlgebraModuleHomomorphism from the module M to the module N given by the matrices mats.

The arguments M and N are two modules over the same algebra (this is checked), and mats is a list of matrices mats[i], where mats[i] represents the linear map from M[i] to N[i] with i running through all the vertices in the same order as when the underlying quiver was created. If both DimensionVector(M)[i] and DimensionVector(N)[i] are non-zero, then mats[i] is a DimensionVector(M)[i] by DimensionVector(N)[i] matrix. If DimensionVector(M)[i] is zero and DimensionVector(N)[i] is non-zero, then mats[i] must be the zero 1 by DimensionVector(N)[i] matrix. Similarly for the other way around. If both DimensionVector(M)[i] and DimensionVector(N)[i] are zero, then mats[i] must be the 1 by 1 zero matrix. The function checks if mats is a homomorphism from the module M to the module N by checking that the matrices given in mats have the correct size and satisfy the appropriate commutativity conditions with the matrices in the modules given by M and N. The source (or domain) and the range (or codomain) of the homomorphism constructed can by obtained again by Range (7.2-22) and by Source (7.2-24), respectively.

gap> L := RightModuleOverPathAlgebra(A,[["a",[0,1]],["b",[0,1]],
> ["c",[[0]]],["d",[[1]]],["e",[1,0]]]);
<[ 0, 1, 1 ]>
gap> DimensionVector(L);
[ 0, 1, 1 ]
gap> f := RightModuleHomOverAlgebra(L,N,[[[0,0,0]], [[1,0]], 
> [[1,2]]]);
<<[ 0, 1, 1 ]> ---> <[ 3, 2, 2 ]>>

gap> IsPathAlgebraMatModuleHomomorphism(f);
true 

7.2 Generalities of homomorphisms

7.2-1 \= (maps)
‣ \= (maps)( f, g )( operation )

Arguments: f, g - two homomorphisms between two modules.

Returns: true, if Source(f) = Source(g), Range(f) = Range(g), and the matrices defining the maps f and g coincide.

7.2-2 \+ (maps)
‣ \+ (maps)( f, g )( operation )

Arguments: f, g - two homomorphisms between two modules.

Returns: the sum f+g of the maps f and g.

The function checks if the maps have the same source and the same range, and returns an error message otherwise.

7.2-3 \* (maps)
‣ \* (maps)( f, g )( operation )

Arguments: f, g - two homomorphisms between two modules, or one scalar and one homomorphism between modules.

Returns: the composition fg of the maps f and g, if the input are maps between representations of the same quivers. If f or g is a scalar, it returns the natural action of scalars on the maps between representations.

The function checks if the maps are composable, in the first case and in the second case it checks if the scalar is in the correct field, and returns an error message otherwise.

7.2-4 CoKernelOfWhat
‣ CoKernelOfWhat( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: a homomorphism g, if f has been computed as the cokernel of the homomorphism g.

7.2-5 IdentityMapping
‣ IdentityMapping( M )( operation )

Arguments: M - a module.

Returns: the identity map between M and M.

7.2-6 ImageElm
‣ ImageElm( f, elem )( operation )

Arguments: f - a homomorphism between two modules, elem - an element in the source of f.

Returns: the image of the element elem in the source (or domain) of the homomorphism f.

The function checks if elem is an element in the source of f, and it returns an error message otherwise.

7.2-7 ImagesSet
‣ ImagesSet( f, elts )( operation )

Arguments: f - a homomorphism between two modules, elts - an element in the source of f, or the source of f.

Returns: the non-zero images of a set of elements elts in the source of the homomorphism f, or if elts is the source of f, it returns a basis of the image.

The function checks if the set of elements elts consists of elements in the source of f, and it returns an error message otherwise.

gap> B := BasisVectors(Basis(N)); 
[ [ [ 1, 0, 0 ], [ 0, 0 ], [ 0, 0 ] ], 
  [ [ 0, 1, 0 ], [ 0, 0 ], [ 0, 0 ] ], 
  [ [ 0, 0, 1 ], [ 0, 0 ], [ 0, 0 ] ], 
  [ [ 0, 0, 0 ], [ 1, 0 ], [ 0, 0 ] ], 
  [ [ 0, 0, 0 ], [ 0, 1 ], [ 0, 0 ] ], 
  [ [ 0, 0, 0 ], [ 0, 0 ], [ 1, 0 ] ], 
  [ [ 0, 0, 0 ], [ 0, 0 ], [ 0, 1 ] ] ]
gap> PreImagesRepresentative(f,B[4]);     
[ [ 0 ], [ 1 ], [ 0 ] ]
gap> PreImagesRepresentative(f,B[5]);
fail
gap> BL := BasisVectors(Basis(L));
[ [ [ 0 ], [ 1 ], [ 0 ] ], [ [ 0 ], [ 0 ], [ 1 ] ] ]
gap> ImageElm(f,BL[1]);
[ [ 0, 0, 0 ], [ 1, 0 ], [ 0, 0 ] ]
gap> ImagesSet(f,L);
[ [ [ 0, 0, 0 ], [ 1, 0 ], [ 0, 0 ] ], 
  [ [ 0, 0, 0 ], [ 0, 0 ], [ 1, 2 ] ] ]
gap> ImagesSet(f,BL);
[ [ [ 0, 0, 0 ], [ 1, 0 ], [ 0, 0 ] ], 
  [ [ 0, 0, 0 ], [ 0, 0 ], [ 1, 2 ] ] ]
gap> z := Zero(f);;
gap> f = z;
false
gap> Range(f) = Range(z);
true
gap> y := ZeroMapping(L,N);;
gap> y = z;            
true
gap> id := IdentityMapping(N);;
gap> f*id;;
gap> #This causes an error!
gap> id*f;
Error, codomain of the first argument is not equal to the domain of th\
e second argument,  called from
<function>( <arguments> ) called from read-eval-loop
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;;
gap> 2*f + z;
<<[ 0, 1, 1 ]> ---> <[ 3, 2, 2 ]>> 

7.2-8 ImageOfWhat
‣ ImageOfWhat( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: a homomorphism g, if f has been computed as the image projection or the image inclusion of the homomorphism g.

7.2-9 IsInjective
‣ IsInjective( f )( property )

Arguments: f - a homomorphism between two modules.

Returns: true if the homomorphism f is one-to-one.

7.2-10 IsIsomorphism
‣ IsIsomorphism( f )( operation )

Arguments: f - a homomorphism between two modules.

Returns: true if the homomorphism f is an isomorphism.

7.2-11 IsLeftMinimal
‣ IsLeftMinimal( f )( property )

Arguments: f - a homomorphism between two modules.

Returns: true if the homomorphism f is left minimal.

7.2-12 IsRightMinimal
‣ IsRightMinimal( f )( property )

Arguments: f - a homomorphism between two modules.

Returns: true if the homomorphism f is right minimal.

gap> L := RightModuleOverPathAlgebra(A,[["a",[0,1]],["b",[0,1]],
> ["c",[[0]]],["d",[[1]]],["e",[1,0]]]);;
gap> f := RightModuleHomOverAlgebra(L,N,[[[0,0,0]], [[1,0]], 
> [[1,2]]]);
<<[ 0, 1, 1 ]> ---> <[ 3, 2, 2 ]>>

gap> g := CoKernelProjection(f);
<<[ 3, 2, 2 ]> ---> <[ 3, 1, 1 ]>>

gap> CoKernelOfWhat(g) = f;
true
gap> h := ImageProjection(f);
<<[ 0, 1, 1 ]> ---> <[ 0, 1, 1 ]>>

gap> ImageOfWhat(h) = f;
true
gap> IsInjective(f); IsSurjective(f); IsIsomorphism(f); 
true
false
false
gap> IsIsomorphism(h);
true 

7.2-13 IsSplitEpimorphism
‣ IsSplitEpimorphism( f )( property )

Arguments: f - a homomorphism between two modules.

Returns: true if the homomorphism f is a splittable epimorphism, otherwise false.

7.2-14 IsSplitMonomorphism
‣ IsSplitMonomorphism( f )( property )

Arguments: f - a homomorphism between two modules.

Returns: true if the homomorphism f is a splittable monomorphism, otherwise false.

gap> S := SimpleModules(A)[1];;
gap> H := HomOverAlgebra(N,S);; 
gap> IsSplitMonomorphism(H[1]);  
false
gap> IsSplitEpimorphism(H[1]);
true

7.2-15 IsSurjective
‣ IsSurjective( f )( property )

Arguments: f - a homomorphism between two modules.

Returns: true if the homomorphism f is onto.

7.2-16 IsZero
‣ IsZero( f )( property )

Arguments: f - a homomorphism between two modules.

Returns: true if the homomorphism f is a zero homomorphism.

7.2-17 KernelOfWhat
‣ KernelOfWhat( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: a homomorphism g, if f has been computed as the kernel of the homomorphism g.

gap> L := RightModuleOverPathAlgebra(A,[["a",[0,1]],["b",[0,1]],
> ["c",[[0]]],["d",[[1]]],["e",[1,0]]]);
<[ 0, 1, 1 ]>
gap> f := RightModuleHomOverAlgebra(L,N,[[[0,0,0]], [[1,0]], 
> [[1,2]]]);;
gap> IsZero(0*f);
true
gap> g := KernelInclusion(f);
<<[ 0, 0, 0 ]> ---> <[ 0, 1, 1 ]>>

gap> KnownAttributesOfObject(g);
[ "Range", "Source", "PathAlgebraOfMatModuleMap", "KernelOfWhat" ]
gap> KernelOfWhat(g) = f;
true 

7.2-18 LeftInverseOfHomomorphism
‣ LeftInverseOfHomomorphism( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: false if the homomorphism f is not a splittable epimorphism, otherwise it returns a splitting of the split epimorphism f.

7.2-19 MatricesOfPathAlgebraMatModuleHomomorphism
‣ MatricesOfPathAlgebraMatModuleHomomorphism( f )( operation )

Arguments: f - a homomorphism between two modules.

Returns: the matrices defining the homomorphism f.

gap> MatricesOfPathAlgebraMatModuleHomomorphism(f);
[ [ [ 0, 0, 0 ] ], [ [ 1, 0 ] ], [ [ 1, 2 ] ] ]
gap> Range(f);
<[ 3, 2, 2 ]>
gap> Source(f);
<[ 0, 1, 1 ]>
gap> Source(f) = L;
true 

7.2-20 PathAlgebraOfMatModuleMap
‣ PathAlgebraOfMatModuleMap( f )( attribute )

Arguments: f -- a homomorphism between two path algebra modules (PathAlgebraMatModule).

Returns: the algebra over which the range and the source of the homomorphism f is defined.

7.2-21 PreImagesRepresentative
‣ PreImagesRepresentative( f, elem )( operation )

Arguments: f - a homomorphism between two modules, elem - an element in the range of f.

Returns: a preimage of the element elem in the range (or codomain) the homomorphism f if a preimage exists, otherwise it returns fail.

The function checks if elem is an element in the range of f and returns an error message if not.

7.2-22 Range
‣ Range( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the range (or codomain) the homomorphism f.

7.2-23 RightInverseOfHomomorphism
‣ RightInverseOfHomomorphism( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: false if the homomorphism f is not a splittable monomorphism, otherwise it returns a splitting of the split monomorphism f.

7.2-24 Source
‣ Source( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the source (or domain) the homomorphism f.

7.2-25 Zero
‣ Zero( f )( operation )

Arguments: f - a homomorphism between two modules.

Returns: the zero map between Source(f) and Range(f).

7.2-26 ZeroMapping
‣ ZeroMapping( M, N )( operation )

Arguments: M, N - two modules.

Returns: the zero map between M and N.

7.2-27 HomomorphismFromImages
‣ HomomorphismFromImages( M, N, genImages )( operation )

Arguments: M, N -- two modules, genImages -- a list.

Returns: A map f between M and N, given by genImages.

Let B be the basis BasisVectors( Basis( M ) ) of M. Then the number of elements of genImages should be equal to the number of elements of B, and genImages[i] is an element of N and the image of B[i] under f. The method fails if f is not a homomorphism, or if B[i] and genImages[i] are supported in different vertices.

7.3 Homomorphisms and modules constructed from homomorphisms and modules

7.3-1 CoKernel
‣ CoKernel( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the cokernel of a homomorphism f between two modules.

This function returns the cokernel of the homomorphism f as a module.

7.3-2 CoKernelProjection
‣ CoKernelProjection( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the cokernel of a homomorphism f between two modules.

This function returns the cokernel of the homomorphism f as the projection homomorphism from the range of the homomorphism f to the cokernel of the homomorphism f.

7.3-3 EndModuloProjOverAlgebra
‣ EndModuloProjOverAlgebra( M )( operation )

Arguments: M - a module.

Returns: the natural homomorphism from the endomorphism ring of M to the endomorphism ring of M modulo the ideal generated by those endomorphisms of M which factor through a projective module.

The operation returns an error message if the zero module is entered as an argument.

7.3-4 EndOfModuleAsQuiverAlgebra
‣ EndOfModuleAsQuiverAlgebra( M )( operation )

Arguments: M - a PathAlgebraMatModule.

Returns: a list of three elements, (i) the endomorphism ring of M, (ii) the adjacency matrix of the quiver of the endomorphism ring and (iii) the endomorphism ring as a quiver algebra.

Suppose M is a module over a quiver algebra over a field K. The function checks if the endomorphism ring of M is K-elementary (not necessary for it to be a quiver algebra, but this is a TODO improvement), and returns error message otherwise.

7.3-5 EndOverAlgebra
‣ EndOverAlgebra( M )( attribute )

Arguments: M - a module.

Returns: the endomorphism ring of M as a subalgebra of the direct sum of the full matrix rings of DimensionVector(M)[i] x DimensionVector(M)[i], where i runs over all vertices where DimensionVector(M)[i] is non-zero.

The endomorphism is an algebra with one, and one can apply for example RadicalOfAlgebra to find the radical of the endomorphism ring.

7.3-6 FromEndMToHomMM
‣ FromEndMToHomMM( f )( operation )

Arguments: f -- an element in EndOverAlgebra(M).

Returns: the homomorphism from M to M corresponding to the element f in the endomorphism ring EndOverAlgebra(M) of M.

7.3-7 FromHomMMToEndM
‣ FromHomMMToEndM( f )( operation )

Arguments: f -- an element in HomOverAlgebra(M,M).

Returns: the element f in the endomorphism ring EndOverAlgebra(M) of M corresponding to the the homomorphism from M to M given by f.

7.3-8 HomFactoringThroughProjOverAlgebra
‣ HomFactoringThroughProjOverAlgebra( M, N )( operation )

Arguments: M, N - two modules.

Returns: a basis for the vector space of homomorphisms from M to N which factors through a projective module.

The function checks if M and N are modules over the same algebra, and returns an error message otherwise.

7.3-9 HomFromProjective
‣ HomFromProjective( m, M )( operation )

Arguments: m, M - an element and a module.

Returns: the homomorphism from the indecomposable projective module defined by the support of the element m to the module M.

The function checks if m is an elememt in M and if the element m is supported in only one vertex. Otherwise it returns fail.

7.3-10 HomOverAlgebra
‣ HomOverAlgebra( M, N )( operation )

Arguments: M, N - two modules.

Returns: a basis for the vector space of homomorphisms from M to N.

The function checks if M and N are modules over the same algebra, and returns an error message and fail otherwise.

7.3-11 Image
‣ Image( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the image of a homomorphism f as a module.

7.3-12 ImageInclusion
‣ ImageInclusion( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the inclusion of the image of a homomorphism f into the range of f.

7.3-13 ImageProjection
‣ ImageProjection( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the projection from the source of f to the image of the homomorphism f.

7.3-14 ImageProjectionInclusion
‣ ImageProjectionInclusion( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: both the projection from the source of f to the image of the homomorphism f and the inclusion of the image of a homomorphism f into the range of f as a list of two elements (first the projection and then the inclusion).

7.3-15 IsomorphismOfModules
‣ IsomorphismOfModules( M, N )( operation )

Arguments: M, N - two PathAlgebraMatModules.

Returns: false if M and N are two non-isomorphic modules, otherwise it returns an isomorphism from M to N.

The function checks if M and N are modules over the same algebra, and returns an error message otherwise.

7.3-16 Kernel
‣ Kernel( f )( attribute )
‣ KernelInclusion( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the kernel of a homomorphism f between two modules.

The first variant Kernel returns the kernel of the homomorphism f as a module, while the latter one returns the inclusion homomorphism of the kernel into the source of the homomorphism f.

gap> hom := HomOverAlgebra(N,N);
[ <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
    , <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
    , <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
    , <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
    , <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
     ]
gap> g := hom[1];
<<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>

gap> M := CoKernel(g);
<[ 2, 2, 2 ]>
gap> f := CoKernelProjection(g);
<<[ 3, 2, 2 ]> ---> <[ 2, 2, 2 ]>>

gap> Range(f) = M;
true
gap> endo := EndOverAlgebra(N);
<algebra-with-one of dimension 5 over Rationals>
gap> RadicalOfAlgebra(endo);
<algebra of dimension 3 over Rationals>
gap> B := BasisVectors(Basis(N));
[ [ [ 1, 0, 0 ], [ 0, 0 ], [ 0, 0 ] ], 
  [ [ 0, 1, 0 ], [ 0, 0 ], [ 0, 0 ] ], 
  [ [ 0, 0, 1 ], [ 0, 0 ], [ 0, 0 ] ], 
  [ [ 0, 0, 0 ], [ 1, 0 ], [ 0, 0 ] ], 
  [ [ 0, 0, 0 ], [ 0, 1 ], [ 0, 0 ] ], 
  [ [ 0, 0, 0 ], [ 0, 0 ], [ 1, 0 ] ], 
  [ [ 0, 0, 0 ], [ 0, 0 ], [ 0, 1 ] ] ]
gap> p := HomFromProjective(B[1],N);
<<[ 1, 4, 3 ]> ---> <[ 3, 2, 2 ]>>

gap> U := Image(p);
<[ 1, 2, 2 ]>
gap> projinc := ImageProjectionInclusion(p);
[ <<[ 1, 4, 3 ]> ---> <[ 1, 2, 2 ]>>
    , <<[ 1, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
     ]
gap> U = Range(projinc[1]);                                      
true
gap> Kernel(p);
<[ 0, 2, 1 ]> 

7.3-17 LeftMinimalVersion
‣ LeftMinimalVersion( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the left minimal version f' of the homomorphism f together with the a list B of modules such that the direct sum of the modules, Range(f') and the modules in the list B is isomorphic to Range(f).

7.3-18 RightMinimalVersion
‣ RightMinimalVersion( f )( attribute )

Arguments: f - a homomorphism between two modules.

Returns: the right minimal version f' of the homomorphism f together with the a list B of modules such that the direct sum of the modules, Source(f') and the modules on the list B is isomorphic to Source(f).

gap> H:= HomOverAlgebra(N,N);;
gap> RightMinimalVersion(H[1]);   
[ <<[ 1, 0, 0 ]> ---> <[ 3, 2, 2 ]>>
    , [ <[ 2, 2, 2 ]> ] ]
gap> LeftMinimalVersion(H[1]);             
[ <<[ 3, 2, 2 ]> ---> <[ 1, 0, 0 ]>>
    , [ <[ 2, 2, 2 ]> ] ]
gap> S := SimpleModules(A)[1];;
gap> MinimalRightApproximation(N,S);
<<[ 1, 0, 0 ]> ---> <[ 1, 0, 0 ]>>

gap> S := SimpleModules(A)[3];;
gap> MinimalLeftApproximation(S,N);   
<<[ 0, 0, 1 ]> ---> <[ 2, 2, 2 ]>> 

7.3-19 RadicalOfModuleInclusion
‣ RadicalOfModuleInclusion( M )( attribute )

Arguments: M - a module.

Returns: the inclusion of the radical of the module M into M.

The radical of M can be accessed using Source, or it can be computed directly via the command RadicalOfModule (6.4-33). If the algebra over which M is a module is not a finite dimensional path algebra or an admissible quotient of a path algebra, then it will search for other methods.

7.3-20 RejectOfModule
‣ RejectOfModule( M, N )( operation )

Arguments: N, M -- two path algebra modules (PathAlgebraMatModule).

Returns: the reject of the module M in the module N as an inclusion homomorhpism from the reject of M into N.

7.3-21 SocleOfModuleInclusion
‣ SocleOfModuleInclusion( M )( operation )

Arguments: M - a module.

Returns: the inclusion of the socle of the module M into M.

The socle of M can be accessed using Source, or it can be computed directly via the command SocleOfModule (6.4-36).

7.3-22 SubRepresentationInclusion
‣ SubRepresentationInclusion( M, gens )( operation )

Arguments: M - a module, gens - a list of elements in M.

Returns: the inclusion of the submodule generated by the generators gens into the module M.

The function checks if gens consists of elements in M, and returns an error message otherwise. The module given by the submodule generated by the generators gens can be accessed using Source.

7.3-23 TopOfModuleProjection
‣ TopOfModuleProjection( M )( operation )

Arguments: M - a module.

Returns: the projection from the module M to the top of the module M.

The module given by the top of the module M can be accessed using Range of the homomorphism.

gap> f := RadicalOfModuleInclusion(N);
<<[ 0, 2, 2 ]> ---> <[ 3, 2, 2 ]>>

gap> radN := Source(f);
<[ 0, 2, 2 ]>
gap> g := SocleOfModuleInclusion(N);
<<[ 1, 0, 2 ]> ---> <[ 3, 2, 2 ]>>

gap> U := SubRepresentationInclusion(N,[B[5]+B[6],B[7]]);
<<[ 0, 2, 2 ]> ---> <[ 3, 2, 2 ]>>

gap> h := TopOfModuleProjection(N);
<<[ 3, 2, 2 ]> ---> <[ 3, 0, 0 ]>> 

7.3-24 TraceOfModule
‣ TraceOfModule( M, N )( operation )

Arguments: M, C -- two path algebra modules (PathAlgebraMatModule).

Returns: the trace of the module M in the module N as an inclusion homomorhpism from the trace of M to N.

 [Top of Book]  [Contents]   [Previous Chapter]   [Next Chapter] 
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind

generated by GAPDoc2HTML