4 Path Algebras

4.11 Categories and Properties of Quotients of Path Algebras

4.11-1 IsAdmissibleQuotientOfPathAlgebra

4.11-2 IsQuotientOfPathAlgebra

4.11-3 IsFiniteDimensional

4.11-4 IsCanonicalAlgebra

4.11-5 IsDistributiveAlgebra

4.11-6 IsFiniteGlobalDimensionAlgebra

4.11-7 IsGentleAlgebra

4.11-8 IsGorensteinAlgebra

4.11-9 IsHereditaryAlgebra

4.11-10 IsKroneckerAlgebra

4.11-11 IsMonomialAlgebra

4.11-12 IsNakayamaAlgebra

4.11-13 IsQuiverAlgebra

4.11-14 IsRadicalSquareZeroAlgebra

4.11-15 IsSchurianAlgebra

4.11-16 IsSelfinjectiveAlgebra

4.11-17 IsSemicommutativeAlgebra

4.11-18 IsSemisimpleAlgebra

4.11-19 IsSpecialBiserialAlgebra

4.11-20 IsStringAlgebra

4.11-21 IsSymmetricAlgebra

4.11-22 IsTriangularReduced

4.11-23 IsWeaklySymmetricAlgebra

4.11-24 BongartzTest

4.11-25 IsFiniteTypeAlgebra

4.11-1 IsAdmissibleQuotientOfPathAlgebra

4.11-2 IsQuotientOfPathAlgebra

4.11-3 IsFiniteDimensional

4.11-4 IsCanonicalAlgebra

4.11-5 IsDistributiveAlgebra

4.11-6 IsFiniteGlobalDimensionAlgebra

4.11-7 IsGentleAlgebra

4.11-8 IsGorensteinAlgebra

4.11-9 IsHereditaryAlgebra

4.11-10 IsKroneckerAlgebra

4.11-11 IsMonomialAlgebra

4.11-12 IsNakayamaAlgebra

4.11-13 IsQuiverAlgebra

4.11-14 IsRadicalSquareZeroAlgebra

4.11-15 IsSchurianAlgebra

4.11-16 IsSelfinjectiveAlgebra

4.11-17 IsSemicommutativeAlgebra

4.11-18 IsSemisimpleAlgebra

4.11-19 IsSpecialBiserialAlgebra

4.11-20 IsStringAlgebra

4.11-21 IsSymmetricAlgebra

4.11-22 IsTriangularReduced

4.11-23 IsWeaklySymmetricAlgebra

4.11-24 BongartzTest

4.11-25 IsFiniteTypeAlgebra

4.13 Attributes and Operations (for Quotients) of Path
Algebras

4.13-1 CartanMatrix

4.13-2 Centre/Center

4.13-3 ComplexityOfAlgebra

4.13-4 CoxeterMatrix

4.13-5 CoxeterPolynomial

4.13-6 Dimension

4.13-7 FrobeniusForm

4.13-8 FrobeniusLinearFunctional

4.13-9 GlobalDimension

4.13-10 LoewyLength

4.13-11 NakayamaAutomorphism

4.13-12 NakayamaPermutation

4.13-13 OrderOfNakayamaAutomorphism

4.13-14 RadicalSeriesOfAlgebra

4.13-1 CartanMatrix

4.13-2 Centre/Center

4.13-3 ComplexityOfAlgebra

4.13-4 CoxeterMatrix

4.13-5 CoxeterPolynomial

4.13-6 Dimension

4.13-7 FrobeniusForm

4.13-8 FrobeniusLinearFunctional

4.13-9 GlobalDimension

4.13-10 LoewyLength

4.13-11 NakayamaAutomorphism

4.13-12 NakayamaPermutation

4.13-13 OrderOfNakayamaAutomorphism

4.13-14 RadicalSeriesOfAlgebra

4.17 Tensor products of path algebras

4.17-1 QuiverProduct

4.17-2 QuiverProductDecomposition

4.17-3 IsQuiverProductDecomposition

4.17-4 IncludeInProductQuiver

4.17-5 ProjectFromProductQuiver

4.17-6 TensorProductOfAlgebras

4.17-7 TensorAlgebrasInclusion

4.17-8 SimpleTensor

4.17-9 TensorProductDecomposition

4.17-10 EnvelopingAlgebra

4.17-11 EnvelopingAlgebraHomomorphism

4.17-12 IsEnvelopingAlgebra

4.17-13 AlgebraAsModuleOverEnvelopingAlgebra

4.17-14 DualOfAlgebraAsModuleOverEnvelopingAlgebra

4.17-15 TrivialExtensionOfQuiverAlgebra

4.17-16 TrivialExtensionOfQuiverAlgebraProjection

4.17-1 QuiverProduct

4.17-2 QuiverProductDecomposition

4.17-3 IsQuiverProductDecomposition

4.17-4 IncludeInProductQuiver

4.17-5 ProjectFromProductQuiver

4.17-6 TensorProductOfAlgebras

4.17-7 TensorAlgebrasInclusion

4.17-8 SimpleTensor

4.17-9 TensorProductDecomposition

4.17-10 EnvelopingAlgebra

4.17-11 EnvelopingAlgebraHomomorphism

4.17-12 IsEnvelopingAlgebra

4.17-13 AlgebraAsModuleOverEnvelopingAlgebra

4.17-14 DualOfAlgebraAsModuleOverEnvelopingAlgebra

4.17-15 TrivialExtensionOfQuiverAlgebra

4.17-16 TrivialExtensionOfQuiverAlgebraProjection

A path algebra is an algebra constructed from a field \(F\) (see Chapter 56 and 57 in the **GAP** manual for information about fields) and a quiver \(Q\). The path algebra \(FQ\) contains all finite linear combinations of paths of \(Q\). This chapter describes the functions in **QPA** that deal with path algebras and quotients of path algebras. Path algebras are algebras, so see Chapter 60: Algebras in the **GAP** manual for functionality such as generators, basis functions, and mappings.

The only supported ordering of elements in a path algebra is length left lexicographic ordering. See 3.4 for more information.

`‣ PathAlgebra` ( F, Q ) | ( function ) |

Arguments: `F` -- a field, `Q` -- a quiver.

Returns: the path algebra `FQ` of `Q` over the field `F`.

For construction of fields, see the **GAP** documentation. The elements of the path algebra `FQ` will be ordered by left length-lexicographic ordering.

gap> Q := Quiver( ["u","v"] , [ ["u","u","a"], ["u","v","b"], > ["v","u","c"], ["v","v","d"] ] ); <quiver with 2 vertices and 4 arrows> gap> F := Rationals; Rationals gap> FQ := PathAlgebra(F,Q); <Rationals[<quiver with 2 vertices and 4 arrows>]>

`‣ IsPathAlgebra` ( object ) | ( property ) |

Arguments: `object` -- any object in **GAP**.

Returns: true whenever `object` is a path algebra.

gap> IsPathAlgebra(FQ); true

`‣ AssociatedMonomialAlgebra` ( A ) | ( attribute ) |

Arguments: `A` -- a quiver algebra.

Returns: the associated monomial algebra of `A` with respect to the Groebner basis the path algebra is endoved with.

`‣ QuiverOfPathAlgebra` ( FQ ) | ( attribute ) |

Arguments: `FQ` -- a path algebra.

Returns: the quiver from which `FQ` was constructed.

gap> QuiverOfPathAlgebra(FQ); <quiver with 2 vertices and 4 arrows>

`‣ OrderingOfAlgebra` ( FQ ) | ( attribute ) |

Arguments: `FQ` -- a path algebra.

Returns: the ordering of the quiver of the path algebra.

*Note:* As of the current version of **QPA**, only left length lexicographic ordering is supported.

`‣ .` ( FQ, generator ) | ( operation ) |

Arguments: `FQ` -- a path algebra, `generator` -- a vertex or an arrow in the quiver `Q`.

Returns: the `generator` as an element of the path algebra.

Other elements of the path algebra can be constructed as linear combinations of the generators. For further operations on elements, see below.

gap> FQ.a; (1)*a gap> FQ.v; (1)*v gap> elem := 2*FQ.a - 3*FQ.v; (-3)*v+(2)*a

`‣ ElementOfPathAlgebra` ( PA, path ) | ( operation ) |

Arguments: `PA` -- a path algebra, `path` -- a path in the quiver from which `PA` was constructed.

Returns: The embedding of `path` into the path algebra `PA`, or it returns false if `path` is not an element of the quiver from which `PA` was constructed.

`‣ <` ( a, b ) | ( operation ) |

Arguments: `a` and `b` -- two elements of the same path algebra.

Returns: True whenever `a` is smaller than `b`, according to the ordering of the path algebra.

`‣ IsLeftUniform` ( element ) | ( operation ) |

Arguments: `element` -- an element of the path algebra.

Returns: true if each monomial in `element` has the same source vertex, false otherwise.

`‣ IsRightUniform` ( element ) | ( operation ) |

Arguments: `element` -- an element of the path algebra.

Returns: true if each monomial in `element` has the same target vertex, false otherwise.

`‣ IsUniform` ( element ) | ( operation ) |

