SSL chapter_right_modules.xml Sprache: XML

<Chapter Label="Right-Modules"><Heading>Right Modules over Path
Algebras</Heading>

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 <Ref Sect="vertexproj"/>).

<Section><Heading>Modules of matrix type</Heading> 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 <Math>v</Math> of the algebra there is a vector space
<Math>V</Math>. 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 <Math>a</Math> is
an arrow from <Math>v</Math> to <Math>w</Math>, then there is a
transformation from vector space <Math>V</Math> to <Math>W</Math>.
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.

 <ManSection>
 <Oper Name="RightModuleOverPathAlgebra" Label="with dimension vector" Arg="A, dim_vector, gens"
 Comm=""/>
 <Oper Name="RightModuleOverPathAlgebra" Label="no dimension vector" Arg="A, mats"
 Comm=""/>
 <Oper Name="RightModuleOverPathAlgebraNC" Label="no dimension vector" Arg="A, mats"
 Comm=""/>
 <Description>
 Arguments: <Arg>A</Arg> -- a (quotient of a) path algebra and <Arg>dim_vector</Arg> -- the dimension vector of the module, <Arg>gens</Arg> or <Arg>mats</Arg> -- a list of matrices. For further explanations, see below.
 </Description>
 <Returns>a module over a path algebra or over a qoutient of a path
 algebra.</Returns>
 <Description>
 In the first function call, the second
 argument <Arg>dim_vector</Arg> is the dimension vector of the
 module, and the last argument <Arg>gens</Arg> (maybe an empty
 list <C>[]</C>) is a list of elements of the form <C>["label",matrix]</C>.
 This function constructs a right module over a (quotient of a)
 path algebra <Arg>A</Arg> with dimension
 vector <Arg>dim_vector</Arg>, and where the generators/arrows
 with a non-zero action is given in the list
 <Arg>gens</Arg>. The format of the list <Arg>gens</Arg> 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 <Arg>A</Arg> 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
 <Arg>mats</Arg> can take on three different forms. The function
 checks (i), (ii), (iii) and (iv) as above.

 1) The argument <Arg>mats</Arg> 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 <Arg>mats</Arg> 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 <Math>a</Math> was created first, then <Math>a</Math>
 would be associated with the first matrix.

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

 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 <C>["a",[n,0]]</C> 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 <C>["b",[0,n]]</C> 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.
 </Description>
 </ManSection>

 <ManSection>
 <Oper Name="RightAlgebraModuleToPathAlgebraMatModule" Arg="M" Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> -- a right module over an algebra.
 </Description>
 <Returns>a module over a (qoutient of a) path algebra.</Returns>
 <Description>
 This function constructs a right module over a (quotient of a)
 path algebra <M>A</M> from a RightAlgebraModule over the same
 algebra <M>A</M>. The function checks if <M>A</M> actually is a
 quotient of a path algebra and if the module <M>M</M> is finite
 dimensional and if not, it returns an error message.
 </Description>
 </ManSection>

 <ManSection>
 <Oper Name="\=" Label="for two path algebra matrix modules" Arg="M,
 N" Comm=""/>
 <Description>
 Arguments: <Arg>M, N</Arg> -- two path algebra matrix modules.
 </Description>
 <Returns>true if <Arg>M</Arg> and <Arg>N</Arg> has the same dimension
 vectors and the same matrices defining the module structure.</Returns>
 </ManSection>

<Example><![CDATA[
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 ]> ]]>
</Example>
</Section>

<Section><Heading>Categories Of Matrix Modules</Heading>

 <ManSection>
 <Filt Name="IsPathAlgebraMatModule" Arg="object" Comm=""/>
 <Returns>
 true or false depending on whether <Arg>object</Arg> belongs to the category <Code>IsPathAlgebraMatModule</Code>.</Returns>
 <Description>
 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 <Ref BookName="ref" Label="representations of
 algebras"/> for more details.

 These modules are also vector spaces over the field of the path
 algebra. So refer to <Ref BookName="ref" Label="vector spaces"/>
 for descriptions of the basis and elementwise operations
 available.
 </Description>
 </ManSection>
</Section>

<Section><Heading>Acting on Module Elements</Heading>

 <ManSection>
 <Oper Name="^" Label="a PathAlgebraMatModule element and a PathAlgebra element" Arg="m, p" Comm=""/>
 <Description>
 Arguments: <Arg>m</Arg> -- an element in a module, <Arg>p</Arg> --
 an element in a quiver algebra.
 </Description>
 <Returns>
 the element <Arg>m</Arg> multiplied with <Arg>p</Arg>.
 </Returns>
 <Description>
 When you act on an module element <Math>m</Math> by an
 arrow <Math>a</Math> from <Math>v</Math> to <Math>w</Math>, the
 component of <Math>m</Math> from <Math>V</Math> is acted on
 by <Math>L</Math> the transformation associated to <Math>a</Math>
 and placed in the component <Math>W</Math>. All other components
 are given the value <Math>0</Math>.
 </Description>
 </ManSection>

<Example><![CDATA[
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 ] ] ]]>
</Example>
</Section>

<Section><Heading>Operations on representations</Heading>

<Example><![CDATA[
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 ]> ]]>
</Example>

