GAP (QPA) - Chapter 6: 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 off]

6 Right Modules over Path Algebras
6.1 Modules of matrix type
6.1-1 RightModuleOverPathAlgebra
6.1-2 RightAlgebraModuleToPathAlgebraMatModule
`6.1-3 \=`
6.2 Categories Of Matrix Modules
6.2-1 IsPathAlgebraMatModule
6.3 Acting on Module Elements
6.3-1 ^
6.4 Operations on representations
6.4-1 AnnihilatorOfModule
6.4-2 BasicVersionOfModule
6.4-3 BlockDecompositionOfModule
6.4-4 BlockSplittingIdempotents
6.4-5 CommonDirectSummand
6.4-6 ComplexityOfModule
6.4-7 DecomposeModule
6.4-8 DecomposeModuleProbabilistic
6.4-9 DecomposeModuleViaCharPoly
6.4-10 DecomposeModuleViaTop
6.4-11 DecomposeModuleWithMultiplicities
6.4-12 Dimension
6.4-13 DimensionVector
6.4-14 DirectSumOfQPAModules
6.4-15 DirectSumInclusions
6.4-16 DirectSumProjections
6.4-17 FromIdentityToDoubleStarHomomorphism
6.4-18 IntersectionOfSubmodules
6.4-19 IsDirectSummand
6.4-20 IsDirectSumOfModules
6.4-21 IsExceptionalModule
6.4-22 IsIndecomposableModule
6.4-23 IsInAdditiveClosure
6.4-24 IsInjectiveModule
6.4-25 IsomorphicModules
6.4-26 IsProjectiveModule
6.4-27 IsRigidModule
6.4-28 IsSemisimpleModule
6.4-29 IsSimpleQPAModule
6.4-30 IsTauRigidModule
6.4-31 LoewyLength
6.4-32 IsZero
6.4-33 MatricesOfPathAlgebraModule
6.4-34 MaximalCommonDirectSummand
6.4-35 NumberOfNonIsoDirSummands
6.4-36 MinimalGeneratingSetOfModule
6.4-37 RadicalOfModule
6.4-38 RadicalSeries
6.4-39 SocleSeries
6.4-40 SocleOfModule
6.4-41 SubRepresentation
6.4-42 SumOfSubmodules
6.4-43 SupportModuleElement
6.4-44 TopOfModule
6.5 Special representations
6.5-1 BasisOfProjectives
6.5-2 ElementInIndecProjective
6.5-3 IndecInjectiveModules
6.5-4 IndecProjectiveModules
6.5-5 SimpleModules
6.5-6 ZeroModule
6.6 Functors on representations
6.6-1 DualOfModule
6.6-2 DualOfModuleHomomorphism
6.6-3 DTr
6.6-4 DTr
6.6-5 NakayamaFunctorOfModule
6.6-6 NakayamaFunctorOfModuleHomomorphism
6.6-7 OppositeNakayamaFunctorOfModule
6.6-8 OppositeNakayamaFunctorOfModuleHomomorphism
6.6-9 RestrictionViaAlgebraHomomorphism
6.6-10 RestrictionViaAlgebraHomomorphismMap
6.6-11 StarOfModule
6.6-12 StarOfModuleHomomorphism
6.6-13 TensorProductOfModules
6.6-14 TrD
6.6-15 TrD
6.6-16 TransposeOfModule
6.6-17 TransposeOfModuleHomomorphism
6.7 Vertex projective modules and submodules thereof
6.7-1 RightProjectiveModule
6.7-2 CompletelyReduceGroebnerBasisForModule
6.7-3 IsLeftDivisible
6.7-4 IsPathAlgebraModule
6.7-5 IsPathAlgebraVector
6.7-6 LeadingCoefficient (of PathAlgebraVector)
6.7-7 LeadingComponent
6.7-8 LeadingPosition
6.7-9 LeadingTerm (of PathAlgebraVector)
6.7-10 LeftDivision
6.7-11 ^
6.7-12 <
6.7-13 /
6.7-14 PathAlgebraVector
6.7-15 ProjectivePathAlgebraPresentation
6.7-16 RightGroebnerBasisOfModule
6.7-17 TargetVertex
6.7-18 UniformGeneratorsOfModule
6.7-19 Vectorize

### 6 Right Modules over Path Algebras

There are two implementations of right modules over path algebras. The first type are matrix modules that are defined by vector spaces and linear transformations. The second type is presentations defined by vertex projective modules (see 6.7).

#### 6.1 Modules of matrix type

The first implementation of right modules over path algebras views them as a collection of vector spaces and linear transformations. Each vertex in the path algebra is associated with a vector space over the field of the algebra. For each vertex \(v\) of the algebra there is a vector space \(V\). Arrows of the algebra are then associated with linear transformations which map the vector space of the source vertex to the vector space of the target vertex. For example, if \(a\) is an arrow from \(v\) to \(w\), then there is a transformation from vector space \(V\) to \(W\). Given the dimension vector of the module we want to construct, the information we need to provide is the non-zero linear transformations. The size of the matrices for the zero linear transformation are given when we know the dimension vector. Alternatively, if we enter all the transformations, we can create the vector spaces of the correct dimension, and check to make sure the dimensions all agree. We can create a module in this way as follows.

##### 6.1-1 RightModuleOverPathAlgebra

`‣ RightModuleOverPathAlgebra`( A, dim_vector, gens ) | ( operation )

`‣ RightModuleOverPathAlgebra`( A, mats ) | ( operation )

`‣ RightModuleOverPathAlgebraNC`( A, mats ) | ( operation )

Arguments: A -- a (quotient of a) path algebra and dim_vector -- the dimension vector of the module, gens or mats -- a list of matrices. For further explanations, see below.

Returns: a module over a path algebra or over a qoutient of a path algebra.

In the first function call, the second argument dim_vector is the dimension vector of the module, and the last argument gens (maybe an empty list `[]`) is a list of elements of the form `["label",matrix]`. This function constructs a right module over a (quotient of a) path algebra A with dimension vector dim_vector, and where the generators/arrows with a non-zero action is given in the list gens. The format of the list gens is [["a",[matrix_a]],["b",[matrix_b]],...], where "a" and "b" are labels of arrows used when the underlying quiver was created and matrix_? is the action of the algebra element corresponding to the arrow with label "?". The action of the arrows can be entered in any order. The function checks (i) if the algebra A is a (quotient of a) path algebra, (ii) if the matrices of the action of the arrows have the correct size according to the dimension vector entered, (iii) also whether or not the relations of the algebra are satisfied and (iv) if all matrices are over the correct field.