Arguments: `element` -- an element of the path algebra.

Returns: true whenever `element` is both left and right uniform.

gap> IsLeftUniform(elem); false gap> IsRightUniform(elem); false gap> IsUniform(elem); false gap> another := FQ.a*FQ.b + FQ.b*FQ.d*FQ.c*FQ.b*FQ.d; (1)*a*b+(1)*b*d*c*b*d gap> IsLeftUniform(another); true gap> IsRightUniform(another); true gap> IsUniform(another); true

`‣ LeadingTerm` ( element ) | ( operation ) |

`‣ Tip` ( element ) | ( operation ) |

Arguments: `element` -- an element of the path algebra.

Returns: the term in `element` whose monomial is largest among those monomials that have nonzero coefficients (known as the "tip" of `element`).

*Note: * The two operations are equivalent.

`‣ LeadingCoefficient` ( element ) | ( operation ) |

`‣ TipCoefficient` ( element ) | ( operation ) |

Arguments: `element` -- an element of the path algebra.

Returns: the coefficient of the tip of `element` (which is an element of the field).

*Note: * The two operations are equivalent.

`‣ LeadingMonomial` ( element ) | ( operation ) |

`‣ TipMonomial` ( element ) | ( operation ) |

Arguments: `element` -- an element of the path algebra.

Returns: the monomial of the tip of `element` (which is an element of the underlying quiver, not of the path algebra).

*Note: * The two operations are equivalent.

gap> elem := FQ.a*FQ.b*FQ.c + FQ.b*FQ.d*FQ.c+FQ.d*FQ.d; (1)*d^2+(1)*a*b*c+(1)*b*d*c gap> LeadingTerm(elem); (1)*b*d*c gap> LeadingCoefficient(elem); 1 gap> mon := LeadingMonomial(elem); b*d*c gap> mon in FQ; false gap> mon in Q; true

`‣ MakeUniformOnRight` ( elems ) | ( operation ) |

Arguments: `elems` -- a list of elements in a path algebra.

Returns: a list of right uniform elements generated by each element of `elems`.

`‣ MappedExpression` ( expr, gens1, gens2 ) | ( operation ) |

Arguments: `expr` -- element of a path algebra, `gens1` and `gens2` -- equal-length lists of generators for subalgebras.

Returns: `expr` as an element of the subalgebra generated by `gens2`.

The element `expr` must be in the subalgebra generated by `gens1`. The lists define a mapping of each generator in `gens1` to the corresponding generator in `gens2`. The value returned is the evaluation of the mapping at `expr`.

`‣ SupportOfQuiverAlgebraElement` ( algebra, element ) | ( operation ) |

`‣ LeftSupportOfQuiverAlgebraElement` ( algebra, element ) | ( operation ) |

`‣ RIghtSupportOfQuiverAlgebraElement` ( algebra, element ) | ( operation ) |

Arguments: `algebra` -- a QuiverAlgebra, `element` -- an element of the QuiverAlgebra

Returns: the second version returns a list of the index of the vertices such that the product from the left is non-zero, the third version returns a list of the index of the vertices such that the product from the right is non-zero, and the first version returns the both of the previous lists of indices of vertices.

`‣ VertexPosition` ( element ) | ( operation ) |

Arguments: `element` -- an element of the path algebra on the form \(k*v\), where \(v\) is a vertex of the underlying quiver and \(k\) is an element of the field.

Returns: the position of the vertex `v` in the list of vertices of the quiver.

`‣ RelationsOfAlgebra` ( A ) | ( attribute ) |

Arguments: `A` -- a quiver algebra.

Returns: a set of generators for the ideal in the path algebra \(kQ\) from which the algebra `FQ` was constructed. If `A` is a path algebra, then an empty list is returned.

In the introduction we saw already one way of constructing a quotient of a path algebra. In addition to this there are at least two other ways of constructing a quotient of a path algebra; one with factoring out an ideal and one where a Groebner basis is attached to the quotient. We discuss these two next.

For several functions in **QPA** to function properly one needs to have a Groebner basis attached to the quotient one wants to construct, or equivalently a Groebner basis for the ideal one is factoring out. For this to work the ideal must admit a finite Groebner basis. However, to our knowledge there is no algorithm for determining if an ideal has a finite Groebner basis. On the other hand, it is known that if the factor algebra is finite dimensional, then the ideal has a finite Groebner basis (independent of the ordering of the elements, see [Gre00] ). In addition to having a finite Groebner basis, several functions also need that the factoring ideal is admissible. A quotient of a path algebra by an admissible ideal belongs to the category `IsAdmissibleQuotientOfPathAlgebra`

(4.11-1). The method used in the introduction constructs a quotient in this category. However, there are situations where it is interesting to analyze quotients of path algebras by a non-admissible ideal, so we provide also additional methods.

In the example below, we construct a factor of a path algebra purely with commands in **GAP** (cf. also Chapter 60: Algebras in the **GAP** manual on how to construct an ideal and a quotient of an algebra). Functions which use Groebner bases like `IsFiniteDimensional`

(4.11-3), `Dimension`

(4.13-6), `IsSpecialBiserialAlgebra`

(4.11-19) or a membership test `\in`

(4.7-6) will work properly (they simply compute the Groebner basis if it is necessary). But some "older" functions (like `IndecProjectiveModules`

(6.5-5)) can fail or give an incorrect answer! This way of constructing a quotient of a path algebra can be useful e.g. if we know that computing a Groebner basis will take a long time and we do not need this because we want to deal only with modules.

gap> Q := Quiver( 1, [ [1,1,"a"], [1,1,"b"] ] ); <quiver with 1 vertices and 2 arrows> gap> kQ := PathAlgebra(Rationals, Q); <Rationals[<quiver with 1 vertices and 2 arrows>]> gap> gens := GeneratorsOfAlgebra(kQ); [ (1)*v1, (1)*a, (1)*b ] gap> a := gens[2]; (1)*a gap> b := gens[3]; (1)*b gap> relations := [a^2,a*b-b*a, b*b]; [ (1)*a^2, (1)*a*b+(-1)*b*a, (1)*b^2 ] gap> I := Ideal(kQ,relations); <two-sided ideal in <Rationals[<quiver with 1 vertices and 2 arrows>]> , (3 generators)> gap> A := kQ/I; <Rationals[<quiver with 1 vertices and 2 arrows>]/ <two-sided ideal in <Rationals[<quiver with 1 vertices and 2 arrows>]> , (3 generators)>> gap> IndecProjectiveModules(A); Compute a Groebner basis of the ideal you are factoring out with before \ you form the quotient algebra, or you have entered an algebra which \ is not finite dimensional. fail