<ManSection>
 <Oper Name="AnnihilatorOfModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module.
 </Description>
 <Returns>a basis of the annihilator of the module <Arg>M</Arg> in
 the finite dimensional algebra over which <Arg>M</Arg> is a
 module.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="BasicVersionOfModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module.
 </Description>
 <Returns> a basic version of the entered module <Arg>M</Arg>, that
 is, if <Math>M \simeq M_1^{n_1} \oplus \cdots \oplus
 M_t^{n_t},</Math> where <Math>M_i</Math> is indecomposable, then
 <Math>M_1\oplus \cdots \oplus M_t</Math> is returned. At
 present, this function only work at best for finite dimensional
 (quotients of a) path algebra over a finite field. If <Arg>M</Arg> is
 zero, then <Arg>M</Arg> is returned.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="BlockDecompositionOfModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module.
 </Description>
 <Returns>a set of modules <Math>\{M_1,..., M_t\}</Math> such that
 <Math>M \simeq M_1\oplus \cdots \oplus M_t,</Math> where each
 <Math>M_i</Math> is isomorphic to <Math>X_i^{n_i}</Math> for some
 indecomposable module <Math>X_i</Math> and positive integer
 <Math>n_i</Math> for all <Math>i</Math>, where <M>X_i\not\simeq X_j</M>
 for <M>i\neq j</M>.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="BlockSplittingIdempotents" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module.
 </Description>
 <Returns>a set <Math>\{e_1,..., e_t\}</Math> of idempotents in the
 endomorphism of <Arg>M</Arg> such that <Math>M \simeq \Im e_1\oplus
 \cdots \oplus \Im e_t,</Math> where each <Math>\Im e_i</Math> is
 isomorphic to <Math>X_i^{n_i}</Math> for some module
 <Math>X_i</Math> and positive integer <Math>n_i</Math> for all
 <Math>i</Math>.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="CommonDirectSummand" Arg="M, N" Comm="for two
 PathAlgebraMatModule's"/>
 <Description>
 Arguments: <Arg>M</Arg> and <Arg>N</Arg> -- two path algebra modules.
 </Description>
 <Returns>a list of four modules [<Arg>X</Arg>,<Arg>U</Arg>,<Arg>X</Arg>, <Arg>V</Arg>],
 where <Arg>X</Arg> is one common non-zero direct summand of <Arg>M</Arg>
 and <Arg>N</Arg>, the sum of <Arg>X</Arg> and <Arg>U</Arg> is <Arg>M</Arg>
 and the sum of <Arg>X</Arg> and <Arg>V</Arg> is <Arg>N</Arg>,
 if such a non-zero direct summand exists. Otherwise it returns false.</Returns>
 <Description>The function checks if <Arg>M</Arg> and <Arg>N</Arg>
 are <C>PathAlgebraMatModule</C>s over the same (quotient of a)
 path algebra.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="ComplexityOfModule" Arg="M, n" Comm="for a
 PathAlgebraMatModule and a positive integer"/>
 <Description>
 Arguments: <Arg>M</Arg> -- path algebdra module, <Arg>n</Arg> -- a positive integer.
 </Description>
 <Returns>an estimate of the complexity of the module <Arg>M</Arg>.
 </Returns>
 <Description>
 The function checks if the algebra over which the module
 <Arg>M</Arg> 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
 <M>f(x)</M> is a polynomial in <M>x</M>, the degree of
 <M>f(x)</M> is given by <M>\lim_{n\to\infty} \frac{\log
 |f(n)|}{\log n}</M>. So then this function computes an estimate
 of the complexity of <Arg>M</Arg> by approximating the complexity
 by considering the limit <M>\lim_{m\to \infty} \log
 \frac{\dim(P(M)(m))}{\log m}</M> where <M>P(M)(m)</M> is the
 <M>m</M>-th projective in a minimal projective resolution of
 <Arg>M</Arg> at stage <M>m</M>. This limit is estimated by
 <M>\frac{\log \dim(P(M)(n))}{\log n}</M>.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="DecomposeModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Oper Name="DecomposeModuleWithInclusions" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module.
 </Description>
 <Returns>a list of indecomposable modules whose direct sum is
 isomorphic to the module <Arg>M</Arg> in first variant. The
 second variant returns a list of inclusions into <Arg>M</Arg>
 with the sum of the images is isomorphic to the module <Arg>M</Arg>.
 </Returns>
 <Description>Warning: the function is not properly tested and it at
 best only works properly over finite fields.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="DecomposeModuleProbabilistic" Arg="HomMM, M" Comm="for
a basis of Hom(M,M) and a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>HomMM</Arg>, <Arg>M</Arg> -- a list of basis
 elements of the Hom-space of the entered module and a path algebra module.
 </Description>
 <Returns>with (hopefully high probability) a list of indecomposable
 modules whose direct sum is isomorphic to the module <Arg>M</Arg>.
 </Returns>
 <Description>Given a module <Arg>M</Arg> over a finite
 dimensional quotient of a path algebra over a finite field, this
 function tries to decompose the entered module <Arg>M</Arg> by
 choosing random elements in the endomorphism ring of <Arg>M</Arg>
 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 <Arg>M</Arg>. 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.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="DecomposeModuleViaCharPoly" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module.
 </Description>
 <Returns>a list with high probability of indecomposable
 modules whose direct sum is isomorphic to the module <Arg>M</Arg>.
 </Returns>
 <Description>Given a module <Arg>M</Arg> over a finite
 dimensional quotient of a path algebra over a finite field, this
 function decomposes the entered module <Arg>M</Arg> by
 computing the endomorphism ring of <A>M</A> and choosing random
 elements in it.

 This is an experimental function, so use with caution.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="DecomposeModuleViaTop" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module.
 </Description>
 <Returns>a list of indecomposable
 modules whose direct sum is isomorphic to the module <Arg>M</Arg>.
 </Returns>
 <Description>Given a module <Arg>M</Arg> over a finite
 dimensional quotient of a path algebra over a finite field, this
 function decomposes the entered module <Arg>M</Arg> by
 finding the image <M>\Sigma</M> of the endomorphism ring of
 <Arg>M</Arg> in the endomorphism ring of the top of <Arg>M</Arg>,
 in <M>\Sigma</M> finds a complete set of primitive idempotents,
 lifts them back to the endomorphism ring of <Arg>M</Arg> and
 decomposes <Arg>M</Arg>.

 This is an experimental function, so use with caution.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="DecomposeModuleWithMultiplicities" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module.
 </Description>
 <Returns>a list of length two, where the first entry is a list of
 all indecomposable non-isomorphic direct summands of <Arg>M</Arg>
 and the second entry is the list of the multiplicities of these
 direct summand in the module <Arg>M</Arg>.
 </Returns>
 <Description>Warning: the function is not properly tested and it at
 best only works properly over finite fields.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="Dimension" Label="for a PathAlgebraMatModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>the dimension of the representation <Arg>M</Arg>.
 </Returns>
</ManSection>

<ManSection>
 <Attr Name="DimensionVector" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>the dimension vector of the representation <Arg>M</Arg>.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="DirectSumOfQPAModules" Arg="L" Comm="for a
 list of PathAlgebraMatModule's"/>
 <Description>
 Arguments: <Arg>L</Arg> -- a list of <C>PathAlgebraMatModule</C>s over the same (quotient of a) path algebra.
 </Description>
 <Returns>the direct sum of the representations contained in the
 list <Arg>L</Arg>.</Returns>
 <Description>In addition three attributes are attached to the
 result, <Ref Filt="IsDirectSumOfModules"/>, <Ref
 Attr="DirectSumProjections"/> <Ref Attr="DirectSumInclusions"/>.
 </Description>
</ManSection>