In the second function call, the list of matrices mats can take on three different forms. The function checks (i), (ii), (iii) and (iv) as above.

1) The argument mats can be a list of blocks of matrices where each block is of the form, `["name of arrow",matrix]'. So if you named your arrows when you created the quiver, then you can associate a matrix with that arrow explicitly.

2) The argument mats is just a list of matrices, and the matrices will be associated to the arrows in the order of arrow creation. If when creating the quiver, the arrow \(a\) was created first, then \(a\) would be associated with the first matrix.

3) The method is very much the same as the second method. If arrows is a list of the arrows of the quiver (obtained for instance through `arrows := ArrowsOfQuiver(Q);`), the argument mats can have the format `[[arrows[1],matrix_1],[arrows[2],matrix_2],.... ].`

If you would like the trivial vector space at any vertex, then for each incoming arrow "a", associate it with a list of the form `["a",[n,0]]` where n is the dimension of the vector space at the source vertex of the arrow. Likewise for all outgoing arrows "b", associate them to a block of form `["b",[0,n]]` where n is the dimension of the vector space at the target vertex of the arrow.

The third function call is the same as the second except that the check (iv) is not performed.

A warning though, the function assumes that you do not mix the styles of inputting the matrices/linear transformations associated to the arrows in the quiver. Furthermore in the two last versions, each arrow needs to be assigned a matrix, otherwise an error will be returned.

##### 6.1-2 RightAlgebraModuleToPathAlgebraMatModule

`‣ RightAlgebraModuleToPathAlgebraMatModule`( M ) | ( operation )

Arguments: M -- a right module over an algebra.

Returns: a module over a (qoutient of a) path algebra.

This function constructs a right module over a (quotient of a) path algebra \(A\) from a RightAlgebraModule over the same algebra \(A\). The function checks if \(A\) actually is a quotient of a path algebra and if the module \(M\) is finite dimensional and if not, it returns an error message.

##### `6.1-3 \=`

`‣ \=`( M, N ) | ( operation )

Arguments: M, N -- two path algebra matrix modules.

Returns: true if M and N has the same dimension vectors and the same matrices defining the module structure.

    gap> Q := Quiver(2, [[1, 2, "a"], [2, 1, "b"],[1, 1, "c"]]);
    <quiver with 2 vertices and 3 arrows>
    gap> P := PathAlgebra(Rationals, Q);
    <Rationals[<quiver with 2 vertices and 3 arrows>]>
    gap> matrices := [["a", [[1,0,0],[0,1,0]]],
    >  ["b", [[0,1],[1,0],[0,1]]],
    >  ["c", [[0,0],[1,0]]]];
    [ [ "a", [ [ 1, 0, 0 ], [ 0, 1, 0 ] ] ],
      [ "b", [ [ 0, 1 ], [ 1, 0 ], [ 0, 1 ] ] ],
      [ "c", [ [ 0, 0 ], [ 1, 0 ] ] ] ]
    gap> M := RightModuleOverPathAlgebra(P,matrices);
    <[ 2, 3 ]>
    gap> mats := [ [[1,0,0], [0,1,0]], [[0,1],[1,0],[0,1]],
    >           [[0,0],[1,0]] ];;
    gap> N := RightModuleOverPathAlgebra(P,mats);
    <[ 2, 3 ]>
    gap> arrows := ArrowsOfQuiver(Q);
    [ a, b, c ]
    gap> mats := [[arrows[1], [[1,0,0],[0,1,0]]],
    >          [arrows[2], [[0,1],[1,0],[0,1]]],
    >          [arrows[3], [[0,0],[1,0]]]];;
    gap> N := RightModuleOverPathAlgebra(P,mats);
    <[ 2, 3 ]>
    gap> # Next we give the vertex simple associate to vertex 1.
    gap> M := RightModuleOverPathAlgebra(P,[["a",[1,0]],["b",[0,1]],
    >              ["c",[[0]]]]);
    <[ 1, 0 ]>
    gap> # The zero module.
    gap> M := RightModuleOverPathAlgebra(P,[["a",[0,0]],["b",[0,0]],
    >              ["c",[0,0]]]);
    <[ 0, 0 ]>
    gap> Dimension(M);
    0
    gap> Basis(M);
    Basis( <[ 0, 0 ]>, ... )
    gap> matrices := [["a", [[1,0,0],[0,1,0]]], ["b",
    >  [[0,1],[1,0],[0,1]]], ["c", [[0,0],[1,0]]]];
    [ [ "a", [ [ 1, 0, 0 ], [ 0, 1, 0 ] ] ],
      [ "b", [ [ 0, 1 ], [ 1, 0 ], [ 0, 1 ] ] ],
      [ "c", [ [ 0, 0 ], [ 1, 0 ] ] ] ]
    gap> M := RightModuleOverPathAlgebra(P,[2,3],matrices);
    <[ 2, 3 ]>
    gap> M := RightModuleOverPathAlgebra(P,[2,3],[]);
    <[ 2, 3 ]>
    gap> A := P/[P.c^2 - P.a*P.b, P.a*P.b*P.c, P.b*P.c];
    <Rationals[<quiver with 2 vertices and 3 arrows>]/
    <two-sided ideal in <Rationals[<quiver with 2 vertices and 3 arrows>]>
        , (4 generators)>>
    gap> Dimension(A);
    9
    gap> Amod := RightAlgebraModule(A,\*,A);
    <9-dimensional right-module over <Rationals[<quiver with
    2 vertices and 3 arrows>]/
    <two-sided ideal in <Rationals[<quiver with 2 vertices and 3 arrows>]>
        , (4 generators)>>>
    gap> RightAlgebraModuleToPathAlgebraMatModule(Amod);
    <[ 4, 5 ]>

#### 6.2 Categories Of Matrix Modules

##### 6.2-1 IsPathAlgebraMatModule

`‣ IsPathAlgebraMatModule`( object ) | ( filter )

Returns: true or false depending on whether object belongs to the category `IsPathAlgebraMatModule`.

These matrix modules fall under the category `IsAlgebraModule' with the added filter of `IsPathAlgebraMatModule'. Operations available for algebra modules can be applied to path algebra modules. See Reference: Representations of Algebras for more details. These modules are also vector spaces over the field of the path algebra. So refer to Reference: Vector Spaces for descriptions of the basis and elementwise operations available.

#### 6.3 Acting on Module Elements

##### 6.3-1 ^

`‣ ^`( m, p ) | ( operation )

Arguments: m -- an element in a module, p -- an element in a quiver algebra.

