GAP (QPA) - Chapter 7: Homomorphisms of Right Modules over Path Algebras

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]

[MathJax on]

7 Homomorphisms of Right Modules over Path Algebras
7.1 Categories and representation of homomorphisms
7.1-1 IsPathAlgebraModuleHomomorphism
7.1-2 RightModuleHomOverAlgebra
7.2 Generalities of homomorphisms
`7.2-1 \= (maps)`
`7.2-2 \+ (maps)`
`7.2-3 \* (maps)`
7.2-4 CoKernelOfWhat
7.2-5 IdentityMapping
7.2-6 ImageElm
7.2-7 ImagesSet
7.2-8 ImageOfWhat
7.2-9 IsInjective
7.2-10 IsIsomorphism
7.2-11 IsLeftMinimal
7.2-12 IsRightMinimal
7.2-13 IsSplitEpimorphism
7.2-14 IsSplitMonomorphism
7.2-15 IsSurjective
7.2-16 IsZero
7.2-17 KernelOfWhat
7.2-18 LeftInverseOfHomomorphism
7.2-19 MatricesOfPathAlgebraMatModuleHomomorphism
7.2-20 PathAlgebraOfMatModuleMap
7.2-21 PreImagesRepresentative
7.2-22 Range
7.2-23 RightInverseOfHomomorphism
7.2-24 Source
7.2-25 Zero
7.2-26 ZeroMapping
7.2-27 HomomorphismFromImages
7.3 Homomorphisms and modules constructed from homomorphisms and modules
7.3-1 AllIndecModulesOfLengthAtMost
7.3-2 AllModulesOfLengthAtMost
7.3-3 AllSimpleSubmodulesOfModule
7.3-4 AllSubmodulesOfModule
7.3-5 CoKernel
7.3-6 CoKernelProjection
7.3-7 EndModuloProjOverAlgebra
7.3-8 EndOfModuleAsQuiverAlgebra
7.3-9 EndOverAlgebra
7.3-10 FromEndMToHomMM
7.3-11 FromHomMMToEndM
7.3-12 HomFactoringThroughProjOverAlgebra
7.3-13 HomFromProjective
7.3-14 HomOverAlgebra
7.3-15 Image
7.3-16 ImageInclusion
7.3-17 ImageProjection
7.3-18 ImageProjectionInclusion
7.3-19 IsomorphismOfModules
7.3-20 Kernel
7.3-21 LeftMinimalVersion
7.3-22 MatrixOfHomomorphismBetweenProjectives
7.3-23 RightMinimalVersion
7.3-24 RadicalOfModuleInclusion
7.3-25 RejectOfModule
7.3-26 SocleOfModuleInclusion
7.3-27 SubRepresentationInclusion
7.3-28 TopOfModuleProjection
7.3-29 TraceOfModule

### 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 AllIndecModulesOfLengthAtMost

`‣ AllIndecModulesOfLengthAtMost`( A, n ) | ( operation )

Arguments: A, n - an algebra over a finite field, an integer.

Returns: all the different indecomposable modules over the algebra A of length at most n.

This function is only implemented for algebras over a finite field.

##### 7.3-2 AllModulesOfLengthAtMost

`‣ AllModulesOfLengthAtMost`( A, n ) | ( operation )

Arguments: A, n - an algebra over a finite field, an integer.

Returns: all the different modules over the algebra A of length at most n.

This function is only implemented for algebras over a finite field.

##### 7.3-3 AllSimpleSubmodulesOfModule

`‣ AllSimpleSubmodulesOfModule`( M ) | ( operation )

Arguments: M - a module.

Returns: all the different simple submodules of a module given as inclusions into the module M.

This function is only implemented for algebras over a finite field.

##### 7.3-4 AllSubmodulesOfModule

`‣ AllSubmodulesOfModule`( M ) | ( operation )

Arguments: M - a module.

Returns: all the different submodules of a module given as inclusions into the module M. It returns the list of submodules as a list of lists according to the length of the submodules, namely, first a list of the zero module, second a list of all simple submodules, third a list of all submodules of length 2, and so on.

This function is only implemented for algebras over a finite field.

##### 7.3-5 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-6 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-7 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-8 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-9 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-10 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-11 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-12 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-13 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-14 HomOverAlgebra

`‣ HomOverAlgebra`( M, N ) | ( operation )

`‣ HomOverAlgebraWithBasisFunction`( M, N ) | ( operation )

Arguments: M, N - two modules.

Returns: a basis for the vector space of homomorphisms from M to N in the first version. In the second version it also returns a list of length two, where the first entry is the basis found by `HomOverAlgebra` and the second entry is a function from the space of homomorphisms from M to N to the vector space with the basis given by the first entry.

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

##### 7.3-15 Image

`‣ Image`( f ) | ( attribute )

Arguments: f - a homomorphism between two modules.

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

##### 7.3-16 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-17 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-18 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-19 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-20 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-21 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-22 MatrixOfHomomorphismBetweenProjectives

`‣ MatrixOfHomomorphismBetweenProjectives`( f ) | ( operation )

Arguments: f -- a homomorphism between two projective modules.

Returns: for a homomorphism f of projective A-modules from P = ⊕ v_iA to P' = ⊕ w_iA, where v_i and w_i are vertices, the homomorphism as a matrix in ⊕ v_iAw_i.

##### 7.3-23 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-24 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-37). 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-25 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-26 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-40).

##### 7.3-27 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-28 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-29 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