<ManSection>
 <Attr Name="DirectSumInclusions" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>
 the list of inclusions from the individual
 modules to their direct sum, when a direct sum has been
 constructed using <Ref Oper="DirectSumOfQPAModules"/>.
 </Returns>
</ManSection>

<ManSection>
 <Attr Name="DirectSumProjections" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <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 <Ref Oper="DirectSumOfQPAModules"/>.
 </Returns>
</ManSection>

<ManSection>
 <Attr Name="FromIdentityToDoubleStarHomomorphism" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>the homomorphism from <Arg>M</Arg> to the double star of
 the module <Arg>M</Arg>.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="IntersectionOfSubmodules" Arg="list" Comm="for a list
 of PathAlgebraMatModule submodules"/>
 <Description>
 Arguments: <Arg>f, g</Arg> or <Arg>list</Arg> -- two homomorphisms
 of PathAlgebraMatModules or a list of such.
 </Description>
 <Returns>the subrepresentation given by the intersection of all the
 submodules given by the inclusions <Arg>f</Arg> and <Arg>g</Arg>
 or <Arg>list</Arg>.
 </Returns>
 <Description>The function checks if <Arg>list</Arg> is non-empty
 and if <Math><Arg>f</Arg>\colon M\to X</Math> and
 <Math><Arg>g</Arg>\colon N\to X</Math> or all the homomorphism in
 <Arg>list</Arg> have the same range and if they all are
 inclusions. If the function is given two arguments <Arg>f</Arg> and
 <Arg>g</Arg>, then it returns <Math>[f',g',g'*f], where
 <Math>f'\colon E\to N,

g'

\colon E\to M</Math>, and
 <Math>E</Math> is the pullback of <Arg>f</Arg> and
 <Arg>g</Arg>. For a list of inclusions it returns a monomorphism
 from a module isomorphic to the intersection to <Math>X</Math>.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="IsDirectSummand" Arg="M, N" Comm="for two
 PathAlgebraMatModule's"/>
 <Description>
 Arguments: <Arg>M, N</Arg> -- two path algebra modules (<C>PathAlgebraMatModule</C>s).
 </Description>
 <Returns>true if <Arg>M</Arg> is isomorphic to a direct summand
 of <Arg>N</Arg>, otherwise false.</Returns>
 <Description>The function checks if <Arg>M</Arg> and <Arg>N</Arg>
 are <C>PathAlgebraMatModule</C>s over the same (quotient of a)
 path algebra.
 </Description>
</ManSection>

<ManSection>
 <Filt Name="IsDirectSumOfModules" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>
 true if <Arg>M</Arg> is constructed via the command <Ref
 Oper="DirectSumOfQPAModules"/>.
 </Returns>
</ManSection>

Using the example above.
<Example><![CDATA[
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 ]>>
 ] ]]>
</Example>

<ManSection>
 <Prop Name="IsExceptionalModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>true if <Arg>M</Arg> is an exceptional module, otherwise
 false, if the field, over which the algebra <Arg>M</Arg> is defined over, is
 finite.
 </Returns>
 <Description>
 The module <Arg>M</Arg> is an exceptional module, if it is indecomposable and
 <M>\Ext^1(M,M)=(0)</M>.
 </Description>
</ManSection>

<ManSection>
 <Prop Name="IsIndecomposableModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>true if <Arg>M</Arg> is an indecomposable module, if the
 field, over which the algebra <Arg>M</Arg> is defined over, is
 finite. If <Arg>M</Arg> is the zero module, then <C>false</C>
 is returned.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="IsInAdditiveClosure" Arg="M, N" Comm="for two
 PathAlgebraMatModule's"/>
 <Description>
 Arguments: <Arg>M, N</Arg> -- two path algebra modules (<C>PathAlgebraMatModule</C>s).
 </Description>
 <Returns>true if <Arg>M</Arg> is in the additive closure of the module
 <Arg>N</Arg>, otherwise false.</Returns>
 <Description>The function checks if <Arg>M</Arg> and <Arg>N</Arg>
 are <C>PathAlgebraMatModule</C>s over the same (quotient of a)
 path algebra.
 </Description>
</ManSection>

<ManSection>
 <Prop Name="IsInjectiveModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>true if the representation <Arg>M</Arg> is injective.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="IsomorphicModules" Arg="M, N" Comm=""/>
 <Description>
 Arguments: <Arg>M, N</Arg> -- two path algebra modules (<C>PathAlgebraMatModule</C>s).
 </Description>
 <Returns>true or false depending on whether <Arg>M</Arg>
 and <Arg>N</Arg> are isomorphic or not.</Returns>
 <Description>
 The function first checks if the modules <Arg>M</Arg>
 and <Arg>N</Arg> are modules over the same algebra, and returns fail
 if not. The function returns true if the modules are
 isomorphic, otherwise false.
 </Description>
</ManSection>

<ManSection>
 <Prop Name="IsProjectiveModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>true if the representation <Arg>M</Arg> is projective.
 </Returns>
</ManSection>

<ManSection>
 <Prop Name="IsRigidModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>true if <Arg>M</Arg> is a rigid module, otherwise
 false.
 </Returns>
 <Description>
 The module <Arg>M</Arg> is a rigid module, if <M>\Ext^1(M,M)=(0)</M>.
 </Description>
</ManSection>

<ManSection>
 <Prop Name="IsSemisimpleModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>true if the representation <Arg>M</Arg> is semisimple.
 </Returns>
</ManSection>

<ManSection>
 <Prop Name="IsSimpleQPAModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>true if the representation <Arg>M</Arg> is simple.
 </Returns>
</ManSection>

<ManSection>
 <Prop Name="IsTauRigidModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>true if <Arg>M</Arg> is a <M>\tau</M>-rigid module, otherwise
 false.
 </Returns>
 <Description>
 The module <Arg>M</Arg> is a <M>\tau</M>-rigid module, if <M>\Hom(M,\tau M)=(0)</M>.
 </Description>
</ManSection>

<ManSection>
 <Attr Name="LoewyLength" Label="for a PathAlgebraMatModule" Arg="M" Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>the Loewy length of the module <Arg>M</Arg>.</Returns>
 <Description>
 The function checks that the module <Arg>M</Arg> is a module over
 a finite dimensional quotient of a path algebra, and returns fail
 otherwise (This is not implemented yet).
 </Description>
</ManSection>