Returns: the element m multiplied with p.

When you act on an module element \(m\) by an arrow \(a\) from \(v\) to \(w\), the component of \(m\) from \(V\) is acted on by \(L\) the transformation associated to \(a\) and placed in the component \(W\). All other components are given the value \(0\).

    gap> # Using the path algebra P from the above example.
    gap> matrices := [["a", [[1,0,0],[0,1,0]]],
    > ["b", [[0,1],[1,0],[0,1]]], ["c", [[0,0],[1,0]]]];
    [ [ "a", [ [ 1, 0, 0 ], [ 0, 1, 0 ] ] ],
      [ "b", [ [ 0, 1 ], [ 1, 0 ], [ 0, 1 ] ] ],
      [ "c", [ [ 0, 0 ], [ 1, 0 ] ] ] ]
    gap> M := RightModuleOverPathAlgebra(P,matrices);
    <[ 2, 3 ]>
    gap> B:=BasisVectors(Basis(M));
    [ [ [ 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 ] ] ]
    gap> B[1] + B[3];
    [ [ 1, 0 ], [ 1, 0, 0 ] ]
    gap> 4*B[2];
    [ [ 0, 4 ], [ 0, 0, 0 ] ]
    gap> m := 5*B[1] + 2*B[4]+B[5];
    [ [ 5, 0 ], [ 0, 2, 1 ] ]
    gap> m^(P.a*P.b-P.c);
    [ [ 0, 5 ], [ 0, 0, 0 ] ]
    gap> B[1]^P.a;
    [ [ 0, 0 ], [ 1, 0, 0 ] ]
    gap> B[2]^P.b;
    [ [ 0, 0 ], [ 0, 0, 0 ] ]
    gap> B[4]^(P.b*P.c);
    [ [ 0, 0 ], [ 0, 0, 0 ] ]

#### 6.4 Operations on representations

    gap> Q  := Quiver(3,[[1,2,"a"],[1,2,"b"],[2,2,"c"],[2,3,"d"],
    > [3,1,"e"]]);
    <quiver with 3 vertices and 5 arrows>
    gap> KQ := PathAlgebra(Rationals, Q);
    <Rationals[<quiver with 3 vertices and 5 arrows>]>
    gap> gens := GeneratorsOfAlgebra(KQ);
    [ (1)*v1, (1)*v2, (1)*v3, (1)*a, (1)*b, (1)*c, (1)*d, (1)*e ]
    gap> u := gens[1];; v := gens[2];;
    gap> w := gens[3];; a := gens[4];;
    gap> b := gens[5];; c := gens[6];;
    gap> d := gens[7];; e := gens[8];;
    gap> rels := [d*e,c^2,a*c*d-b*d,e*a];;
    gap> A := KQ/rels;
    <Rationals[<quiver with 3 vertices and 5 arrows>]/
    <two-sided ideal in <Rationals[<quiver with 3 vertices and 5 arrows>]>
        , (5 generators)>>
    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);
    <[ 3, 2, 2 ]>

##### 6.4-1 AnnihilatorOfModule

`‣ AnnihilatorOfModule`( M ) | ( operation )

Arguments: M -- a path algebra module.

Returns: a basis of the annihilator of the module M in the finite dimensional algebra over which M is a module.

##### 6.4-2 BasicVersionOfModule

`‣ BasicVersionOfModule`( M ) | ( operation )

Arguments: M -- a path algebra module.

Returns: a basic version of the entered module M, that is, if \(M \simeq M_1^{n_1} \oplus \cdots \oplus M_t^{n_t},\) where \(M_i\) is indecomposable, then \(M_1\oplus \cdots \oplus M_t\) is returned. At present, this function only work at best for finite dimensional (quotients of a) path algebra over a finite field. If M is zero, then M is returned.

##### 6.4-3 BlockDecompositionOfModule

`‣ BlockDecompositionOfModule`( M ) | ( operation )

Arguments: M -- a path algebra module.

Returns: a set of modules \(\{M_1,..., M_t\}\) such that \(M \simeq M_1\oplus \cdots \oplus M_t,\) where each \(M_i\) is isomorphic to \(X_i^{n_i}\) for some indecomposable module \(X_i\) and positive integer \(n_i\) for all \(i\), where \(X_i\not\simeq X_j\) for \(i\neq j\).

##### 6.4-4 BlockSplittingIdempotents

`‣ BlockSplittingIdempotents`( M ) | ( operation )

Arguments: M -- a path algebra module.

Returns: a set \(\{e_1,..., e_t\}\) of idempotents in the endomorphism of M such that \(M \simeq \Im e_1\oplus \cdots \oplus \Im e_t,\) where each \(\Im e_i\) is isomorphic to \(X_i^{n_i}\) for some module \(X_i\) and positive integer \(n_i\) for all \(i\).

##### 6.4-5 CommonDirectSummand

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

Arguments: M and N -- two path algebra modules.

Returns: a list of four modules [X,U,X, V], where X is one common non-zero direct summand of M and N, the sum of X and U is M and the sum of X and V is N, if such a non-zero direct summand exists. Otherwise it returns false.

The function checks if M and N are `PathAlgebraMatModule`s over the same (quotient of a) path algebra.

##### 6.4-6 ComplexityOfModule

`‣ ComplexityOfModule`( M, n ) | ( operation )

Arguments: M -- path algebdra module, n -- a positive integer.

Returns: an estimate of the complexity of the module M.

The function checks if the algebra over which the module M lives is known to have finite global dimension. If so, it returns complexity zero. Otherwise it tries to estimate the complexity in the following way. Recall that if a function \(f(x)\) is a polynomial in \(x\), the degree of \(f(x)\) is given by \(\lim_{n\to\infty} \frac{\log |f(n)|}{\log n}\). So then this function computes an estimate of the complexity of M by approximating the complexity by considering the limit \(\lim_{m\to \infty} \log \frac{\dim(P(M)(m))}{\log m}\) where \(P(M)(m)\) is the \(m\)-th projective in a minimal projective resolution of M at stage \(m\). This limit is estimated by \(\frac{\log \dim(P(M)(n))}{\log n}\).

##### 6.4-7 DecomposeModule

`‣ DecomposeModule`( M ) | ( operation )

`‣ DecomposeModuleWithInclusions`( M ) | ( operation )

Arguments: M -- a path algebra module.

Returns: a list of indecomposable modules whose direct sum is isomorphic to the module M in first variant. The second variant returns a list of inclusions into M with the sum of the images is isomorphic to the module M.

Warning: the function is not properly tested and it at best only works properly over finite fields.