To resolve this matter, we need to compute the Gröbner basis of the ideal generated by the relations in \(kQ\) (yes, it seems like we are going in circles here. Remember, then, that an ideal in the "mathematical sense" may exist independently of the a corresponding `Ideal`

object in **GAP**. Also, Gröbner bases in **QPA** are handled by the **GBNP** package, with constructor methods not dependent on `Ideal`

objects. After creating the ideal \(I\), we need to perform yet another Gröbner basis operation which just set a respective attribute for \(I\), see `GroebnerBasis`

(5.1-2).

gap> gb := GBNPGroebnerBasis(relations,kQ); [ (1)*a^2, (-1)*a*b+(1)*b*a, (1)*b^2 ] gap> I := Ideal(kQ,gb); <two-sided ideal in <Rationals[<quiver with 1 vertices and 2 arrows>]>, (3 generators)> gap> GroebnerBasis(I,gb); <complete two-sided Groebner basis containing 3 elements> gap> IndecProjectiveModules(A); fail gap> A := kQ/I; <Rationals[<quiver with 1 vertices and 2 arrows>]/ <two-sided ideal in <Rationals[<quiver with 1 vertices and 2 arrows>]>, (3 generators)>> gap> IndecProjectiveModules(A); [ <[ 4 ]> ]

Note that the instruction `A := kQ/relations;`

used in Introduction is exactly an abbreviation for a sequence of instructions with Groebner basis as in above example.

Most **QPA** operations working on algebras handle path algebras and quotients of path algebras in the same way (when this makes sense). However, there are still a few operations which does not work properly when given a quotient of a path algebra. When constructing a quotient of a path algebra one needs define the ideal one is factoring out. Above this has been done with the commands

gap> gens := GeneratorsOfAlgebra(kQ); [ (1)*v1, (1)*a, (1)*b ] gap> a := gens[2]; (1)*a gap> b := gens[3]; (1)*b

The following command makes this process easier.

`‣ AssignGeneratorVariables` ( A ) | ( operation ) |

Arguments: `A` -- a quiver algebra.

Returns: Takes a quiver algebra `A` as an argument and creates variables, say \(v_1,...,v_n\) for the vertices, and \(a_1,...,a_t\) for the arrows for the corresponding elements in `A`, whenever the quiver for the quiver algebra `A` is was constructed with the vertices being named \(v_1,...,v_n\) and the arrows being named \(a_1,...,a_t\).

Here is an example of its use.

gap> AssignGeneratorVariables(kQ); #I Assigned the global variables [ v1, a, b ] gap> v1; a; b; (1)*v1 (1)*a (1)*b

`‣ Ideal` ( FQ, elems ) | ( function ) |

Arguments: `FQ` -- a path algebra, `elems` -- a list of elements in `FQ`.

Returns: the ideal of `FQ` generated by `elems` with the property `IsIdealInPathAlgebra`

(4.8-2).

For more on ideals, see the **GAP** reference manual (Chapter 60.6).

*Technical info:* Ideal is a synonym for a global GAP function TwoSidedIdeal which calls an operation TwoSidedIdealByGenerators (synonym IdealByGenerators) for an algebra (FLMLOR).

gap> gb := GBNPGroebnerBasis(relations,kQ); [ (1)*a^2, (-1)*a*b+(1)*b*a, (1)*b^2 ] gap> I := Ideal(kQ,gb); <two-sided ideal in <Rationals[<quiver with 1 vertices and 2 arrows>]> , (3 generators)> gap> GroebnerBasis(I,gb); <complete two-sided Groebner basis containing 3 elements> gap> IndecProjectiveModules(A); [ <[ 4 ]> ] gap> A := kQ/I; <Rationals[<quiver with 1 vertices and 2 arrows>]/ <two-sided ideal in <Rationals[<quiver with 1 vertices and 2 arrows>]> , (3 generators)>> gap> IndecProjectiveModules(A); [ <[ 4 ]> ] true

`‣ IdealOfQuotient` ( A ) | ( attribute ) |

Arguments: `A` -- a quiver algebra.

Returns: the ideal in the path algebra \(kQ\) from which `A` was constructed.

`‣ PathsOfLengthTwo` ( Q ) | ( operation ) |

Arguments: `Q` -- a quiver.

Returns: a list of all paths of length two in `Q`, sorted by `<`

. Fails with error message if `Q` is not a Quiver object.

`‣ NthPowerOfArrowIdeal` ( FQ, n ) | ( operation ) |

Arguments: `FQ` -- a path algebra, `n` -- a positive integer.

Returns: the ideal generated all the paths of length `n` in `FQ`.

`‣ AddNthPowerToRelations` ( FQ, rels, n ) | ( operation ) |

Arguments: `FQ` -- a path algebra, `rels` -- a (possibly empty) list of elements in `FQ`, `n` -- a positive integer.

Returns: the list `rels` with the paths of length `n` of `FQ` appended (will change the list `rels`).

`4.7-6 \in`

`‣ \in` ( elt, I ) | ( operation ) |

Arguments: `elt` - an element in a path algebra, `I` - an ideal in the same path algebra (i.e. with `IsIdealInPathAlgebra`

(4.8-2) property).

Returns: true, if `elt` belongs to `I`.

It performs the membership test for an ideal in path algebra using completely reduced Groebner bases machinery.

*Technical info:* For the efficiency reasons, it computes Groebner basis for `I` only if it has not been computed yet. Similarly, it performs CompletelyReduceGroebnerBasis only if it has not been reduced yet. The method can change the existing Groebner basis.

*Remark:* It works only in case `I` is in the arrow ideal.

`‣ IsAdmissibleIdeal` ( I ) | ( property ) |

Arguments: `I` -- an IsIdealInPathAlgebra object.

Returns: true whenever `I` is an *admissible* ideal in a path algebra, i.e. `I` is a subset of \(J^2\) and `I` contains \(J^n\) for some \(n\), where \(J\) is the arrow ideal.

*Technical note:* The second condition is checked by the nilpotency index of the radical and checking if the ideal generated by the arrows to one plus this index is in the ideal of the relations (this uses Groebner bases machinery).

`‣ IsIdealInPathAlgebra` ( I ) | ( property ) |

Arguments: `I` -- an IsFLMLOR object.

Returns: true whenever `I` is an ideal in a path algebra.

`‣ IsMonomialIdeal` ( I ) | ( property ) |

Arguments: `I` -- an IsIdealInPathAlgebra object.

Returns: true whenever `I` is a *monomial* ideal in a path algebra, i.e. `I` is generated by a set of monomials (= "zero-relations").

*Technical note:* It uses the observation: `I` is a monomial ideal iff Groebner basis of `I` is a set of monomials. It computes Groebner basis for `I` only in case it has not been computed yet and a usual set of generators (GeneratorsOfIdeal) is not a set of monomials.

`‣ IsQuadraticIdeal` ( rels ) | ( operation ) |

Arguments: `rels` -- a list of elements in a path algebra.

Returns: true whenever `rels` is a list of elements in the linear span of degree two elements of a path algebra. It returns false whenever `rels` is a list of elements in a path algebra, but not in the linear span of degree two of a path algebra. Otherwise it returns fail.

`‣ ProductOfIdeals` ( I, J ) | ( operation ) |

Arguments: `I, J` -- two ideals in a path algebra `KQ`.

Returns: the ideal formed by the product of the ideals `I` and `J`, whenever the ideal `J` admits finitely many nontips in `KQ`.

The function checks if the two ideals are ideals in the same path algebra and that `J` admits finitely many nontips in `KQ`.

`‣ QuadraticPerpOfPathAlgebraIdeal` ( rels ) | ( operation ) |

Arguments: `rels` -- a list of elements in a path algebra.

Returns: fail if `rels` is not a list of elements in the linear span of degree two elements of a path algebra `KQ`. Otherwise it returns a list of length two, where the first element is a set of generators for the ideal \(\textit{rels}^\perp\) in opposite algebra of `KQ` and the second element is the opposite algebra of `KQ`.

For many of the functions related to quotients, you will need to compute a Groebner basis of the ideal. This is done with the GBNP package. The following example shows how to set a Groebner basis for an ideal (note that this must be done before the quotient is constructed). See the next two chapters for more on Groebner bases.

gap> rels := [FQ.a - FQ.b*FQ.c, FQ.d*FQ.d]; [ (1)*a+(-1)*b*c, (1)*d^2 ] gap> gb := GBNPGroebnerBasis(rels, FQ); [ (-1)*a+(1)*b*c, (1)*d^2 ] gap> I := Ideal(FQ, gb); <two-sided ideal in <Rationals[<quiver with 2 vertices and 4 arrows>]> , (2 generators)> gap> GroebnerBasis(I, gb); <complete two-sided Groebner basis containing 2 elements> gap> quot := FQ/I; <Rationals[<quiver with 2 vertices and 4 arrows>]/ <two-sided ideal in <Rationals[<quiver with 2 vertices and 4 arrows>]> , (2 generators)>>

`‣ GroebnerBasisOfIdeal` ( I ) | ( attribute ) |

Arguments: `I` -- an ideal in path algebra.

Returns: a Groebner basis of ideal `I` (if it has been already computed!).

This attribute is set only by an operation `GroebnerBasis`

(5.1-2).

`‣ IsAdmissibleQuotientOfPathAlgebra` ( A ) | ( filter ) |

Arguments: `A` -- any object.

Returns: true whenever `A` is a quotient of a path algebra by an admissible ideal constructed by the command `\/`

with arguments a path algebra and a list of relations, `KQ/rels`

, where `rels`

is a list of relations. Otherwise it returns an error message.

`‣ IsQuotientOfPathAlgebra` ( object ) | ( property ) |

Argument: `object` -- any object in **GAP**.

Returns: true whenever `object` is a quotient of a path algebra.

gap> quot := FQ/I; <Rationals[<quiver with 2 vertices and 4 arrows>]/ <two-sided ideal in <Rationals[<quiver with 2 vertices and 4 arrows>]> , (2 generators)>> gap> IsQuotientOfPathAlgebra(quot); true gap> IsQuotientOfPathAlgebra(FQ); false

`‣ IsFiniteDimensional` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true whenever `A` is a finite dimensional algebra.

*Technical note:* For a path algebra it uses a standard **GAP** method. For a quotient of a path algebra it uses Groebner bases machinery (it computes Groebner basis for the ideal only in case it has not been computed yet).

`‣ IsCanonicalAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true if `A` has been constructed by the operation `CanonicalAlgebra`

(4.15-2), otherwise "Error, no method found".

`‣ IsDistributiveAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true if `A` is an admissible quotient of a path algebra and distributive. Otherwise it returns false if `A` is an admissible quotient of a path algebra and distributive. If `A` is a quotient of a path algebra, but not an admissible quotient, then it looks for other methods. There are not further methods implemented in QPA as of now.

`‣ IsFiniteGlobalDimensionAlgebra` ( A ) | ( property ) |

Arguments: `A` - an algebra over a field.

Returns: true if it is known that the entered algebra `A` has finite global dimension.

There is no method associated to this, so if it is not known that the algebra has finite global dimension, then an error message saying "no method found!" is return.

`‣ IsGentleAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true if the algebra `A` is a gentle algebra. Otherwise false.

`‣ IsGorensteinAlgebra` ( A ) | ( property ) |

Arguments: `A` -- an algebra.

Returns: true if it is known that `A` is a Gorenstein algebra. If unknown it returns an error message saying "no method found!".

There is no method installed for this yet.

`‣ IsHereditaryAlgebra` ( A ) | ( property ) |

Arguments: `A` -- an admissible quotient of a path algebra.

Returns: true if `A` is a hereditary algebra and false otherwise.

`‣ IsKroneckerAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true if `A` has been constructed by the operation `KroneckerAlgebra`

(4.15-3), otherwise "Error, no method found".

`‣ IsMonomialAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a quiver algebra.

Returns: true when `A` is given as `kQ/I`

and `I`

is a monomial ideal in `kQ`

, otherwise it returns false.

`‣ IsNakayamaAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true if `A` has been constructed by the operation `NakayamaAlgebra`

(4.15-4), otherwise "Error, no method found".

`‣ IsQuiverAlgebra` ( A ) | ( filter ) |

Arguments: `A` -- an algebra.

Returns: true if `A` is a path algebra or a quotient of a path algebra algebra, otherwise false.

`‣ IsRadicalSquareZeroAlgebra` ( A ) | ( property ) |

Arguments: `A` -- an algebra.

Returns: true if `A` is a radical square zero algebra, otherwise false.

`‣ IsSchurianAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true if `A` is a schurian algebra. By definition it means that: for all \(x,y\in Q_0\) we have \(\dim A(x,y)\leq 1 \).

*Note:* This method fail when a Groebner basis for ideal has not been computed before creating a quotient!

`‣ IsSelfinjectiveAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: fail if `A` is not finite dimensional. Otherwise it returns true or false according to whether `A` is selfinjective or not.

`‣ IsSemicommutativeAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true if `A` is a semicommutative algebra. By definition it means that:

1. `A` is schurian (cf. `IsSchurianAlgebra`

(4.11-15)).

2. Quiver \(Q\) of `A` is acyclic (cf. `IsAcyclicQuiver`

(3.3-2)).

3. For all pairs of vertices \((x,y)\) the following condition is satisfied: for every two paths \(P,P'\) from \(x\) to \(y\): \(P\in I \Leftrightarrow P'\in I\).

*Note:* This method fail when a Groebner basis for ideal has not been computed before creating a quotient!

`‣ IsSemisimpleAlgebra` ( A ) | ( property ) |

Arguments: `A` - an algebra over a field.

Returns: true if the entered algebra `A` is semisimple, false otherwise.

Checks if the algebra is finite dimensional. If it is an admissible quotients of a path algebra, it only checks if the underlying quiver has any arrows or not. Otherwise, it computes the radical of the algebra and checks if it is zero.

`‣ IsSpecialBiserialAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true whenever `A` is a *special biserial algebra*, i.e. `A=KQ/I`, where `Q` is `IsSpecialBiserialQuiver`

(4.15-9), `I` is an admissible ideal (`IsAdmissibleIdeal`

(4.8-1)) and `I` satisfies the "special biserial" conditions, i.e.:

for any arrow \(a\) there exists at most one arrow \(b\) such that \(ab\) does not belong to

`I`there exists at most one arrow \(c\) such that \(ca\) does not belong to \(I\).

*Note:* e.g. a path algebra of one loop IS NOT special biserial, but one loop IS special biserial quiver (see `IsSpecialBiserialQuiver`

(4.15-9) for examples).

`‣ IsStringAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: true whenever `A` is a *string* (special biserial) algebra, i.e. `A=KQ/I` is a special biserial algebra (`IsSpecialBiserialAlgebra`

(4.11-19) and `I` is generated by monomials (= "zero-relations") (cf. `IsMonomialIdeal`

(4.8-3)). See `IsSpecialBiserialQuiver`

(4.15-9) for examples.

`‣ IsSymmetricAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: fail if `A` is not finite dimensional or does not have a Groebner basis. Otherwise it returns true or false according to whether `A` is symmetric or not.

`‣ IsTriangularReduced` ( A ) | ( property ) |

Arguments: `A` - a finite dimensional QuiverAlgebra.

Returns: `false`

if the algebra `A` is triangular reducable, that is, there is a sum over vertices \(e\) such that \(eA(1 - e) = (0)\) for \(e\neq 0,1\). Otherwise, it returns `true`

.

The function checks if the algebra `A` is finite dimensional and gives an error message otherwise.

`‣ IsWeaklySymmetricAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: fail if `A` is not finite dimensional or does not have a Groebner basis. Otherwise it returns true or false according to whether `A` is weakly symmetric or not.

`‣ BongartzTest` ( A, bound ) | ( property ) |

Arguments: `A, bound` -- a path algebra or a quotient of a path algebra and an integer.

Returns: false if there exists a \(\tau\)-translate of a simple, injective or projective `A`-module up to the power `bound` has dimension greater or equal to \(\max\{2\dim A, 30\}\). Then `A` is of infinite representation type. Returns fail otherwise.

`‣ IsFiniteTypeAlgebra` ( A ) | ( property ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: Returns true if `A` is of finite representation type. Returns false if `A` is of infinite representation type. Returns fail if we can not determine the representation type (i.e. it impossible from theoretical/algorithmic point of view or a suitable criterion has not been implemented yet; the implementation is in progress). Note: in case `A` is a path algebra the function is completely implemented.

gap> Q := Quiver(5, [ [1,2,"a"], [2,4,"b"], [3,2,"c"], [2,5,"d"] ]); <quiver with 5 vertices and 4 arrows> gap> A := PathAlgebra(Rationals, Q); <Rationals[<quiver with 5 vertices and 4 arrows>]> gap> IsFiniteTypeAlgebra(A); Infinite type! Quiver is not a (union of) Dynkin quiver(s). false gap> quo := A/[A.a*A.b, A.c*A.d];; gap> IsFiniteTypeAlgebra(quo); Finite type! Special biserial algebra with no unoriented cycles in Q. true

A quiver is a quadruple \(Q = (Q_0, Q_1, s, t)\) where \(Q_0\) is the set of vertices, \(Q_1\) is the set of arrows and \(s, t : Q_1 \rightarrow Q_0\) are source and target functions where for each \( \alpha \in Q_1\), \(s(\alpha)\) and \(t(\alpha)\) denotes starting and ending vertex of \(\alpha\) respectively. For the functions defined in this section the quiver has to be constructed using first construction of ???. The arrows in \(Q_1\) should be small Roman letters defined in alphabetical order as in the example below. These operations can handle string algebras with number of arrows less than or equal to 26. Say that a finite sequence \(\alpha_n\alpha_{n-1}...\alpha_1\) is a path in \(Q\) if \(s(\alpha_{i+1}) = t(\alpha_i)\) for all \(1 \leq i \leq n-1\) The source and target of the path are \(s(\alpha_1)\) and \(t(\alpha_n)\) respectively. We denote by \(\rho\) a set of monomial relations on \(Q\). Every relation in \(\rho\) is a finite sequence \(\alpha_1 \alpha_{2}...\alpha_n\) of elements of \(Q_1\) with \(n \geq 2\) such that \(\alpha_n \alpha_{n-1}...\alpha_1\) is a path. \(\newline\) For a quiver \(Q\), we define two functions \(\sigma, \epsilon : Q_1 \rightarrow \{-1, 1\}\) such that

if \(b_1 \neq b_2\) such that \(s(b_1) = s(b_2)\), then \(\sigma(b_1) = -\sigma(b_2)\);

if \(b_1 \neq b_2\) such that \(t(b_1) = t(b_2)\), then \(\epsilon(b_1) = -\epsilon(b_2)\);

if \(s(b_1) = t(b_2)\) and \(b_1b_2 \notin \rho\), then \(\sigma(b_1) = -\epsilon(b_2)\).

Let us denote the inverse of the set of arrows in \(Q_1\) by the corresponding capital letters. For example if \(b\) is an arrow in \(Q_1\) the its inverse is denoted by \(B\). The set of the inverse arrows is denoted by \(Q_1^{-1}\). We extend the definition of \(\sigma\) and \(\epsilon\) to \(Q_1 \cup Q_1^{-1}\) so that \(\sigma(B) = \epsilon(b)\) and \(\epsilon(B) = \sigma(b)\) for all \(b \in Q_1\). Note that a *string* of positive length is a walk along the arrows of \(Q\) and their inverses such that it does not contain paths obtained by reversing relations in \(\rho\) and their inverses as substrings. We also extend the definition of \(\sigma\) and \(\epsilon\) to all strings; if \(\alpha = \alpha_n ...\alpha_2 \alpha_1\), then \(\sigma(\alpha) = \sigma(\alpha_1)\) and \(\epsilon(\alpha) = \epsilon(\alpha_n)\). \(\newline\) For each vertex \(v\in Q_0\), we have a zero length lazy string starting and ending at vertex \(v\), denoted by \(1_v\). The inverse of this string is \(1_v\) itself. The main purpose of defining \(\sigma\) and \(\epsilon\) is to distinguish \(1_v\) with its inverse. We denote this zero length string as \((v,1)\) and \((v,-1)\) and set \(\sigma((v,i)) := -i\) and \(\epsilon((v,i)) := i\). The concatenation \((v,i)u\) of strings is defined if and only if \(\epsilon(u) = i\) and the concatenation \(u(v,i)\) is defined if and only if \(\sigma(u) = -i\). Moreover if \(\alpha = \alpha_n \alpha_{n-1} ... \alpha_2 \alpha_1\) and \(\beta = \beta_m \beta_{m-1} ... \beta_2 \beta_1\) are two strings such that \(s(\alpha) = t(\beta)\), their concatenation is the string \(\alpha\beta = \alpha_n ... \alpha_1 \beta_m ... \beta_1\). Note that, for a given quiver \(Q\), the functions \(\sigma, \epsilon\) are not unique. A choice of \(\sigma\) and \(\epsilon\) functions is computed within our codes and utilized in other functions.

`‣ IsValidString` ( Q, rho, input_str ) | ( operation ) |

Arguments: `Q` -- a quiver, `rho` -- a list of monomial relations, `input_str` -- an input collection of characters.

Returns: "Not a String Algebra" if the algebra presented by `(Q,rho)` is not a string algebra, "Valid Positive Length String" if `input_str` is a string of positive length in the corresponding string algebra, "Valid Zero Length String", if `input_str` is a zero length string in the corresponding string algebra, "Invalid String" if `input_str` is not a string in the corresponding string algebra

`‣ StringsLessThan` ( Q, rho, level ) | ( operation ) |

Arguments: `Q` -- a quiver, `rho` -- a list of monomial relations, `level` -- an integer.

Returns: "Not a String Algebra" if the algebra presented by `(Q,rho)` is not a string algebra, an empty list if `level` is a negative integer, a list of all strings of length less than or equal to `level` if `level` is a non-negative integer.

A string \(u\) is called \(\textbf{cyclic}\) if \(s(u) = t(u)\). A cyclic string is called \(\textbf{primitive}\) if it can not be written as an n-fold concatenation \(\mathfrak{v}^n\) for any string \(\mathfrak{v}\) and any \(n \in \mathbb{N}\). If \(\mathfrak{b}\) is a primitive cyclic string such that \(\mathfrak{b}^m\) exists, for all \(m \in \mathbb{N}\), then \(\mathfrak{b} \) is called a \(\textbf{band}\).

`‣ IsABand` ( Q, rho, input_str ) | ( operation ) |

Arguments: `Q` -- a quiver, `rho` -- a list of monomial relations, `input_str` -- an input collection of characters.

Returns: "Not a String Algebra" if the algebra presented by `(Q,rho)` is not a string algebra, "Invalid String" if `input_str` is not a string in the corresponding string algebra, \(0\) if `input_str` is a valid string but not a band, \(1\) if `input_str` is a band in the corresponding string algebra.

`‣ BandsLessThan` ( Q, rho, level ) | ( operation ) |

Arguments: `Q` -- a quiver, `rho` -- a list of monomial relations, `level` -- an integer.

Returns: "Not a String Algebra" if the algebra presented by `(Q,rho)` is not a string algebra, an empty list if `level` is a negative integer, a list of all bands of length less than or equal to `level` if `level` is a non-negative integer.

Two bands \(\mathfrak{b}_1\) and \(\mathfrak{b}_2\) of a string algebra are said to be equivalent if they are cyclic permutations of each other. For any band \(\mathfrak{b}\), output of \(\texttt{BandsLessThan}\) function contains all bands equivalent to \(\mathfrak{b}\). A representative of each equivalence class is chosen such that the first syllable from right is an inverse syllable and the last syllable from right is a direct syllable. This new list is returned as the output of the following function.

`‣ BandRepresentativesLessThan` ( Q, rho, level ) | ( operation ) |

Arguments: `Q` -- a quiver, `rho` -- a list of monomial relations, `level` -- an integer.

Returns: "Not a String Algebra" if the algebra presented by `(Q,rho)` is not a string algebra, an empty list if `level` is negative integer, a list of all band representatives of length less than or equal to `level` if `level` is a non-negative integer.

A string algebra with finite number of bands is called a domestic string algebra.

`‣ IsDomesticStringAlgebra` ( Q, rho ) | ( operation ) |

Arguments: `Q` -- a quiver, `rho` -- a list of monomial relations.

Returns: "Not a String Algebra" if the algebra presented by `(Q,rho)` is not a string algebra, \(0\) if the corresponding string algebra is non-domestic, \(1\) if the corresponding string algebra is domestic.

A string is \(\textbf{band-free}\) if it does not contain any cyclic permutation of a band as a substring. Let \(Ba(\Lambda)\) denote the collection of all bands up to cyclic permutation and \(Q_0^{Ba}\) denote a fixed set of representatives of bands in \(Ba(\Lambda)\). For \(\mathfrak{b}_1, \mathfrak{b}_2 \in Q_0^{Ba}\), we say that a finite string \(u\) is a weak bridge \(\mathfrak{b}_1 \xrightarrow{u} \mathfrak{b}_2\) if it is band-free and if \(\mathfrak{b}_2 u \mathfrak{b}_1\) is a string.\(\newline\) We say that a weak bridge \(\mathfrak{b}_1 \xrightarrow{u} \mathfrak{b}_2\) is a bridge if there is \(\textbf{no}\) \(\mathfrak{b}\in Q_0^{Ba}\) and weak bridges \(\mathfrak{b}_1 \xrightarrow{u_1} \mathfrak{b}\) and \(\mathfrak{b} \xrightarrow{u_2} \mathfrak{b}_2\) such that one of the following holds :

\(\mathfrak{u} = \mathfrak{u_2}\mathfrak{u_1}\), where \(\mathfrak{u_1}\) and \(\mathfrak{u_2}\) are positive length strings,

\(\mathfrak{u} = \mathfrak{u_2'}\mathfrak{u_1'}\), for some positive length strings \(\mathfrak{u_1'}, \mathfrak{u_2'}\) such that \(\mathfrak{u_2} = \mathfrak{u_2'} \mathfrak{u_2''}\), \(\mathfrak{u_1} = \mathfrak{u_1''} \mathfrak{u_1'}\) and \(\mathfrak{b} = \mathfrak{u_1''} \mathfrak{u_2''}\).

`‣ BridgeQuiver` ( Q, rho ) | ( operation ) |

Arguments: `Q` a quiver, `rho` a list of monomial relations.

Returns: "Not a String Algebra" if the algebra presented by `(Q,rho)` is not a string algebra, \(0\) if the corresponding string algebra is non-domestic, the bridge quiver of the corresponding string algebra if it is domestic.

`‣ LocalARQuiver` ( Q, rho, input_str ) | ( operation ) |

Arguments: `Q` -- a quiver, `rho` -- a list of monomial relations, `input_str` -- an input collection of characters.

Returns: "Not a String Algebra" if the algebra presented by `(Q,rho)` is not a string algebra, the list of (equivalence classes of) irreducible maps, i.e., the arrows of the Auslander-Reiten quiver, whose source or target is the string module corresponding to `input_str`.

gap> Q := Quiver(4, [[1,2,"a"], [1,2,"b"], [2,3,"c"], [3,4,"d"], [3,4,"e"]]); <quiver with 4 vertices and 5 arrows> gap> rho := ["bc", "cd"]; [ "bc", "cd" ] gap> IsValidString(Q,rho,"eca"); "Valid Positive Length String" gap> StringsLessThan(Q,rho,2); [ "(1,1)", "b", "Ab", "(1,-1)", "a", "ca", "Ba", "(2,1)", "c", "B", "ec", "aB", "(2,-1)", "A", "bA", "(3,1)", "e", "De", "(3,-1)", "d", "C", "Ed", "AC", "(4,1)", "E", "dE", "CE", "(4,-1)", "D", "eD" ] gap> IsABand(Q,rho,"eca"); 0 gap> IsABand(Q,rho,"Ab"); 1 gap> BandsLessThan(Q,rho,3); [ "Ab", "Ba", "aB", "bA", "De", "Ed", "dE", "eD" ] gap> BandRepresentativesLessThan(Q,rho,3); [ "aB", "bA", "dE", "eD" ] gap> IsDomesticStringAlgebra(Q,rho); true gap> Q1 := BridgeQuiver(Q,rho); <quiver with 4 vertices and 2 arrows> gap> Display(Q1); Quiver( ["v1","v2","v3","v4"], [["v3","v2","CE"],["v1","v4","ec"]] ) gap> LocalARQuiver(Q,rho,"eca"); [ "The canonical embedding StringModule(eca) to StringModule(eDeca)", "The canonical projection StringModule(ecaBa) to StringModule(eca)" ]

`‣ CartanMatrix` ( A ) | ( operation ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: the Cartan matrix of the algebra `A`, after having checked that `A` is a finite dimensional quotient of a path algebra.

`‣ Centre/Center` ( A ) | ( operation ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: the centre of the algebra `A` as a subalgebra.

The function computes the center of `A` if `A` is a finite dimensional quotient of a path algebra or `A` is a path algebra with on restriction on the underlying quiver.

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

Arguments: `A` -- a path algebra or a quotient of a path algebra, `n` -- a positive integer.

Returns: an estimate of the complexity of the algebra `A`.

The function checks if the algebra `A` 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 maximal complexity of the simple modules over `A` by approximating the complexity of each simple module \(S\) by considering the limit \(\lim_{m\to \infty} \log \frac{\dim(P(S)(m))}{\log m}\) where \(P(S)(m)\) is the \(m\)-th projective in a minimal projective resolution of `S` at stage \(m\). This limit is estimated by \(\frac{\log \dim(P(S)(n))}{\log n}\).

`‣ CoxeterMatrix` ( A ) | ( attribute ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: the Coxeter matrix of the algebra `A`, after having checked that `A` is a finite dimensional quotient of a path algebra.

`‣ CoxeterPolynomial` ( A ) | ( attribute ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: the Coxeter polynomial of the algebra `A`, after having checked that `A` is a finite dimensional quotient of a path algebra.

`‣ Dimension` ( A ) | ( attribute ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: the dimension of the algebra `A` or *infinity* in case `A` is an infinite dimensional algebra.

For a quotient of a path algebra it uses Groebner bases machinery (it computes Groebner basis for the ideal only in case it has not been computed yet).

`‣ FrobeniusForm` ( A ) | ( attribute ) |

Arguments: `A` -- a quotient of a path algebra.

Returns: false if `A` is not selfinjective algebra. Otherwise it returns the Frobenius form of `A`.

`‣ FrobeniusLinearFunctional` ( A ) | ( attribute ) |

Arguments: `A` -- a quotient of a path algebra.

Returns: false if `A` is not selfinjective algebra. Otherwise it returns the Frobenius linear functional of `A`, which is used to construct the Frobenius form.

`‣ GlobalDimension` ( A ) | ( attribute ) |

Arguments: `A` -- an algebra.

Returns: the global dimension of the algebra `A` if it is known. Otherwise it returns an error message saying "no method found!".

There is no method installed for this yet.

`‣ LoewyLength` ( A ) | ( attribute ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: fail if `A` is not finite dimensional. Otherwise it returns the Loewy length of the algebra `A`.

`‣ NakayamaAutomorphism` ( A ) | ( attribute ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: false if `A` is not selfinjective algebra. Otherwise it returns the Nakayama automorphism of `A`.

`‣ NakayamaPermutation` ( A ) | ( attribute ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: false if `A` is not selfinjective algebra. Otherwise it returns a list of two elements where the first is the Nakayama permutation on the simple modules and the second is the Nakayama permutation on the index set of the simple modules of `A`.

`‣ OrderOfNakayamaAutomorphism` ( A ) | ( attribute ) |

Arguments: `A` -- a path algebra or a quotient of a path algebra.

Returns: false if `A` is not selfinjective algebra. Otherwise it returns the order of the Nakayama autormorphism of `A` AS AN ELEMENT OF \(\operatorname{Aut}(A)\).

`‣ RadicalSeriesOfAlgebra` ( A ) | ( attribute ) |

Arguments: `A` -- an algebra.

Returns: the radical series of the algebra `A` in a list, where the first element is the algebra `A` itself, then radical of `A`, radical square of `A`, and so on.

`‣ IsElementOfQuotientOfPathAlgebra` ( object ) | ( property ) |

Arguments: `object` -- any object in **GAP**.

Returns: true whenever `object` is an element of some quotient of a path algebra.

gap> elem := quot.a*quot.b; [(1)*a*b] gap> IsElementOfQuotientOfPathAlgebra(elem); true gap> IsElementOfQuotientOfPathAlgebra(FQ.a*FQ.b); false

`‣ Coefficients` ( B, element ) | ( operation ) |

Arguments: `B, element` -- a basis for a quotient of a path algebra and element thereof.

Returns: the coefficients of the `element` in terms of the canonical basis `B` of the quotient of a path algebra in which `element` is an element.

`‣ IsNormalForm` ( element ) | ( operation ) |

Arguments: `element` -- an element of a path algebra.

Returns: true if `element` is known to be in normal form.

gap> IsNormalForm(elem); true

`‣ <` ( a, b ) | ( operation ) |

Arguments: `a` and `b` -- elements from a path algebra.

Returns: true whenever `a` < `b`.

`‣ ElementOfQuotientOfPathAlgebra` ( family, element, computenormal ) | ( operation ) |

Arguments: `family` -- a family of elements, `element` -- an element of a path algebra, `computenormal` -- true or false.

Returns: The projection of `element` into the quotient given by `family`. If `computenormal` is false, then the normal form of the projection of `element` is returned.

`family` is the ElementsFamily of the family of the algebra `element` is projected into.

`‣ OriginalPathAlgebra` ( algebra ) | ( attribute ) |

Arguments: `algebra` -- an algebra.

Returns: a path algebra.

If `algebra` is a quotient of a path algebra or just a path algebra itself, the returned algebra is the path algebra it was constructed from. Otherwise it returns an error saying that the algebra entered was not given as a quotient of a path algebra.

`‣ BrauerConfigurationAlgebra` ( field, brauer_configuration ) | ( function ) |

Arguments: `field` -- a field, `brauer_configuration` -- a list of the form [[vertices], [edges/polygons], [orientations]].

Returns: the Brauer configuration algebra corresponding to the brauer configuration `brauer_configuration` over the field `field`. If the brauer configuration entered is not valid, fail is returned.

The `brauer_configuration` consists of vertices, polygons/edges, and orientations corresponding to a Brauer Configuration or Brauer Tree. Each vertex must have the form ["vertexname", multiplicity]. Each edge/polygon must have the form ["edgename", "vertex1name", "vertex2name", ...]. There must be an orientation corresponding to each vertex. Orientations must have the form ["edge1name/polygon1name", "edge2name/polygon2name", ...].

gap> alg := BrauerConfigurationAlgebra(Rationals, [ [ [ "v1", 1 ], [ "v2", 1 ], [ "v3", 2 ] ], [ [ "e1", "v1", "v2" ], [ "e2", "v2", "v3" ] ], [ [ "e1" ], [ "e1", "e2" ], ["e2" ] ]]); <A quotient of the path algebra <Rationals[<quiver with 2 vertices and 3 arrows>]> modulo the ideal <two-sided ideal in <Rationals[<quiver with 2 vertices and 3 arrows>]>, (5 generators)>>

`‣ CanonicalAlgebra` ( field, weights[, relcoeff] ) | ( operation ) |

Arguments: `field` -- a field, `weights` -- a list of positive integers, [, `relcoeff` -- a list of non-zero elements in the field.

Returns: the canonical algebra over the `field` with the quiver given by the weight sequence `weights` and the relations given by the coefficients `relcoeff`.

It function checks if all the `weights` are greater or equal to two, the number of weights is at least two, the number of coefficients is the number of `weights` - 2, the coefficients for the relations are in field and non-zero. If only the two first arguments are given, then the number of weights must be two.

`‣ KroneckerAlgebra` ( field, n ) | ( operation ) |

Arguments: `field` -- a field, `n` -- a positive integer.

Returns: the `n`-Kronecker algebra over the field `field`.

It function checks if the number `n` of arrows is greater or equal to two and returns an error message if not.

`‣ NakayamaAlgebra` ( admiss-seq, field ) | ( function ) |

Arguments: `field` -- a field, `admiss-seq` -- a list of positive integers.

Returns: the Nakayama algebra corresponding to the admissible sequence `admiss-seq` over the field `field`. If the entered sequence is not an admissible sequence, the sequence is returned.

The `admiss-seq` consists of the dimensions of the projective representations.

`‣ AdmissibleSequenceGenerator` ( num_vert, height ) | ( operation ) |

Arguments: `num_vert`, `height` -- two positive integers.

Returns: all admissible sequences of Nakayama algebras with `num_vert` number of vertices, and indecomposable projective modules of length at most `height`.

gap> alg := NakayamaAlgebra([2,1], Rationals); <Rationals[<quiver with 2 vertices and 1 arrows>]> gap> QuiverOfPathAlgebra(alg); <quiver with 2 vertices and 1 arrows>

`‣ PosetAlgebra` ( F, P ) | ( operation ) |

Arguments: `F` -- a field, `P` -- a poset.

Returns: the poset algebra associated to the poset `P` over the field `K`.

`‣ PosetOfPosetAlgebra` ( A ) | ( attribute ) |

Arguments: `A` -- a poset algebra.

Returns: the poset from which that poset algebra `A` is constructed.

`‣ TruncatedPathAlgebra` ( F, Q, n ) | ( operation ) |

Arguments: `F` -- a field, `Q` -- a quiver, `n` -- a positive integer.

Returns: the truncated path algebra `KQ/I`, where `I` is the ideal generated by all paths of length `n` in `KQ`.

`‣ IsSpecialBiserialQuiver` ( Q ) | ( property ) |

Arguments: `Q` -- a quiver.

Returns: true whenever `Q` is a *"special biserial"* quiver, i.e. every vertex in `Q` is a source (resp. target) of at most 2 arrows.

*Note:* e.g. a path algebra of one loop IS NOT special biserial, but one loop IS special biserial quiver (cf. `IsSpecialBiserialAlgebra`

(4.11-19) and also an Example below).

gap> Q := Quiver(1, [ [1,1,"a"], [1,1,"b"] ]);; gap> A := PathAlgebra(Rationals, Q);; gap> IsSpecialBiserialAlgebra(A); IsStringAlgebra(A); false false gap> rel1 := [A.a*A.b, A.a^2, A.b^2]; [ (1)*a*b, (1)*a^2, (1)*b^2 ] gap> quo1 := A/rel1;; gap> IsSpecialBiserialAlgebra(quo1); IsStringAlgebra(quo1); true true gap> rel2 := [A.a*A.b-A.b*A.a, A.a^2, A.b^2]; [ (1)*a*b+(-1)*b*a, (1)*a^2, (1)*b^2 ] gap> quo2 := A/rel2;; gap> IsSpecialBiserialAlgebra(quo2); IsStringAlgebra(quo2); true false gap> rel3 := [A.a*A.b+A.b*A.a, A.a^2, A.b^2, A.b*A.a]; [ (1)*a*b+(1)*b*a, (1)*a^2, (1)*b^2, (1)*b*a ] gap> quo3 := A/rel3;; gap> IsSpecialBiserialAlgebra(quo3); IsStringAlgebra(quo3); true true gap> rel4 := [A.a*A.b, A.a^2, A.b^3]; [ (1)*a*b, (1)*a^2, (1)*b^3 ] gap> quo4 := A/rel4;; gap> IsSpecialBiserialAlgebra(quo4); IsStringAlgebra(quo4); false false

`‣ OppositePath` ( p ) | ( operation ) |

Arguments: `p` -- a path.

Returns: the path corresponding to `p` in the opposite quiver.

The following example illustrates the use of `OppositeQuiver`

(3.5-9) and `OppositePath`

.

gap> Q := Quiver( [ "u", "v" ], [ [ "u", "u", "a" ], > [ "u", "v", "b" ] ] ); <quiver with 2 vertices and 2 arrows> gap> Qop := OppositeQuiver(Q); <quiver with 2 vertices and 2 arrows> gap> VerticesOfQuiver( Qop ); [ u_op, v_op ] gap> ArrowsOfQuiver( Qop ); [ a_op, b_op ] gap> OppositePath( Q.a * Q.b ); b_op*a_op gap> IsIdenticalObj( Q, OppositeQuiver( Qop ) ); true gap> OppositePath( Qop.b_op * Qop.a_op ); a*b

`‣ OppositePathAlgebra` ( A ) | ( attribute ) |

Arguments: `A` -- a path algebra or quotient of path algebra.

Returns: the opposite algebra \(\textit{A}^\text{op}\).

This attribute contains the opposite algebra of an algebra.

The opposite algebra of a path algebra is the path algebra over the opposite quiver (as given by `OppositeQuiver`

(3.5-9)). The opposite algebra of a quotient of a path algebra has the opposite quiver and the opposite relations of the original algebra.

The function `OppositePathAlgebraElement`

(4.16-3) takes an algebra element to the corresponding element in the opposite algebra.

The opposite of the opposite of an algebra \(A\) is isomorphic to \(A\). In QPA, we regard these two algebras to be the same, so the call `OppositePathAlgebra(OppositePathAlgebra(A))`

returns the object `A`

.

`‣ OppositePathAlgebraElement` ( x ) | ( function ) |

Arguments: `x` -- a path.

Returns: the element corresponding to `x` in the opposite algebra.

`‣ OppositeAlgebraHomomorphism` ( A ) | ( attribute ) |

Arguments: `A` -- an algebra homomorphism of two (quotients) of path algebras.

Returns: algebra homomorphism between the corresponding opposite algebras.

The following example illustrates the use of `OppositePathAlgebra`

(4.16-2) and `OppositePathAlgebraElement`

(4.16-3).

gap> Q := Quiver( [ "u", "v" ], [ [ "u", "u", "a" ], > [ "u", "v", "b" ] ] ); <quiver with 2 vertices and 2 arrows> gap> A := PathAlgebra( Rationals, Q ); <Rationals[<quiver with 2 vertices and 2 arrows>]> gap> OppositePathAlgebra( A ); <Rationals[<quiver with 2 vertices and 2 arrows>]> gap> OppositePathAlgebraElement( A.u + 2*A.a + 5*A.a*A.b ); (1)*u_op+(2)*a_op+(5)*b_op*a_op gap> IsIdenticalObj( A, > OppositePathAlgebra( OppositePathAlgebra( A ) ) ); true

If \(\Lambda\) and \(\Gamma\) are quotients of path algebras over the same field \(F\), then their tensor product \(\Lambda \tensor_F \Gamma\) is also a quotient of a path algebra over \(F\).

The quiver for the tensor product path algebra is the `QuiverProduct`

(4.17-1) of the quivers of the original algebras.

The operation `TensorProductOfAlgebras`

(4.17-6) computes the tensor products of two quotients of path algebras as a quotient of a path algebra.

`‣ QuiverProduct` ( Q1, Q2 ) | ( operation ) |

Arguments: `Q1` and `Q2` -- quivers.

Returns: the product quiver \(\textit{Q1} \quiverproduct \textit{Q2}\).

A vertex in \(\textit{Q1} \quiverproduct \textit{Q2}\) which is made by combining a vertex named `u`

in `Q1` with a vertex `v`

in `Q2` is named `u_v`

. Arrows are named similarly (they are made by combining an arrow from one quiver with a vertex from the other).

`‣ QuiverProductDecomposition` ( Q ) | ( attribute ) |

Arguments: `Q` -- a quiver.

Returns: the original quivers `Q` is a product of, if `Q` was created by the `QuiverProduct`

(4.17-1) operation.

The value of this attribute is an object in the category `IsQuiverProductDecomposition`

(4.17-3).

`‣ IsQuiverProductDecomposition` ( object ) | ( category ) |

Arguments: `object` -- any object in **GAP**.

Category for objects containing information about the relation between a product quiver and the quivers it is a product of. The quiver factors can be extracted from the decomposition object by using the [] notation (like accessing elements of a list). The decomposition object is also used by the operations `IncludeInProductQuiver`

(4.17-4) and `ProjectFromProductQuiver`

(4.17-5).

`‣ IncludeInProductQuiver` ( L, Q ) | ( operation ) |

Arguments: `L` -- a list containing the paths \(q_1\) and \(q_2\), \(Q\) -- a product quiver.

Returns: a path in `Q`.

Includes paths \(q_1\) and \(q_2\) from two quivers into the product of these quivers, `Q`. If at least one of \(q_1\) and \(q_2\) is a vertex, there is exactly one possible inclusion. If they are both non-trivial paths, there are several possibilities. This operation constructs the path which is the inclusion of \(q_1\) at the source of \(q_2\) multiplied with the inclusion of \(q_2\) at the target of \(q_1\).

`‣ ProjectFromProductQuiver` ( i, p ) | ( operation ) |

Arguments: `i` -- a positive integer, `p` -- a path in the product quiver.

Returns: the projection of the product quiver path `p` to one of the factors. Which factor it should be projected to is specified by the argument `i`.

The following example shows how the operations related to quiver products are used.

gap> q1 := Quiver( [ "u1", "u2" ], [ [ "u1", "u2", "a" ] ] ); <quiver with 2 vertices and 1 arrows> gap> q2 := Quiver( [ "v1", "v2", "v3" ], [ [ "v1", "v2", "b" ], [ "v2", "v3", "c" ] ] ); <quiver with 3 vertices and 2 arrows> gap> q1_q2 := QuiverProduct( q1, q2 ); <quiver with 6 vertices and 7 arrows> gap> q1_q2.u1_b * q1_q2.a_v2; u1_b*a_v2 gap> IncludeInProductQuiver( [ q1.a, q2.b * q2.c ], q1_q2 ); a_v1*u2_b*u2_c gap> ProjectFromProductQuiver( 2, q1_q2.a_v1 * q1_q2.u2_b * q1_q2.u2_c ); b*c gap> q1_q2_dec := QuiverProductDecomposition( q1_q2 ); <object> gap> q1_q2_dec[ 1 ]; <quiver with 2 vertices and 1 arrows> gap> q1_q2_dec[ 1 ] = q1; true

`‣ TensorProductOfAlgebras` ( FQ1, FQ2 ) | ( operation ) |

Arguments: `FQ1` and `FQ2` -- (quotients of) path algebras.

Returns: The tensor product of `FQ1` and `FQ2`.

The result is a quotient of a path algebra, whose quiver is the `QuiverProduct`

(4.17-1) of the quivers of the operands.

`‣ TensorAlgebrasInclusion` ( T, n ) | ( operation ) |

Arguments: `T` -- quiver algebra, `n` -- 1 or 2.

Returns: Returns the inclusion \(A \hookrightarrow A \otimes B\) or the inclusion \(B \hookrightarrow A \otimes B\) if \(n = 1\) or \(n = 2\), respectively.

`‣ SimpleTensor` ( L, T ) | ( operation ) |

Arguments: `L` -- a list containing two elements \(x\) and \(y\) of two (quotients of) path algebras, `T` -- the tensor product of these algebras.

Returns: the simple tensor \(x \tensor y\).

\(x \tensor y\) is in the tensor product `T` (produced by `TensorProductOfAlgebras`

(4.17-6)).

`‣ TensorProductDecomposition` ( T ) | ( attribute ) |

Arguments: `T` -- a tensor product of path algebras.

Returns: a list of the factors in the tensor product.

`T` should be produced by `TensorProductOfAlgebras`

(4.17-6)).

The following example shows how the operations for tensor products of quotients of path algebras are used.

gap> q1 := Quiver( [ "u1", "u2" ], [ [ "u1", "u2", "a" ] ] ); <quiver with 2 vertices and 1 arrows> gap> q2 := Quiver( [ "v1", "v2", "v3", "v4" ], > [ [ "v1", "v2", "b" ], > [ "v1", "v3", "c" ], > [ "v2", "v4", "d" ], > [ "v3", "v4", "e" ] ] ); <quiver with 4 vertices and 4 arrows> gap> fq1 := PathAlgebra( Rationals, q1 ); <Rationals[<quiver with 2 vertices and 1 arrows>]> gap> fq2 := PathAlgebra( Rationals, q2 ); <Rationals[<quiver with 4 vertices and 4 arrows>]> gap> I := Ideal( fq2, [ fq2.b * fq2.d - fq2.c * fq2.e ] ); <two-sided ideal in <Rationals[<quiver with 4 vertices and 4 arrows>]> , (1 generators)> gap> quot := fq2 / I; <Rationals[<quiver with 4 vertices and 4 arrows>]/ <two-sided ideal in <Rationals[<quiver with 4 vertices and 4 arrows>]> , (1 generators)>> gap> t := TensorProductOfAlgebras( fq1, quot ); <Rationals[<quiver with 8 vertices and 12 arrows>]/ <two-sided ideal in <Rationals[<quiver with 8 vertices and 12 arrows>]>, (6 generators)>> gap> SimpleTensor( [ fq1.a, quot.b ], t ); [(1)*u1_b*a_v2] gap> t_dec := TensorProductDecomposition( t ); [ <Rationals[<quiver with 2 vertices and 1 arrows>]>, <Rationals[<quiver with 4 vertices and 4 arrows>]/ <two-sided ideal in <Rationals[<quiver with 4 vertices and 4 arrows>]>, (1 generators)>> ] gap> t_dec[ 1 ] = fq1; true

`‣ EnvelopingAlgebra` ( A ) | ( attribute ) |

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

Returns: the enveloping algebra \(\textit{A}^\text{e} = \textit{A}^\text{op} \tensor \textit{A}\) of `A`.

`‣ EnvelopingAlgebraHomomorphism` ( f ) | ( attribute ) |

Arguments: `f` -- an algebra homomorphism of two (quotients of) a path algebras.

Returns: the algebra homomorphism between the corresponding enveloping algebras the source of `f` and the range of `f`.

`‣ IsEnvelopingAlgebra` ( A ) | ( property ) |

Arguments: `A` -- an algebra.

Returns: true if and only if `A` is the result of a call to `EnvelopingAlgebra`

(4.17-10).

`‣ AlgebraAsModuleOverEnvelopingAlgebra` ( A ) | ( attribute ) |

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

Returns: the algebra `A` as a right module over the enveloping algebra of `A`.

`‣ DualOfAlgebraAsModuleOverEnvelopingAlgebra` ( A ) | ( attribute ) |

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

Returns: the algebra `A` as a right module over the enveloping algebra of `A`.

`‣ TrivialExtensionOfQuiverAlgebra` ( A ) | ( attribute ) |

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

Returns: the trivial extension algebra \(T(A)=A\oplus D(A)\) of the entered algebra `A`.

`‣ TrivialExtensionOfQuiverAlgebraProjection` ( A ) | ( attribute ) |

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

Returns: the natural algebra projection form trivial extension \(T(A)\) to `A`.

`‣ QuiverAlgebraOfAmodAeA` ( A, elist ) | ( operation ) |

Arguments: `A`, `elist` - a finite dimensional quiver algebra and a list of integers.

Returns: a quiver algebra isomorphic `A` modulo the ideal generated by a sum of vertices in `A`.

Given a quiver algebra `A` and a sum of vertices \(e\), this function computes the quiver algebra \(A/AeA\). The list `elist` is a list of integers, where each integer occurring in the list corresponds to the position of the vertex in the vertices defining the idempotent \(e\).

`‣ QuiverAlgebraOfeAe` ( A, elist ) | ( operation ) |

Arguments: `A`, `e` - a finite dimensional quiver algebra and an idempotent.

Returns: a quiver algebra isomorphic \(eAe\), where `A` is the entered algebra and `e` is the entered idempotent.

Given a quiver algebra `A` and an idempotent `e`, this function computes the quiver algebra isomorphic to \(eAe\). The function checks if the entered element `e` is an idempotent in `A`.

`‣ AlgebraAsQuiverAlgebra` ( A ) | ( operation ) |

Arguments: `A` - a finite dimensional algebra over a finite field.

Returns: a (quotient of a) path algebra isomorphic to the entered algebra `A` whenever possible and a list of the images of the vertices and the arrows in this path algebra in `A`.

The operation only applies when `A` is a finite dimensional indecomposable algebra over a finite field, otherwise it returns an error message. It checks the algebra `A` is basic and elementary over some field and otherwise it returns an error message. In the list of images the images of the vertices are listed first and then the images of the arrows.

`‣ BlocksOfAlgebra` ( A ) | ( operation ) |

Arguments: `A` - a finite dimensional algebra.

Returns: a block decomposition of the entered algebra `A` as a list of indecomposable algebras.

`‣ IsBasicAlgebra` ( A ) | ( property ) |

Arguments: `A` - a finite dimensional algebra over a finite field.

Returns: true if the entered algebra `A` is a (finite dimensional) basic algebra and false otherwise. This method only applies to algebras over finite fields.

`‣ IsElementaryAlgebra` ( A ) | ( property ) |

Arguments: `A` - a finite dimensional algebra over a finite field.

Returns: true if the entered algebra `A` is a (finite dimensional) elementary algebra and false otherwise. This method only applies to algebras over finite fields.

The algebra `A` need not to be an elementary algebra over the field which it is defined, but be an elementary algebra over a field extension.

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

`‣ PreprojectiveAlgebra` ( A ) | ( operation ) |

Arguments (first version): `M` - a path algebra module over finite dimensional hereditary algebra over a finite field, `n` - an integer.

Arguments (second version): `A` - a path algebra.

Returns: in the first version the preprojective algebra of the module `M` if it only has support up to degree `n`. In the second version it returns the preprojective algebra of a hereditary algebra given by a path algebra over a field.

`‣ PrimitiveIdempotents` ( A ) | ( attribute ) |

Arguments: `A` - a finite dimensional simple algebra over a finite field.

Returns: a complete set of primitive idempotents \(\{ e_i \}\) such that \(A \simeq Ae_1 + ... + Ae_n\).

TODO: Understand what this function actually does.

`‣ LiftingCompleteSetOfOrthogonalIdempotents` ( f, e ) | ( operation ) |

Arguments: `map` - an algebra homomorphism, `idempotents` elements in the range of `map`.

Returns: a complete set of orthogonal idempotents in `Source(f)`

which are liftings of the entered `idempotents` whenever possible.

The operation only applies when the domain of `f` is finite dimensional. It checks if the list of elements `idempotents` is a set complete set of orthogonal idempotents. If some idempotent in `idempotents` is not in the image of `map`, then an error message is returned. If all idempotents in `idempotents` has a preimage, then this operation returns a complete set of orthogonal of idempotents which is a lifting of the idempotents in `idempotents` to the source of `f` whenever possible or it returns fail.

`‣ LiftingIdempotent` ( f, e ) | ( operation ) |

Arguments: `f` - an algebra homomorphism, `e` an element in the range of `f`.

Returns: an idempotent \(a\) in `Source(f)`

such that `ImageElm(f, a) = e`

whenever possible. If `e` is not in the image of `f`, an error message is given, and if `e` does not have a preimage by `f` `fail`

is returned.

The operation only applies when the domain of `f` is finite dimensional. It checks if the element `e` is an idempotent. If `e` is not in the image of `f`, then an error message is returned. If `e` has a preimage, then this operation returns a lifting of `e` to the source of `f` whenever possible or it returns fail. Using the algorithm described in the proof of Proposition 27.1 in Anderson and Fuller, Rings and categories of modules, second edition, GMT, Springer-Verlag.

`‣ ReadAlgebra` ( string ) | ( operation ) |

Arguments: `string` - a name of a file.

Returns: a finite dimension quotient \(A\) of a path algebra saved by command `SaveAlgebra`

to the file `string`. This function creates the algebra \(A\) again, which can be saved to a file again with the function `SaveAlgebra`

.

`‣ SaveAlgebra` ( A, string, action ) | ( operation ) |

Arguments: `A` - an algebra, `string` - a name of a file, `action` - a string.

Returns: or creates a file with name `string`, storing the algebra `A`, which can be opened again with the function `ReadAlgebra`

and reconstructed. The last argument `action` decides if the file `string`, if it exists already, should be overwritten, not overwritten or the user should be prompted for an answer to this question. The corresponding user inputs are: "delete", "keep" or "query".

generated by GAPDoc2HTML