<ManSection>
 <Prop Name="IsZero" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>true if <Arg>M</Arg> is the zero module, otherwise
 false.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="MatricesOfPathAlgebraModule" Arg="M" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>a list of the matrices that defines the
 representation <Arg>M</Arg> as a right module of the acting path
 algebra.
 </Returns>
 <Description>
 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.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="MaximalCommonDirectSummand" Arg="M, N" Comm="for two
 PathAlgebraMatModule's"/>
 <Description>
 Arguments: <Arg>M, N</Arg> -- two path algebra modules (<C>PathAlgebraMatModule</C>s).
 </Description>
 <Returns>a list of three modules [<Arg>X</Arg>,<Arg>U</Arg>,<Arg>V</Arg>],
 where <Arg>X</Arg> is a maximal common non-zero direct summand of <Arg>M</Arg>
 and <Arg>N</Arg>, the sum of <Arg>X</Arg> and <Arg>U</Arg> is <Arg>M</Arg>
 and the sum of <Arg>X</Arg> and <Arg>V</Arg> is <Arg>N</Arg>,
 if such a non-zero maximal direct summand exists. Otherwise it returns false.</Returns>
 <Description>The function checks if <Arg>M</Arg> and <Arg>N</Arg>
 are <C>PathAlgebraMatModule</C>s over the same (quotient of a)
 path algebra.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="NumberOfNonIsoDirSummands" Arg="M" Comm="for a PathAlgebraMatModule's"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra modules (<C>PathAlgebraMatModule</C>s).
 </Description>
 <Returns>a list with two elements: (1) the number of non-isomorphic
 indecomposable direct summands of the module <Arg>M</Arg> and (2)
 the dimensions of the simple blocks of the semisimple ring
 <Math>\End(M)/\rad \End(M)</Math>.</Returns>
</ManSection>

<ManSection>
 <Attr Name="MinimalGeneratingSetOfModule" Arg="M" Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>a minimal generator set of the module <Arg>M</Arg> as a
 module of the path algebra it is defined over. </Returns>
</ManSection>

<ManSection>
 <Oper Name="RadicalOfModule" Arg="M" Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>the radical of the module <Arg>M</Arg>.</Returns>
 <Description>
 This returns only the representation given by the radical of the
 module <Arg>M</Arg>. The operation
 <Ref Oper="RadicalOfModuleInclusion"/> computes the inclusion of the
 radical of <Arg>M</Arg> into <Arg>M</Arg>. This function applies
 when the algebra over which <Arg>M</Arg> is defined is an
 admissible quotient of a path algebra.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="RadicalSeries" Arg="M" Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>the radical series of the module <Arg>M</Arg>.</Returns>
 <Description>
 The function gives the radical series as a list of vectors
 <Code>[n_1,...,n_s]</Code>, where the algebra has <Math>s</Math>
 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.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="SocleSeries" Arg="M" Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>the socle series of the module <Arg>M</Arg>.</Returns>
 <Description>
 The function gives the socle series as a list of vectors
 <Code>[n_1,...,n_s]</Code>, where the algebra has <Math>s</Math>
 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.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="SocleOfModule" Arg="M" Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>).
 </Description>
 <Returns>the socle of the module <Arg>M</Arg>.</Returns>
 <Description>
 This operation only return the representation given by the socle
 of the module <Arg>M</Arg>. The inclusion the socle
 of <Arg>M</Arg> into <Arg>M</Arg> can be computed using
 <Ref Oper="SocleOfModuleInclusion"/>.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="SubRepresentation" Arg="M, gens" Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module (<C>PathAlgebraMatModule</C>), <Arg>gens</Arg> -- elements in <Arg>M</Arg>.
 </Description>
 <Returns>the submodule of the module <Arg>M</Arg> generated by the
 elements <Arg>gens</Arg>.</Returns>
 <Description>
 The function checks if <Arg>gens</Arg> are elements
 in <Arg>M</Arg>, and returns an error message otherwise. The
 inclusion of the submodule generated by the
 elements <Arg>gens</Arg> into <Arg>M</Arg> can be computed using
 <Ref Oper="SubRepresentationInclusion"/>.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="SumOfSubmodules" Arg="list" Comm="for a list
 of PathAlgebraMatModule submodules"/>
 <Description>
 Arguments: <Arg>f, g</Arg> or <Arg>list</Arg> -- two inclusions
 of PathAlgebraMatModules or a list of such.
 </Description>
 <Returns>the subrepresentation given by the sum of all the
 submodules given by the inclusions <Arg>f, g</Arg>
 or <Arg>list</Arg>.
 </Returns>
 <Description>The function checks if <Arg>list</Arg> is non-empty
 and if <Math><Arg>f</Arg>\colon M\to X</Math>
 and <Math><Arg>g</Arg>\colon N\to X</Math> or all the
 homomorphism in <Arg>list</Arg> have the same range and if they
 all are inclusions. If the function is given two
 arguments <Arg>f</Arg> and <Arg>g</Arg>, then it
 returns <Math>[h,f',g']</Math>, where <Math>h\colon M + N\to
 X</Math>, <Math>f'\colon M\to M + N and

g'

\colon
 N\to M + N</Math>. For a list of
 inclusions it returns a monomorphism from a module isomorphic
 to the sum of the subrepresentations to <Math>X</Math>.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="SupportModuleElement" Arg="m" Comm=""/>
 <Description>
 Arguments: <Arg>m</Arg> -- an element of a path algebra module.
 </Description>
 <Returns>the primitive idempotents <Arg>v</Arg> in the algebra over
 which the module containing the element <Arg>m</Arg> is a module,
 such that <Arg>m^v</Arg> is non-zero.</Returns>
 <Description>
 The function checks if <Arg>m</Arg> is an element in a module
 over a (quotient of a) path algebra, and returns fail otherwise.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="TopOfModule" Arg="M" Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> or <Arg>f</Arg> -- a path algebra module
 or a homomorphism thereof.
 </Description>
 <Returns>the top of the module <Arg>M</Arg> or the homomorphism
 induced on the top of the modules associated to the homomorphism <Arg>f</Arg>.</Returns>
 <Description>
 This returns only the representation given by the top of the
 module <Arg>M</Arg> or the homomorphism induced on the top of the
 modules associated to the entered homomorphism. The operation
 <Ref Oper="TopOfModuleProjection"/> computes the projection of the
 module <Arg>M</Arg> onto the top of the module <Arg>M</Arg>.
 </Description>
</ManSection>
</Section>

<Section><Heading>Special representations</Heading>
Here we collect the predefined representations/modules over a finite
 dimensional quotient of a path algebra.