##### 6.4-8 DecomposeModuleProbabilistic

`‣ DecomposeModuleProbabilistic`( HomMM, M ) | ( operation )

Arguments: HomMM, M -- a list of basis elements of the Hom-space of the entered module and a path algebra module.

Returns: with (hopefully high probability) a list of indecomposable modules whose direct sum is isomorphic to the module M.

Given a module M over a finite dimensional quotient of a path algebra over a finite field, this function tries to decompose the entered module M by choosing random elements in the endomorphism ring of M which are non-nilpotent and non-invertible. Such elements splits the module in two direct summands, and the procedure does this as long as it finds such elements. The output is not guaranteed to be a list of indecomposable modules, but their direct sum is isomorphic to the entered module M. This was constructed as joint effort by the participants at the workshop "Persistence, Representations, and Computation", February 26th - March 2nd, 2018". This is an experimental function, so use with caution.

##### 6.4-9 DecomposeModuleViaCharPoly

`‣ DecomposeModuleViaCharPoly`( M ) | ( operation )

Arguments: M -- a path algebra module.

Returns: a list with high probability of indecomposable modules whose direct sum is isomorphic to the module M.

Given a module M over a finite dimensional quotient of a path algebra over a finite field, this function decomposes the entered module M by computing the endomorphism ring of M and choosing random elements in it. This is an experimental function, so use with caution.

##### 6.4-10 DecomposeModuleViaTop

`‣ DecomposeModuleViaTop`( M ) | ( operation )

Arguments: M -- a path algebra module.

Returns: a list of indecomposable modules whose direct sum is isomorphic to the module M.

Given a module M over a finite dimensional quotient of a path algebra over a finite field, this function decomposes the entered module M by finding the image \(\Sigma\) of the endomorphism ring of M in the endomorphism ring of the top of M, in \(\Sigma\) finds a complete set of primitive idempotents, lifts them back to the endomorphism ring of M and decomposes M. This is an experimental function, so use with caution.

##### 6.4-11 DecomposeModuleWithMultiplicities

`‣ DecomposeModuleWithMultiplicities`( M ) | ( operation )

Arguments: M -- a path algebra module.

Returns: a list of length two, where the first entry is a list of all indecomposable non-isomorphic direct summands of M and the second entry is the list of the multiplicities of these direct summand in the module M.

Warning: the function is not properly tested and it at best only works properly over finite fields.

##### 6.4-12 Dimension