<ManSection>
 <Attr Name="BasisOfProjectives" Arg="A" Comm=""/>
 <Description>
 Arguments: <Arg>A</Arg> -- a finite dimensional (quotient of a) path
 algebra.
 </Description>
 <Returns>a list of bases for all the indecomposable projective
 representations over <Arg>A</Arg>. The basis for each indecomposable projective is given a list of elements in nontips in <Arg>A</Arg>.
 </Returns>
 <Description>
 The function checks if the algebra <Arg>A</Arg> is a
 finite dimensional (quotient of a) path algebra, and returns an
 error message otherwise.
 </Description>
 </ManSection>

<ManSection>
 <Oper Name="ElementInIndecProjective" Arg="A, m, s" Comm="for a
 QuiverAlgebra,
 an element in
 indec. projective
 and an integer"/>
 <Description>
 Arguments: <Arg>A</Arg> -- a QuiverAlgebra, <Arg>m</Arg> -- an
 element in an indecomposable projective representation,
 <Arg>s</Arg> -- an integer.
 </Description>
 <Returns>the element in the path algebra corresponding to
 <Arg>m</Arg> in the right ideal from which the indecomposable
 projective representation is constructed.</Returns>
</ManSection>

<ManSection>
 <Oper Name="ElementIn_vA_AsElementInIndecProj" Arg="A, m" Comm="for a
 QuiverAlgebra,
 an element in
 vA for a
 vertex v"/>
 <Description>
 Arguments: <Arg>A</Arg> -- a QuiverAlgebra, <Arg>m</Arg> -- an
 element in <Arg>vA</Arg> for a vertex <Arg>v</Arg>.
 </Description>
 <Returns>the corresponding element in the indecomposable projective
 representation assosicated with the vertex <Arg>v</Arg>.</Returns>
</ManSection>

 <ManSection>
 <Attr Name="IndecInjectiveModules" Arg="A" Comm="for an algebra"/>
 <Description>
 Arguments: <Arg>A</Arg> -- a finite dimensional (quotient of a) path
 algebra.
 </Description>
 <Returns>a list of all the non-isomorphic indecomposable injective
 representations over <Arg>A</Arg>.
 </Returns>
 <Description>
 The function checks if the algebra <Arg>A</Arg> is a finite
 dimensional (quotient of a) path algebra, and returns an error
 message otherwise.
 </Description>
 </ManSection>

 <ManSection>
 <Attr Name="IndecProjectiveModules" Arg="A" Comm="for an algebra"/>
 <Description>
 Arguments: <Arg>A</Arg> -- a finite dimensional (quotient of a) path
 algebra.
 </Description>
 <Returns>a list of all the non-isomorphic indecomposable projective
 representations over <Arg>A</Arg>.
 </Returns>
 <Description>
 The function checks if the algebra <Arg>A</Arg> is a
 finite dimensional (quotient of a) path algebra, and returns an
 error message otherwise.
 </Description>
 </ManSection>

 <ManSection>
 <Attr Name="SimpleModules" Arg="A" Comm=""/>
 <Description>
 Arguments: <Arg>A</Arg> -- a finite dimensional (admissible quotient of a) path
 algebra.
 </Description>
 <Returns>a list of all the simple representations over <Arg>A</Arg> .
 </Returns>
 <Description>
 The function checks if the algebra <Arg>A</Arg> is a finite
 dimensional (admissible quotient of a) path algebra, and returns an error
 message otherwise.
 </Description>
 </ManSection>

 <ManSection>
 <Attr Name="ZeroModule" Arg="A" Comm=""/>
 <Description>
 Arguments: <Arg>A</Arg> -- a finite dimensional (quotient of a) path
 algebra.
 </Description>
 <Returns>the zero representation over <Arg>A</Arg>.
 </Returns>
 <Description>
 The function checks if the algebra <Arg>A</Arg> is a finite
 dimensional (quotient of a) path algebra, and returns an error
 message otherwise.
 </Description>
 </ManSection>
</Section>

<Section><Heading>Functors on representations</Heading>

<ManSection>
 <Attr Name="DualOfModule" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a <C>PathAlgebraMatModule</C>.
 </Description>
 <Returns>
 the dual of <Arg>M</Arg> over the opposite algebra <M>A^\op</M>,
 if <Arg>M</Arg> is a module over <M>A</M>.
 </Returns>
</ManSection>

<ManSection>
 <Attr Name="DualOfModuleHomomorphism" Arg="f" Comm="for a PathAlgebraMatModuleMap"/>
 <Description>
 Arguments: <Arg>f</Arg> -- a map between two representations <Arg>M</Arg> and <Arg>N</Arg> over a path algebra <Math>A</Math>.
 </Description>
 <Returns>
 the dual of this map over the opposite path algebra <Arg>A^\op</Arg>.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="DTr" Arg="M, [ n ]" Comm="for a PathAlgebraMatModule and an
 integer"/>
 <Oper Name="DualOfTranspose" Arg="M, [ n ]" Comm="for a
 PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module, (optional) <Arg>n</Arg> -- an integer.
 </Description>
 <Returns>the dual of the transpose of <Arg>M</Arg> when
 called with only one argument, while it returns the dual of the
 transpose applied to <Arg>M</Arg> <Arg>n</Arg> times
 otherwise. If <Arg>n</Arg> is negative, then powers of <C>TrD</C>
 are computed. <Ref Oper="DualOfTranspose"/> is a synonym for
 <Ref Oper="DTr"/>. </Returns>
</ManSection>

<ManSection>
 <Oper Name="DTr" Arg="f, [ n ]" Comm="for a
 PathAlgebraMatModuleHomomorphism
 and an integer"/>
 <Description>
 Arguments: <Arg>f</Arg> -- a path algebra module homomorphism and
 <Arg>n</Arg> -- an integer. </Description>
 <Returns>the <Arg>n</Arg>-th power of the dual of the transpose of the homomorphism <Arg>f</Arg>. </Returns>
</ManSection>

<ManSection>
 <Attr Name="NakayamaFunctorOfModule" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a <C>PathAlgebraMatModule</C>.
 </Description>
 <Returns>
 the module <M>\Hom_K(\Hom_A(M,A), K)</M> over <M>A</M>, when
 <Arg>M</Arg> is a module over a <M>K</M>-algebra <M>A</M>.
 </Returns>
</ManSection>

<ManSection>
 <Attr Name="NakayamaFunctorOfModuleHomomorphism" Arg="f" Comm="for a PathAlgebraMatModuleMap"/>
 <Description>
 Arguments: <Arg>f</Arg> -- a map between two modules <Arg>M</Arg>
 and <Arg>N</Arg> over a path algebra <Math>A</Math>. 
 </Description>
 <Returns>
 the homomorphism induced by <M>f\colon M\to N</M> from the module
 <M>\Hom_K(\Hom_A(M,A),K)</M> to <M>\Hom_K(\Hom_A(N,A), K)</M>,
 when <Arg>f</Arg> is a module homomorphism over a <M>K</M>-algebra
 <Arg>A</Arg>.
 </Returns>
</ManSection>

<ManSection>
 <Attr Name="OppositeNakayamaFunctorOfModule" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a <C>PathAlgebraMatModule</C>.
 </Description>
 <Returns>
 the module <M>\Hom_A(\Hom_K(M,K), A)</M> over <M>A</M>, when
 <Arg>M</Arg> is a module over a <M>K</M>-algebra <M>A</M>.
 </Returns>
</ManSection>

<ManSection>
 <Attr Name="OppositeNakayamaFunctorOfModuleHomomorphism" Arg="f" Comm="for a PathAlgebraMatModuleMap"/>
 <Description>
 Arguments: <Arg>f</Arg> -- a map between two modules <Arg>M</Arg>
 and <Arg>N</Arg> over a path algebra <Math>A</Math>. 
 </Description>
 <Returns>
 the homomorphism induced by <M>f\colon M\to N</M> from the module
 <M>\Hom_A(\Hom_K(M,K),A)</M> to <M>\Hom_A(\Hom_K(N,K), A)</M>,
 when <Arg>f</Arg> is a module homomorphism over a <M>K</M>-algebra
 <Arg>A</Arg>.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="RestrictionViaAlgebraHomomorphism" Arg="f, M" Comm="for
 an IsAlgebraHomomorphism
 and IsPathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>f</Arg> -- an IsAlgebraHomomorphism, <Arg>M</Arg> -- an IsPathAlgebraMatModule.
 </Description>
 <Returns>Given an algebra homomorphism <M>f \colon A
 \hookrightarrow B</M> and a module <Arg>M</Arg> over <M>B</M>,
 this function returns <Arg>M</Arg> as a module over <M>A</M>.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="RestrictionViaAlgebraHomomorphismMap" Arg="f, h" Comm="for
 an IsAlgebraHomomorphism
 and IsPathAlgebraMatModuleHomomorphism"/>
 <Description>
 Arguments: <Arg>f</Arg> -- an IsAlgebraHomomorphism, <Arg>h</Arg> -- an IsPathAlgebraMatModuleHomomorphism.
 </Description>
 <Returns>Given an algebra homomorphism <M>f \colon A
 \hookrightarrow B</M> and a homomorphism of modules <Arg>h</Arg>
 from <M>M</M> to <M>N</M> over <M>B</M>,
 this function returns the induced homomorphism induced by
 <Arg>h</Arg> as a homomorphism over <M>A</M>.
 </Returns>
</ManSection>

<ManSection>
 <Attr Name="StarOfModule" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a <C>PathAlgebraMatModule</C>.
 </Description>
 <Returns>
 the module <M>\Hom_A(M,A)</M> over the opposite of <M>A</M>,
 when <Arg>M</Arg> is a module over an algebra <M>A</M>.
 </Returns>
</ManSection>

<ManSection>
 <Attr Name="StarOfModuleHomomorphism" Arg="f" Comm="for a PathAlgebraMatModuleMap"/>
 <Description>
 Arguments: <Arg>f</Arg> -- a map between two modules <Arg>M</Arg>
 and <Arg>N</Arg> over a path algebra <Math>A</Math>. 
 </Description>
 <Returns>
 the homomorphism induced by <M>f\colon M\to N</M> from the module
 <M>\Hom_A(N,A)</M> to <M>\Hom_A(M,A)</M>, when <Arg>f</Arg> is a
 module homomorphism over an algebra <Arg>A</Arg>.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="TensorProductOfModules" Arg="M, N" Comm="for two PathAlgebraMatModules"/>
 <Description>
 Arguments: <Arg>M</Arg>, <Arg>N</Arg> -- two path algebra modules </Description>
 <Returns>the tensor product <M>M\otimes_A N</M> as a vector space
 and a function <M>M\times N \to M\otimes_A N</M>, given two
 representations <Arg>M</Arg> and <Arg>N</Arg>, where <Arg>M</Arg>
 is a right module over <M>A</M> and <Arg>N</Arg> is a right module
 over the opposite of <M>A</M>.
 </Returns>
</ManSection>

<ManSection>
 <Oper Name="TrD" Arg="M, [n]" Comm="for a PathAlgebraMatModule and an
 integer"/>
 <Oper Name="TransposeOfDual" Arg="M, [n]" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module, (optional) <Arg>n</Arg> -- an integer.
 </Description>
 <Returns>the transpose of the dual of <Arg>M</Arg> when
 called with only one argument, while it returns the transpose of
 the dual applied to <Arg>M</Arg> <Arg>n</Arg> times
 otherwise. If <Arg>n</Arg> is negative, then powers of <C>TrD</C>
 are computed. <Ref Oper="TransposeOfDual"/> is a synonym for
 <Ref Oper="TrD"/>.</Returns>
</ManSection>

<ManSection>
 <Oper Name="TrD" Arg="f, [ n ]" Comm="for a
 PathAlgebraMatModuleHomomorphism
 and an integer"/>
 <Description>
 Arguments: <Arg>f</Arg> -- a path algebra module homomorphism,
 <Arg>n</Arg> -- an integer. </Description>
 <Returns>the <Arg>n</Arg>-th power of the transpose of the dual of the homomorphism <Arg>f</Arg>. </Returns>
</ManSection>

<ManSection>
 <Attr Name="TransposeOfModule" Arg="M" Comm="for a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a path algebra module.
 </Description>
 <Returns>the transpose of the module <Arg>M</Arg>.</Returns>
</ManSection>

<ManSection>
 <Attr Name="TransposeOfModuleHomomorphism" Arg="f" Comm="for a PathAlgebraMatModuleHomomorphism"/>
 <Description>
 Arguments: <Arg>f</Arg> -- a path algebra module homomorphism.
 </Description>
 <Returns>the transpose of the module homomorphism <Arg>f</Arg>.</Returns>
</ManSection>

</Section>