`‣ Dimension`( M ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the dimension of the representation M.

##### 6.4-13 DimensionVector

`‣ DimensionVector`( M ) | ( attribute )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the dimension vector of the representation M.

##### 6.4-14 DirectSumOfQPAModules

`‣ DirectSumOfQPAModules`( L ) | ( operation )

Arguments: L -- a list of `PathAlgebraMatModule`s over the same (quotient of a) path algebra.

Returns: the direct sum of the representations contained in the list L.

In addition three attributes are attached to the result, `IsDirectSumOfModules` (6.4-20), `DirectSumProjections` (6.4-16) `DirectSumInclusions` (6.4-15).

##### 6.4-15 DirectSumInclusions

`‣ DirectSumInclusions`( M ) | ( attribute )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the list of inclusions from the individual modules to their direct sum, when a direct sum has been constructed using `DirectSumOfQPAModules` (6.4-14).

##### 6.4-16 DirectSumProjections

`‣ DirectSumProjections`( M ) | ( attribute )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the list of projections from the direct sum to the individual modules used to construct direct sum, when a direct sum has been constructed using `DirectSumOfQPAModules` (6.4-14).

##### 6.4-17 FromIdentityToDoubleStarHomomorphism

`‣ FromIdentityToDoubleStarHomomorphism`( M ) | ( attribute )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the homomorphism from M to the double star of the module M.

##### 6.4-18 IntersectionOfSubmodules

`‣ IntersectionOfSubmodules`( list ) | ( operation )

Arguments: f, g or list -- two homomorphisms of PathAlgebraMatModules or a list of such.

Returns: the subrepresentation given by the intersection of all the submodules given by the inclusions f and g or list.

The function checks if list is non-empty and if \(\textit{f}\colon M\to X\) and \(\textit{g}\colon N\to X\) or all the homomorphism in list have the same range and if they all are inclusions. If the function is given two arguments f and g, then it returns \([f',g',g'*f]\), where \(f'\colon E\to N\), \(g'\colon E\to M\), and \(E\) is the pullback of f and g. For a list of inclusions it returns a monomorphism from a module isomorphic to the intersection to \(X\).

##### 6.4-19 IsDirectSummand

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

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

Returns: true if M is isomorphic to a direct summand of N, otherwise false.

The function checks if M and N are `PathAlgebraMatModule`s over the same (quotient of a) path algebra.

##### 6.4-20 IsDirectSumOfModules

`‣ IsDirectSumOfModules`( M ) | ( filter )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if M is constructed via the command `DirectSumOfQPAModules` (6.4-14).

Using the example above.

    gap> N2 := DirectSumOfQPAModules([N,N]);
    <[ 6, 4, 4 ]>
    gap> proj := DirectSumProjections(N2);
    [ <<[ 6, 4, 4 ]> ---> <[ 3, 2, 2 ]>>
        , <<[ 6, 4, 4 ]> ---> <[ 3, 2, 2 ]>>
         ]
    gap> inc := DirectSumInclusions(N2);
    [ <<[ 3, 2, 2 ]> ---> <[ 6, 4, 4 ]>>
        , <<[ 3, 2, 2 ]> ---> <[ 6, 4, 4 ]>>
         ]

##### 6.4-21 IsExceptionalModule

`‣ IsExceptionalModule`( M ) | ( property )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if M is an exceptional module, otherwise false, if the field, over which the algebra M is defined over, is finite.

The module M is an exceptional module, if it is indecomposable and \(\Ext^1(M,M)=(0)\).

##### 6.4-22 IsIndecomposableModule

`‣ IsIndecomposableModule`( M ) | ( property )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if M is an indecomposable module, if the field, over which the algebra M is defined over, is finite. If M is the zero module, then `false` is returned.

##### 6.4-23 IsInAdditiveClosure

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

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

Returns: true if M is in the additive closure of the module N, otherwise false.

The function checks if M and N are `PathAlgebraMatModule`s over the same (quotient of a) path algebra.

##### 6.4-24 IsInjectiveModule

`‣ IsInjectiveModule`( M ) | ( property )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if the representation M is injective.

##### 6.4-25 IsomorphicModules

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

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

Returns: true or false depending on whether M and N are isomorphic or not.

The function first checks if the modules M and N are modules over the same algebra, and returns fail if not. The function returns true if the modules are isomorphic, otherwise false.

##### 6.4-26 IsProjectiveModule

`‣ IsProjectiveModule`( M ) | ( property )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if the representation M is projective.

##### 6.4-27 IsRigidModule

`‣ IsRigidModule`( M ) | ( property )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if M is a rigid module, otherwise false.

The module M is a rigid module, if \(\Ext^1(M,M)=(0)\).

##### 6.4-28 IsSemisimpleModule

`‣ IsSemisimpleModule`( M ) | ( property )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if the representation M is semisimple.

##### 6.4-29 IsSimpleQPAModule

`‣ IsSimpleQPAModule`( M ) | ( property )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if the representation M is simple.

##### 6.4-30 IsTauRigidModule

`‣ IsTauRigidModule`( M ) | ( property )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if M is a \(\tau\)-rigid module, otherwise false.

The module M is a \(\tau\)-rigid module, if \(\Hom(M,\tau M)=(0)\).

##### 6.4-31 LoewyLength

`‣ LoewyLength`( M ) | ( attribute )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the Loewy length of the module M.

The function checks that the module M is a module over a finite dimensional quotient of a path algebra, and returns fail otherwise (This is not implemented yet).

##### 6.4-32 IsZero

`‣ IsZero`( M ) | ( property )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: true if M is the zero module, otherwise false.

##### 6.4-33 MatricesOfPathAlgebraModule

`‣ MatricesOfPathAlgebraModule`( M ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: a list of the matrices that defines the representation M as a right module of the acting path algebra.

The list of matrices that are returned are not the same identical to the matrices entered to define the representation if there is zero vector space in at least one vertex. Then zero matrices of the appropriate size are returned.

##### 6.4-34 MaximalCommonDirectSummand

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

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

Returns: a list of three modules [X,U,V], where X is a maximal common non-zero direct summand of M and N, the sum of X and U is M and the sum of X and V is N, if such a non-zero maximal direct summand exists. Otherwise it returns false.

The function checks if M and N are `PathAlgebraMatModule`s over the same (quotient of a) path algebra.

##### 6.4-35 NumberOfNonIsoDirSummands

`‣ NumberOfNonIsoDirSummands`( M ) | ( operation )

Arguments: M -- a path algebra modules (`PathAlgebraMatModule`s).

Returns: a list with two elements: (1) the number of non-isomorphic indecomposable direct summands of the module M and (2) the dimensions of the simple blocks of the semisimple ring \(\End(M)/\rad \End(M)\).

##### 6.4-36 MinimalGeneratingSetOfModule

`‣ MinimalGeneratingSetOfModule`( M ) | ( attribute )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: a minimal generator set of the module M as a module of the path algebra it is defined over.

##### 6.4-37 RadicalOfModule

`‣ RadicalOfModule`( M ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the radical of the module M.

This returns only the representation given by the radical of the module M. The operation `RadicalOfModuleInclusion` (7.3-24) computes the inclusion of the radical of M into M. This function applies when the algebra over which M is defined is an admissible quotient of a path algebra.

##### 6.4-38 RadicalSeries

`‣ RadicalSeries`( M ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the radical series of the module M.

The function gives the radical series as a list of vectors `[n_1,...,n_s]`, where the algebra has \(s\) isomorphism classes of simple modules and the numbers give the multiplicity of each simple. The first vector listed corresponds to the top layer, and so on.

##### 6.4-39 SocleSeries

`‣ SocleSeries`( M ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the socle series of the module M.

The function gives the socle series as a list of vectors `[n_1,...,n_s]`, where the algebra has \(s\) isomorphism classes of simple modules and the numbers give the multiplicity of each simple. The last vector listed corresponds to the socle layer, and so on backwards.

##### 6.4-40 SocleOfModule

`‣ SocleOfModule`( M ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the socle of the module M.

This operation only return the representation given by the socle of the module M. The inclusion the socle of M into M can be computed using `SocleOfModuleInclusion` (7.3-26).

##### 6.4-41 SubRepresentation

`‣ SubRepresentation`( M, gens ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`), gens -- elements in M.

Returns: the submodule of the module M generated by the elements gens.

The function checks if gens are elements in M, and returns an error message otherwise. The inclusion of the submodule generated by the elements gens into M can be computed using `SubRepresentationInclusion` (7.3-27).

##### 6.4-42 SumOfSubmodules

`‣ SumOfSubmodules`( list ) | ( operation )

Arguments: f, g or list -- two inclusions of PathAlgebraMatModules or a list of such.

Returns: the subrepresentation given by the sum of all the submodules given by the inclusions f, g or list.

The function checks if list is non-empty and if \(\textit{f}\colon M\to X\) and \(\textit{g}\colon N\to X\) or all the homomorphism in list have the same range and if they all are inclusions. If the function is given two arguments f and g, then it returns \([h,f',g']\), where \(h\colon M + N\to X\), \(f'\colon M\to M + N\) and \(g'\colon N\to M + N\). For a list of inclusions it returns a monomorphism from a module isomorphic to the sum of the subrepresentations to \(X\).

##### 6.4-43 SupportModuleElement

`‣ SupportModuleElement`( m ) | ( operation )

Arguments: m -- an element of a path algebra module.

Returns: the primitive idempotents v in the algebra over which the module containing the element m is a module, such that m^v is non-zero.

The function checks if m is an element in a module over a (quotient of a) path algebra, and returns fail otherwise.

##### 6.4-44 TopOfModule

`‣ TopOfModule`( M ) | ( operation )

Arguments: M or f -- a path algebra module or a homomorphism thereof.

Returns: the top of the module M or the homomorphism induced on the top of the modules associated to the homomorphism f.

This returns only the representation given by the top of the module M or the homomorphism induced on the top of the modules associated to the entered homomorphism. The operation `TopOfModuleProjection` (7.3-28) computes the projection of the module M onto the top of the module M.

#### 6.5 Special representations

Here we collect the predefined representations/modules over a finite dimensional quotient of a path algebra.

##### 6.5-1 BasisOfProjectives

`‣ BasisOfProjectives`( A ) | ( attribute )

Arguments: A -- a finite dimensional (quotient of a) path algebra.

Returns: a list of bases for all the indecomposable projective representations over A. The basis for each indecomposable projective is given a list of elements in nontips in A.

The function checks if the algebra A is a finite dimensional (quotient of a) path algebra, and returns an error message otherwise.

##### 6.5-2 ElementInIndecProjective

`‣ ElementInIndecProjective`( A, m, s ) | ( operation )

Arguments: A -- a QuiverAlgebra, m -- an element in an indecomposable projective representation, s -- an integer.

Returns: the element in the path algebra corresponding to m in the right ideal from which the indecomposable projective representation is constructed.

##### 6.5-3 IndecInjectiveModules

`‣ IndecInjectiveModules`( A ) | ( attribute )

Arguments: A -- a finite dimensional (quotient of a) path algebra.

Returns: a list of all the non-isomorphic indecomposable injective representations over A.

The function checks if the algebra A is a finite dimensional (quotient of a) path algebra, and returns an error message otherwise.

##### 6.5-4 IndecProjectiveModules

`‣ IndecProjectiveModules`( A ) | ( attribute )

Arguments: A -- a finite dimensional (quotient of a) path algebra.

Returns: a list of all the non-isomorphic indecomposable projective representations over A.

The function checks if the algebra A is a finite dimensional (quotient of a) path algebra, and returns an error message otherwise.

##### 6.5-5 SimpleModules

`‣ SimpleModules`( A ) | ( attribute )

Arguments: A -- a finite dimensional (admissible quotient of a) path algebra.

Returns: a list of all the simple representations over A .

The function checks if the algebra A is a finite dimensional (admissible quotient of a) path algebra, and returns an error message otherwise.

##### 6.5-6 ZeroModule

`‣ ZeroModule`( A ) | ( attribute )

Arguments: A -- a finite dimensional (quotient of a) path algebra.

Returns: the zero representation over A.

The function checks if the algebra A is a finite dimensional (quotient of a) path algebra, and returns an error message otherwise.

#### 6.6 Functors on representations

##### 6.6-1 DualOfModule

`‣ DualOfModule`( M ) | ( attribute )

Arguments: M -- a `PathAlgebraMatModule`.

Returns: the dual of M over the opposite algebra \(A^\op\), if M is a module over \(A\).

##### 6.6-2 DualOfModuleHomomorphism

`‣ DualOfModuleHomomorphism`( f ) | ( attribute )

Arguments: f -- a map between two representations M and N over a path algebra \(A\).

Returns: the dual of this map over the opposite path algebra A^\op.

##### 6.6-3 DTr

`‣ DTr`( M[, n] ) | ( operation )

`‣ DualOfTranspose`( M[, n] ) | ( operation )

Arguments: M -- a path algebra module, (optional) n -- an integer.

Returns: the dual of the transpose of M when called with only one argument, while it returns the dual of the transpose applied to M n times otherwise. If n is negative, then powers of `TrD` are computed. `DualOfTranspose` is a synonym for `DTr`.

##### 6.6-4 DTr

`‣ DTr`( f[, n] ) | ( operation )

Arguments: f -- a path algebra module homomorphism and n -- an integer.

Returns: the n-th power of the dual of the transpose of the homomorphism f.

##### 6.6-5 NakayamaFunctorOfModule

`‣ NakayamaFunctorOfModule`( M ) | ( attribute )

Arguments: M -- a `PathAlgebraMatModule`.

Returns: the module \(\Hom_K(\Hom_A(M,A), K)\) over \(A\), when M is a module over a \(K\)-algebra \(A\).

##### 6.6-6 NakayamaFunctorOfModuleHomomorphism

`‣ NakayamaFunctorOfModuleHomomorphism`( f ) | ( attribute )

Arguments: f -- a map between two modules M and N over a path algebra \(A\).

Returns: the homomorphism induced by \(f\colon M\to N\) from the module \(\Hom_K(\Hom_A(M,A),K)\) to \(\Hom_K(\Hom_A(N,A), K)\), when f is a module homomorphism over a \(K\)-algebra A.

##### 6.6-7 OppositeNakayamaFunctorOfModule

`‣ OppositeNakayamaFunctorOfModule`( M ) | ( attribute )

Arguments: M -- a `PathAlgebraMatModule`.

Returns: the module \(\Hom_A(\Hom_K(M,K), A)\) over \(A\), when M is a module over a \(K\)-algebra \(A\).

##### 6.6-8 OppositeNakayamaFunctorOfModuleHomomorphism

`‣ OppositeNakayamaFunctorOfModuleHomomorphism`( f ) | ( attribute )

Arguments: f -- a map between two modules M and N over a path algebra \(A\).

Returns: the homomorphism induced by \(f\colon M\to N\) from the module \(\Hom_A(\Hom_K(M,K),A)\) to \(\Hom_A(\Hom_K(N,K), A)\), when f is a module homomorphism over a \(K\)-algebra A.

##### 6.6-9 RestrictionViaAlgebraHomomorphism

`‣ RestrictionViaAlgebraHomomorphism`( f, M ) | ( operation )

Arguments: f -- an IsAlgebraHomomorphism, M -- an IsPathAlgebraMatModule.

Returns: Given an algebra homomorphism \(f \colon A \hookrightarrow B\) and a module M over \(B\), this function returns M as a module over \(A\).

##### 6.6-10 RestrictionViaAlgebraHomomorphismMap

`‣ RestrictionViaAlgebraHomomorphismMap`( f, h ) | ( operation )

Arguments: f -- an IsAlgebraHomomorphism, h -- an IsPathAlgebraMatModuleHomomorphism.

Returns: Given an algebra homomorphism \(f \colon A \hookrightarrow B\) and a homomorphism of modules h from \(M\) to \(N\) over \(B\), this function returns the induced homomorphism induced by h as a homomorphism over \(A\).

##### 6.6-11 StarOfModule

`‣ StarOfModule`( M ) | ( attribute )

Arguments: M -- a `PathAlgebraMatModule`.

Returns: the module \(\Hom_A(M,A)\) over the opposite of \(A\), when M is a module over an algebra \(A\).

##### 6.6-12 StarOfModuleHomomorphism

`‣ StarOfModuleHomomorphism`( f ) | ( attribute )

Arguments: f -- a map between two modules M and N over a path algebra \(A\).

Returns: the homomorphism induced by \(f\colon M\to N\) from the module \(\Hom_A(N,A)\) to \(\Hom_A(M,A)\), when f is a module homomorphism over an algebra A.

##### 6.6-13 TensorProductOfModules

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

Arguments: M, N -- two path algebra modules

Returns: the tensor product \(M\otimes_A N\) as a vector space and a function \(M\times N \to M\otimes_A N\), given two representations M and N, where M is a right module over \(A\) and N is a right module over the opposite of \(A\).

##### 6.6-14 TrD

`‣ TrD`( M[, n] ) | ( operation )

`‣ TransposeOfDual`( M[, n] ) | ( operation )

Arguments: M -- a path algebra module, (optional) n -- an integer.

Returns: the transpose of the dual of M when called with only one argument, while it returns the transpose of the dual applied to M n times otherwise. If n is negative, then powers of `TrD` are computed. `TransposeOfDual` is a synonym for `TrD`.

##### 6.6-15 TrD

`‣ TrD`( f[, n] ) | ( operation )

Arguments: f -- a path algebra module homomorphism, n -- an integer.

Returns: the n-th power of the transpose of the dual of the homomorphism f.

##### 6.6-16 TransposeOfModule

`‣ TransposeOfModule`( M ) | ( attribute )

Arguments: M -- a path algebra module.

Returns: the transpose of the module M.

##### 6.6-17 TransposeOfModuleHomomorphism

`‣ TransposeOfModuleHomomorphism`( f ) | ( attribute )

Arguments: f -- a path algebra module homomorphism.

Returns: the transpose of the module homomorphism f.

#### 6.7 Vertex projective modules and submodules thereof

In general, if \(R\) is a ring and \(e\) is an idempotent of \(R\), then \(eR\) is a projective module of \(R\). Then we can form a direct sum of these projective modules together to form larger projective module. One can construct more general modules by providing a vertex projective presentation. In this case, \(M\) is the cokernel as given by the following exact sequence: \(\oplus_{j=1}^{r} w(j)R \rightarrow \oplus_{i=1}^{g} v(i)R \rightarrow{M} \rightarrow 0\) for some map between \(\oplus_{j=1}^{r} w(j)R\) and \(\oplus_{i=1}^{g} v(i)R\). The maps \(w\) and \(v\) map the integers to some idempotent in \(R\).

##### 6.7-1 RightProjectiveModule

`‣ RightProjectiveModule`( A, verts ) | ( function )

Arguments: A -- a (quotient of a) path algebra, verts -- a list of vertices.

Returns: the right projective module over A which is the direct sum of projective modules of the form vA where the vertices are taken from verts.

The module created is in the category `IsPathAlgebraModule`. In this implementation the algebra can be a quotient of a path algebra. So if the list was \([v,w]\) then the module created will be the direct sum \(vA \oplus wA\), in that order. Elements of the modules are vectors of algebra elements, and in each component, each path begins with the vertex in that position in the list of vertices. Right projective modules are implementated as algebra modules (see Reference: Representations of Algebras) and all operations for algebra modules are applicable to right projective modules. In particular, one can construct submodules using `SubAlgebraModule` (Reference: SubAlgebraModule).

Here we create the right projective module \(P = vA \oplus vA \oplus wA\).

    gap> F := GF(11);
    GF(11)
    gap> Q := Quiver(["v","w", "x"],[["v","w","a"],["v","w","b"],
    > ["w","x","c"]]);
    <quiver with 3 vertices and 3 arrows>
    gap> A := PathAlgebra(F,Q);
    <GF(11)[<quiver with 3 vertices and 3 arrows>]>
    gap> P := RightProjectiveModule(A,[A.v,A.v,A.w]);
    <right-module over <GF(11)[<quiver with 3 vertices and 3 arrows>]>>
    gap> Dimension(P);
    12

##### 6.7-2 CompletelyReduceGroebnerBasisForModule

`‣ CompletelyReduceGroebnerBasisForModule`( GB ) | ( function )

Arguments: GB -- an right Groebner basis for a (submodule of a) vertex projective module over a path algebra.

Returns: a completely reduced right Groebner basis from the entered Groebner basis GB.

This function takes as input an right Groebner basis for a vertex projective module or a submodule thereof, an constructs completely reduced right Groebner from it.

##### 6.7-3 IsLeftDivisible

`‣ IsLeftDivisible`( x, y ) | ( property )

Arguments: x, y -- two path algebra vectors.

Returns: true if the tip of y left divides the tip of x. False otherwise.

Given two PathAlgebraVectors x and y, then y is said to left divide x, if the tip of x and the tip of y occur in the same coordinate, and the tipmonomial of the tip of y leftdivides the tipmonomial of the tip of x.

##### 6.7-4 IsPathAlgebraModule

`‣ IsPathAlgebraModule`( P ) | ( property )

Arguments: P -- any object.

Returns: true if the argument P is in the category `IsPathAlgebraModule`.

##### 6.7-5 IsPathAlgebraVector

`‣ IsPathAlgebraVector`( v ) | ( property )

Arguments: v -- a path algebra vector.

Returns: true if v has been constructed as a PathAlgebraVector. Otherwise it returns false.

##### 6.7-6 LeadingCoefficient (of PathAlgebraVector)

`‣ LeadingCoefficient (of PathAlgebraVector)`( x ) | ( operation )

Arguments: x -- an element in a PathAlgebraModule.

Returns: the coefficient of the leading term/tip of a `PathAlgebraVector`.

The tip of the element x can by found by applying the command `LeadingTerm (of PathAlgebraVector)` (6.7-9).

##### 6.7-7 LeadingComponent

`‣ LeadingComponent`( v ) | ( operation )

Arguments: v -- a path algebra vector.

Returns: `v[pos]`, where `pos` is the coordinate for the tip of the vector, whenever v is non-zero. That is, it returns the coordinate of the vector v where the tip occors. It returns zero otherwise.

##### 6.7-8 LeadingPosition

`‣ LeadingPosition`( v ) | ( operation )

Arguments: v -- a path algebra vector.

Returns: the coordinate in which the tip of the vector occurs.

##### 6.7-9 LeadingTerm (of PathAlgebraVector)

`‣ LeadingTerm (of PathAlgebraVector)`( x ) | ( operation )

Arguments: x -- an element in a PathAlgebraModule.

Returns: the leading term/tip of a `PathAlgebraVector`.

The tip of the element x is computed using the following order: the tip is computed for each coordinate, if the largest of these occur as a tip of several coordinates, then the coordinate with the smallest index from 1 to the length of vector is chosen. The position of the tip was computed when the `PathAlgebraVector` was created.

##### 6.7-10 LeftDivision

`‣ LeftDivision`( x, y ) | ( operation )

Arguments: x, y -- two path algebra vectors.

Returns: a scalar multiple of a path, say \(\lambda\) such that the tips of \(y*\lambda\) and \(x\) are the same, if the tip of y left divides the tip of x. False otherwise.

In the following example, we create two elements in \(P\), perform some elementwise operations, and then construct a submodule using the two elements as generators.

    gap> p1 := Vectorize(P,[A.b*A.c,A.a*A.c,A.c]);
    [ (Z(11)^0)*b*c, (Z(11)^0)*a*c, (Z(11)^0)*c ]
    gap> p2 := Vectorize(P,[A.a,A.b,A.w]);
    [ (Z(11)^0)*a, (Z(11)^0)*b, (Z(11)^0)*w ]
    gap> 2*p1 + p2;
    [ (Z(11)^0)*a+(Z(11))*b*c, (Z(11)^0)*b+(Z(11))*a*c,
      (Z(11)^0)*w+(Z(11))*c ]
    gap> S := SubAlgebraModule(P,[p1,p2]);
    <right-module over <GF(11)[<quiver with 3 vertices and 3 arrows>]>>
    gap> Dimension(S);
    3

##### 6.7-11 ^

`‣ ^`( m, a ) | ( operation )

Arguments: m -- an element of a path algebra module, a -- an element of a path algebra.

Returns: the element m multiplied with a.

This action is defined by multiplying each component in m by a on the right.

    gap> p2^(A.c - A.w);
    [ (Z(11)^5)*a+(Z(11)^0)*a*c, (Z(11)^5)*b+(Z(11)^0)*b*c,
      (Z(11)^5)*w+(Z(11)^0)*c ]

##### 6.7-12 <

`‣ <`( m1, m2 ) | ( operation )

Arguments: m1, m2 -- two elements of a PathAlgebraModule.

Returns: `true' if m1 is less than m2 and false otherwise.

Elements are compared componentwise from left to right using the ordering of the underlying algebra. The element m1 is less than m2 if the first time components are not equal, the component of m1 is less than the corresponding component of m2.

    gap> p1 < p2;
    false

##### 6.7-13 /

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

Arguments: M, N -- two finite dimensional `PathAlgebraModule`s.

Returns: the factor module \(M/N\).

This module is again a right algebra module, and all applicable methods and operations are available for the resulting factor module. Furthermore, the resulting module is a vector space, so operations for computing bases and dimensions are also available.

    gap> PS := P/S;
    <9-dimensional right-module over <GF(11)[<quiver with 3 vertices and
    3 arrows>]>>
    gap> Basis(PS);
    Basis( <9-dimensional right-module over <GF(11)[<quiver with
    3 vertices and 3 arrows>]>>,
    [ [ [ <zero> of ..., (Z(11)^0)*v, <zero> of ... ] ],
      [ [ (Z(11)^0)*v, <zero> of ..., <zero> of ... ] ],
      [ [ <zero> of ..., <zero> of ..., (Z(11)^0)*w ] ],
      [ [ <zero> of ..., (Z(11)^0)*a, <zero> of ... ] ],
      [ [ (Z(11)^0)*a, <zero> of ..., <zero> of ... ] ],
      [ [ (Z(11)^0)*b, <zero> of ..., <zero> of ... ] ],
      [ [ <zero> of ..., <zero> of ..., (Z(11)^0)*c ] ],
      [ [ <zero> of ..., (Z(11)^0)*a*c, <zero> of ... ] ],
      [ [ (Z(11)^0)*a*c, <zero> of ..., <zero> of ... ] ] ] )

##### 6.7-14 PathAlgebraVector

`‣ PathAlgebraVector`( fam, components ) | ( operation )

Arguments: fam -- a PathAlgebraVectorFamily, components -- a homogeneous list of elements.

Returns: a PathAlgebraVector in the PathAlgebraVectorFamily fam with the components of the vector being equal to components.

This function is typically used when constructing elements of a module constructed by the command `RightProjectiveModule`. If `P` is constructed as say, `P := RightProjectiveModule(KQ, [KQ.v1, KQ.v1, KQ.v2])`, then `ExtRepOfObj(p)`, where `p` is an element if `P` is a `PathAlgebraVector`. The tip is computed using the following ordering: the tip is computed for each coordinate, if the largest of these occur as a tip of several coordinates, then the coordinate with the smallest index from 1 to the length of vector is chosen.

##### 6.7-15 ProjectivePathAlgebraPresentation

`‣ ProjectivePathAlgebraPresentation`( M ) | ( operation )

Arguments: M -- a finite dimensional module over a (quotient of a) path algebra.

Returns: a projective presentation of the entered module M over a (qoutient of a) path algebra \(A\). The projective presentation, or resolution is over the path algebra form which \(A\) was constructed.

This function takes as input a PathAlgebraMatModule and constructs a projetive presentation of this module over the path algebra over which it is defined, ie. a projetive resolution of length 1. It returns a list of five elements: (1) a projective module \(P\) over the path algebra, which modulo the relations induced the projective cover of M, (2) a submodule \(U\) of \(P\) such that \(P/U\) is isomorphic to M, (3) module generators of \(P\), (4) module generators for \(U\) which forms a completely reduced right Groebner basis for \(U\), and (5) a matrix with enteries in the path algebra which gives the map from \(U\) to \(P\), if \(U\) were considered a direct sum of vertex projective modules over the path algebra.

##### 6.7-16 RightGroebnerBasisOfModule

`‣ RightGroebnerBasisOfModule`( M ) | ( attribute )

Arguments: M -- a PathAlgebraModule.

Returns: a right Groebner basis for the module M.

It checks if the acting algebra on the module M is a path algebra, and it returns an error message otherwise. The elements in the right Groebner basis that is constructed, can be retrieved by the command `BasisVectors`. The underlying module is likewise returned by the command `UnderlyingModule`. The output of the function is satisfying the filter/category `IsRightPathAlgebraModuleGroebnerBasis`.

##### 6.7-17 TargetVertex

`‣ TargetVertex`( v ) | ( operation )

Arguments: v -- a PathAlgebraVector.

Returns: a vertex \(w\) such that \(v*w = v\), if such a vertex exists, and fail otherwise.

Given a PathAlgebraVector v, if v is right uniform, this function finds the vertex \(w\) such that \(v*w = v\) whenever v is non-zero, and returns the zero path otherwise. If v is not right uniform it returns fail.

##### 6.7-18 UniformGeneratorsOfModule

`‣ UniformGeneratorsOfModule`( M ) | ( attribute )

Arguments: M -- a `PathAlgebraModule`.

Returns: a set of right uniform generators of the mdoule M. If M is the zero module, then it returns an empty list.

##### 6.7-19 Vectorize

`‣ Vectorize`( M, components ) | ( function )

Arguments: M -- a module over a path algebra, components -- a list of elements of M.

Returns: a vector in M from a list of path algebra elements components, which defines the components in the resulting vector.

The returned vector is normalized, so the vector's components may not match the input components.

[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