<Section Label="vertexproj"><Heading>Vertex projective modules and submodules thereof</Heading>
In general, if <Math>R</Math> is a ring and <Math>e</Math> is an
idempotent of <Math>R</Math>, then <Math>eR</Math> is a projective
module of <Math>R</Math>. 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 <Arg>vertex
projective presentation</Arg>. In this case, <Math>M</Math> is the
cokernel as given by the following exact sequence:

<Math>\oplus_{j=1}^{r} w(j)R \rightarrow \oplus_{i=1}^{g} v(i)R
\rightarrow{M} \rightarrow 0</Math>

for some map between <Math>\oplus_{j=1}^{r} w(j)R</Math>
and <Math>\oplus_{i=1}^{g} v(i)R</Math>. The maps <Math>w</Math>
and <Math>v</Math> map the integers to some idempotent
in <Math>R</Math>.

<ManSection>
 <Func Name="RightProjectiveModule" Arg="A, verts"
 Comm=""/>
 <Description>
 Arguments: <Arg>A</Arg> -- a (quotient of a) path algebra, <Arg>verts</Arg> -- a list of vertices.
 </Description>
 <Returns> the right projective module over <Arg>A</Arg> which is
 the direct sum of projective modules of the form <Arg>vA</Arg>
 where the vertices are taken from <Arg>verts</Arg>.</Returns>
 <Description>
 The module created is in the category <C>IsPathAlgebraModule</C>.

 In this implementation the algebra can be a quotient of a path
 algebra. So if the list was
 <Math>[v,w]</Math> then the module created will be the direct
 sum <Math>vA \oplus wA</Math>, 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 implemented as algebra
 modules (see <Ref BookName="ref" Label="representations of algebras"/>) and all
 operations for algebra modules are applicable to right
 projective modules. In particular, one can construct submodules
 using <Ref BookName="ref" Func="SubAlgebraModule"/>.
 </Description>
</ManSection>
Here we create the right projective module <Math>P = vA \oplus vA
\oplus wA</Math>.

<Example><![CDATA[
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 ]]>
</Example>

<ManSection>
 <Func Name="CompletelyReduceGroebnerBasisForModule" Arg="GB" Comm="for a right Groebner basis of a module"/>
 <Description>
 Arguments: <Arg>GB</Arg> -- an right Groebner basis for a (submodule of a) vertex projective module over a path algebra.
 </Description>
 <Returns>a completely reduced right Groebner basis from the entered Groebner basis <Arg>GB</Arg>.</Returns>
 <Description>
 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.
 </Description>
</ManSection>

<ManSection>
 <Prop Name="IsLeftDivisible" Arg="x, y" Comm="for two PathAlgebraVector's"/>
 <Description>
 Arguments: <Arg>x, y</Arg> -- two path algebra vectors.
 </Description>
 <Returns>true if the tip of <Arg>y</Arg> left divides the tip of <Arg>x</Arg>.
 False otherwise.</Returns>
 <Description>
 Given two PathAlgebraVectors <Arg>x</Arg> and <Arg>y</Arg>, then
 <Arg>y</Arg> is said to left divide <Arg>x</Arg>, if the tip of
 <Arg>x</Arg> and the tip of <Arg>y</Arg> occur in the same
 coordinate, and the tipmonomial of the tip of <Arg>y</Arg>
 leftdivides the tipmonomial of the tip of <Arg>x</Arg>.
 </Description>
</ManSection>

<ManSection>
 <Prop Name="IsPathAlgebraModule" Arg="P" Comm="an object"/>
 <Description>
 Arguments: <Arg>P</Arg> -- any object.
 </Description>
 <Returns>true if the argument <Arg>P</Arg> is in the category <C>IsPathAlgebraModule</C>.</Returns>
</ManSection>

<ManSection>
 <Prop Name="IsPathAlgebraVector" Arg="v" Comm="for a PathAlgebraVector"/>
 <Description>
 Arguments: <Arg>v</Arg> -- a path algebra vector.
 </Description>
 <Returns>true if <Arg>v</Arg> has been constructed as a PathAlgebraVector.
 Otherwise it returns false.</Returns>
</ManSection>

<ManSection>
 <Oper Name="LeadingCoefficient (of PathAlgebraVector)" Arg="x" Comm="for a PathAlgebraVector"/>
 <Description>
 Arguments: <Arg>x</Arg> -- an element in a PathAlgebraModule.
 </Description>
 <Returns>the coefficient of the leading term/tip of a <C>PathAlgebraVector</C>.</Returns>
 <Description>
 The tip of the element <Arg>x</Arg> can by found by applying the
 command <Ref Oper="LeadingTerm (of PathAlgebraVector)"/>.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="LeadingComponent" Arg="v" Comm="for a PathAlgebraVector"/>
 <Description>
 Arguments: <Arg>v</Arg> -- a path algebra vector.
 </Description>
 <Returns><C>v[pos]</C>, where <C>pos</C> is the coordinate for the tip
 of the vector, whenever <Arg>v</Arg> is non-zero. That is, it returns the coordinate
 of the vector <Arg>v</Arg> where the tip occors. It returns zero otherwise.</Returns>
</ManSection>

<ManSection>
 <Oper Name="LeadingPosition" Arg="v" Comm="for a PathAlgebraVector"/>
 <Description>
 Arguments: <Arg>v</Arg> -- a path algebra vector.
 </Description>
 <Returns>the coordinate in which the tip of the vector occurs.</Returns>
</ManSection>

<ManSection>
 <Oper Name="LeadingTerm (of PathAlgebraVector)" Arg="x"
Comm=""/>
 <Description>
 Arguments: <Arg>x</Arg> -- an element in a PathAlgebraModule.
 </Description>
 <Returns>the leading term/tip of a <C>PathAlgebraVector</C>.</Returns>
 <Description>
 The tip of the element <Arg>x</Arg> 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
 <C>PathAlgebraVector</C> was created.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="LeftDivision" Arg="x, y" Comm="for two PathAlgebraVector's"/>
 <Description>
 Arguments: <Arg>x, y</Arg> -- two path algebra vectors.
 </Description>
 <Returns>a scalar multiple of a path, say <Math>\lambda</Math> such
 that the tips of <Math>y*\lambda</Math> and <Math>x</Math> are the same,
 if the tip of <Arg>y</Arg> left divides the tip of <Arg>x</Arg>.
 False otherwise.</Returns>
</ManSection>

In the following example, we create two elements in <Math>P</Math>,
perform some elementwise operations, and then construct a submodule
using the two elements as generators.

<Example><![CDATA[
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 ]]>
</Example>

 <ManSection>
 <Oper Name="^" Label="a PathAlgebraModule element and a PathAlgebra element" Arg="m, a" Comm="Action by a path algebra element"/>
 <Description>
 Arguments: <Arg>m</Arg> -- an element of a path algebra module, <Arg>a</Arg> -- an element of a path algebra.
 </Description>
 <Returns>
 the element <Arg>m</Arg> multiplied with <Arg>a</Arg>.
 </Returns>
 <Description>
 This action is defined by multiplying each component
 in <Arg>m</Arg> by <Arg>a</Arg> on the right.
 </Description>
 </ManSection>

<Example><![CDATA[
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 ] ]]>
</Example>

 <ManSection>
 <Oper Name="<" Label="for two elements in a PathAlgebraModule" Arg="m1, m2" Comm="lessthan"/>
 <Description>
 Arguments: <Arg>m1, m2</Arg> -- two elements of a PathAlgebraModule.
 </Description>
 <Returns>
 `true' if m1 is less than m2 and false otherwise.
 </Returns>
 <Description>
 Elements are compared componentwise from left to right using the ordering of the underlying algebra. The element <Arg>m1</Arg> is less than <Arg>m2</Arg> if the first time components are not equal, the
 component of <Arg>m1</Arg> is less than the corresponding
 component of <Arg>m2</Arg>.
 </Description>
 </ManSection>

<Example><![CDATA[
gap> p1 < p2;
false ]]>
</Example>

 <ManSection>
 <Oper Name="/" Arg="M, N" Comm="Factor module"/>
 <Description>
 Arguments: <Arg>M, N</Arg> -- two finite dimensional <C>PathAlgebraModule</C>s.
 </Description>
 <Returns>
 the factor module <Math>M/N</Math>.
 </Returns>
 <Description>
 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.
 </Description>
 </ManSection>

<Example><![CDATA[
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 ... ] ] ] ) ]]>
</Example>

<ManSection>
 <Oper Name="PathAlgebraVector" Arg="fam, components" Comm="for a PathAlgebraVectorFamily and a list"/>
 <Description>
 Arguments: <Arg>fam</Arg> -- a PathAlgebraVectorFamily, <Arg>components</Arg> -- a homogeneous list of elements.
 </Description>
 <Returns>a PathAlgebraVector in the PathAlgebraVectorFamily <Arg>fam</Arg> with the components of the vector being
 equal to <Arg>components</Arg>.
 </Returns>
 <Description>
 This function is typically used when constructing elements of a module
 constructed by the command <C>RightProjectiveModule</C>. If <C>P</C> is
 constructed as say, <C>P := RightProjectiveModule(KQ, [KQ.v1, KQ.v1, KQ.v2])</C>,
 then <C>ExtRepOfObj(p)</C>, where <C>p</C> is an element if <C>P</C> is
 a <C>PathAlgebraVector</C>. 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.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="ProjectivePathAlgebraPresentation" Arg="M" Comm="projective presentation of a PathAlgebraMatModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a finite dimensional module over a (quotient of a) path algebra.
 </Description>
 <Returns>a projective presentation of the entered module
 <Arg>M</Arg> over a (qoutient of a) path algebra
 <Math>A</Math>. The projective presentation, or resolution is over
 the path algebra form which <Math>A</Math> was constructed.
 </Returns>
 <Description>
 This function takes as input a PathAlgebraMatModule and
 constructs a projective presentation of this module over the path
 algebra over which it is defined, i.e. a projective resolution of
 length 1. It returns a list of five elements: (1) a projective
 module <Math>P</Math> over the path algebra, which modulo the
 relations induced the projective cover of <Arg>M</Arg>, (2) a
 submodule <Math>U</Math> of <Math>P</Math> such that
 <Math>P/U</Math> is isomorphic to <Arg>M</Arg>, (3) module
 generators of <Math>P</Math>, (4) module generators for
 <Math>U</Math> which forms a completely reduced right Groebner
 basis for <Math>U</Math>, and (5) a matrix with entries in the
 path algebra which gives the map from <Math>U</Math> to
 <Math>P</Math>, if <Math>U</Math> were considered a direct sum of
 vertex projective modules over the path algebra.
 </Description>
</ManSection>

<ManSection>
 <Attr Name="RightGroebnerBasisOfModule" Arg="M" Comm="for a PathAlgebraModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a PathAlgebraModule.
 </Description>
 <Returns>a right Groebner basis for the module <Arg>M</Arg>.</Returns>
 <Description>
 It checks if the acting algebra on the module <Arg>M</Arg> 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 <C>BasisVectors</C>.
 The underlying module is likewise returned by the command <C>UnderlyingModule</C>.
 The output of the function is satisfying the filter/category
 <C>IsRightPathAlgebraModuleGroebnerBasis</C>.
 </Description>
</ManSection>

<ManSection>
 <Oper Name="TargetVertex" Arg="v" Comm="for a PathAlgebraVector element"/>
 <Description>
 Arguments: <Arg>v</Arg> -- a PathAlgebraVector.
 </Description>
 <Returns>a vertex <Math>w</Math> such that <Math>v*w = v</Math>, if
 such a vertex exists, and fail otherwise.
 </Returns>
 <Description>
 Given a PathAlgebraVector <Arg>v</Arg>, if <Arg>v</Arg> is right
 uniform, this function finds the vertex <Math>w</Math> such that
 <Math>v*w = v</Math> whenever <Arg>v</Arg> is non-zero, and
 returns the zero path otherwise. If <Arg>v</Arg> is not right
 uniform it returns fail.
 </Description>
</ManSection>

<ManSection>
 <Attr Name="UniformGeneratorsOfModule" Arg="M" Comm="for a PathAlgebraModule"/>
 <Description>
 Arguments: <Arg>M</Arg> -- a <C>PathAlgebraModule</C>.
 </Description>
 <Returns>a set of right uniform generators of the mdoule <Arg>M</Arg>. If
 <Arg>M</Arg> is the zero module, then it returns an empty list.
 </Returns>
</ManSection>

<ManSection>
 <Func Name="Vectorize" Arg="M, components"
Comm=""/>
 <Description>
 Arguments: <Arg>M</Arg> -- a module over a path algebra, <Arg>components</Arg> -- a list of elements of <Arg>M</Arg>.
 </Description>
 <Returns>a vector in <Arg>M</Arg> from a list of path
--> --------------------

--> maximum size reached

--> --------------------

quality100%

¤ Dauer der Verarbeitung: 0.63 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.