We use the term quiver algebra for an algebra that is either a path algebra or a quotient of a path algebra by some ideal.
‣ IsQuiverAlgebraElement( arg ) | ( filter ) |
Returns: true or false
Category for elements of quiver algebras.
‣ IsQuiverAlgebra( arg ) | ( filter ) |
Returns: true or false
Category for quiver algebras.
‣ IsPathAlgebraElement( arg ) | ( filter ) |
Returns: true or false
Category for elements of path algebras.
‣ IsPathAlgebra( arg ) | ( filter ) |
Returns: true or false
Category for path algebras.
‣ IsPathIdeal( arg ) | ( filter ) |
Returns: true or false
Category for (two-sided) ideals in path algebras.
‣ IsQuotientOfPathAlgebraElement( arg ) | ( filter ) |
Returns: true or false
Category for elements of quotients of path algebras.
‣ IsQuotientOfPathAlgebra( arg ) | ( filter ) |
Returns: true or false
Category for quotients of path algebras.
‣ PathAlgebra( k, Q ) | ( operation ) |
Constructs the path algebra over the field k using the quiver Q.
gap> Q := LeftQuiver( "Q(3)[a:1->2,b:2->3,c:2->3]" ); Q(3)[a:1->2,b:2->3,c:2->3] gap> kQ := PathAlgebra( Rationals, Q ); Rationals * Q gap> kQ.c - 2/5 * kQ.ba + kQ[1]; -2/5*(b*a) + 1*(c) + 1*(1)
‣ QuotientOfPathAlgebra( kQ, I ) | ( operation ) |
‣ QuotientOfPathAlgebra( kQ, relations ) | ( operation ) |
‣ \/( kQ, I ) | ( operation ) |
‣ \/( kQ, relations ) | ( operation ) |
Constructs a quotient of a path algebra.
The first argument is a path algebra kQ. The second argument is either an ideal I in the algebra kQ or a list relations of elements of kQ. The result is kQ divided by the ideal I, or by the ideal generated by relations.
The / operator is defined to do the same as QuotientOfPathAlgebra, so QuotientOfPathAlgebra( kQ, I ) or QuotientOfPathAlgebra( kQ, relations ) can also be written as kQ/I or kQ/relations.
gap> kQ := PathAlgebra( Rationals, LeftQuiver( "Q(3)[a:1->2,b:2->3,c:2->3]" ) ); Rationals * Q gap> A := kQ / [ kQ.ca - kQ.ba ]; (Rationals * Q) / [ 1*(c*a) - 1*(b*a) ] gap> (A.c + A.b) * A.a; { 2*(b*a) } gap> kQ / TwoSidedIdealByGenerators( kQ, [ kQ.ca - kQ.ba ] ); (Rationals * Q) / [ 1*(c*a) - 1*(b*a) ]
‣ QuiverOfAlgebra( A ) | ( attribute ) |
Returns: IsQuiver (1.1-7)
Returns the quiver Q of the quiver algebra A = \(kQ/I\).
‣ RelationsOfAlgebra( A ) | ( attribute ) |
Returns: list of IsPathAlgebraElement (2.1-3)
Returns a list of relations for the quiver algebra A. That is, if A = \(kQ/I\), then this operation returns a list of generators for the ideal \(I\). If A is a path algebra, this operation returns the empty list.
‣ IdealOfQuotient( A ) | ( attribute ) |
Returns: IsPathIdeal (2.1-5)
For a quotient A = \(kQ/I\) of a path algebra, this operation returns the ideal \(I\).
‣ LeftActingDomain( A ) | ( attribute ) |
Returns the underlying field of the algebra A.
Returns: IsField
‣ PathAlgebra( A ) | ( attribute ) |
Returns: IsPathAlgebra (2.1-4)
Given a quiver algebra A = \(kQ/I\), this operation returns the path algebra \(kQ\).
‣ PathAlgebraElement( kQ, coefficients, paths ) | ( operation ) |
‣ PathAlgebraElementNC( kQ, coefficients, paths ) | ( operation ) |
Returns: IsPathAlgebraElement (2.1-3)
Creates an element of a path algebra.
The argument kQ is a path algebra, paths is a list of paths in the quiver of kQ, and coefficients a list of coefficients. The lists paths and coefficients must have the same length. If the paths are \(p_1, \ldots, p_n\) and the coefficients are \(c_1, \ldots, c_n\), then the result is the linear combination \(\sum_{i=1}^n c_i p_i\).
For the operation PathAlgebraElement, the elements in paths may be listed in any order, and the same paths can occur several times in the list. The operation PathAlgebraElementNC assumes that the list of paths is sorted in decreasing order (by the path ordering of the quiver) and does not have any duplicates.
gap> kQ := PathAlgebra( Rationals, LeftQuiver( "Q(3)[a:1->2,b:2->3,c:2->3]" ) ); Rationals * Q gap> PathAlgebraElement( kQ, [ 2, -1, 1/5 ], [ Q.a, Q.ba, Q[1] ] ); -1*(b*a) + 2*(a) + 1/5*(1) gap> PathAlgebraElement( kQ, [ 2, 3/2 ], [ Q.a, Q.a ] ); 7/2*(a)
‣ QuotientOfPathAlgebraElement( A, e ) | ( function ) |
Given a quotient A = kQ/I of a path algebra kQ, and an element e of kQ, this operation produces the element of A represented by e.
gap> kQ := PathAlgebra( Rationals, LeftQuiver( "Q(3)[a:1->2,b:2->3,c:2->3]" ) ); Rationals * Q gap> A := kQ / [ kQ.ca - kQ.ba ]; (Rationals * Q) / [ 1*(c*a) - 1*(b*a) ] gap> e := kQ.ca + kQ.ba; 1*(c*a) + 1*(b*a) gap> QuotientOfPathAlgebraElement( A, e ); { 2*(b*a) }
‣ PathAsAlgebraElement( A, p ) | ( operation ) |
Returns the path p as an element of the quiver algebra A.
gap> Q := LeftQuiver( "Q(3)[a:1->2,b:2->3,c:2->3]" );; gap> kQ := PathAlgebra( Rationals, Q );; gap> A := kQ / [ kQ.ca - kQ.ba ];; gap> PathAsAlgebraElement( kQ, Q.ca ); 1*(c*a) gap> PathAsAlgebraElement( A, Q.ca ); { 1*(b*a) }
‣ AlgebraElementByLabel( A, label ) | ( operation ) |
‣ \[\]( A, label ) | ( operation ) |
Returns: IsQuiverAlgebraElement (2.1-1)
Returns the primitive path (vertex or arrow) with label label, as an element of the quiver algebra A. If no such path exists, an error is signalled. The operation A[ label ] is equivalent to AlgebraElementByLabel( A, label ).
gap> Q := LeftQuiver( "Q(3)[a:1->2,b:2->3,c:2->3]" );; gap> kQ := PathAlgebra( Rationals, Q );; gap> kQ[ 1 ] + kQ[ 2 ] + kQ[ 3 ]; 1*(3) + 1*(2) + 1*(1) gap> kQ[ 'b' ] * kQ[ 'a' ]; 1*(b*a)
‣ AlgebraElementFromString( A, string ) | ( operation ) |
Returns: IsQuiverAlgebraElement (2.1-1)
Returns the path described by the string string (see PathFromString (1.4-13)) as an element of the quiver algebra A. If no such path exists, an error is signalled.
This operation can also be called by writing A.str, where str is an unquoted string literal.
gap> Q := LeftQuiver( "Q(3)[a:1->2,b:2->3,c:3->2,d:2->1]" );; gap> kQ := PathAlgebra( Rationals, Q );; gap> AlgebraElementFromString( kQ, "dcba" ); 1*(d*c*b*a) gap> kQ.dcba; 1*(d*c*b*a)
‣ AlgebraOfElement( e ) | ( attribute ) |
Returns: IsQuiverAlgebra (2.1-2)
Returns the quiver algebra the element e belongs to.
‣ Coefficients( e ) | ( attribute ) |
Returns: list of field elements
Returns a list of coefficients for the algebra element e.
Every element of a quiver algebra can be written as a linear combination \(\sum_{i=1}^n c_i p_i\) of paths. The attribute Paths (2.5-3) gives the list \(p_1, \ldots, p_n\) of paths for the element e, and this attribute returns the corresponding list \(c_1, \ldots, c_n\) of coefficients.
‣ Paths( e ) | ( attribute ) |
Returns: list of IsPath (1.1-1)
Returns a list of paths for the algebra element e.
Every element of a quiver algebra can be written as a linear combination \(\sum_{i=1}^n c_i p_i\) of paths. This operation produces the list \(p_1, \ldots, p_n\) of paths for the element e. The corresponding coefficients \(c_1, \ldots, c_n\) can be obtained by the attribute Coefficients (2.5-2).
The paths are ordered in decreasing order, by the path ordering of the quiver.
If e is an element of a path algebra, then there is a unique way to express it as a linear combination of paths. If e is an element of a quotient of a path algebra, then there may be several ways to express it as a linear combination of paths. In this case, the chosen combination is that of Representative( e ) (see Representative (2.5-5)).
‣ IsUniform( e ) | ( property ) |
Returns: true or false
Checks whether the element e is uniform, that is, whether all paths in the element have the same source and the same target.
‣ Representative( e ) | ( attribute ) |
Returns: IsPathAlgebraElement (2.1-3)
Returns the canonical representative path algebra element of the element e of a quotient of a path algebra.
‣ TranslateAlgebraElement( e, A, f ) | ( operation ) |
Returns: IsQuiverAlgebraElement (2.1-1)
Translate the element e to an element in the quiver algebra A by using the function f on each path.
‣ LeadingPath( e ) | ( attribute ) |
Returns: IsPath (1.1-1)
Returns the leading path of the path algebra element e, that is, the path occuring in e which is largest with respect to the quiver's ordering of paths.
‣ LeadingCoefficient( e ) | ( operation ) |
Returns: field element
Returns the leading coefficient of the path algebra element e, that is, the coefficient of the leading path.
‣ LeadingTerm( e ) | ( attribute ) |
Returns: IsPathAlgebraElement (2.1-3)
Returns the leading term of the path algebra element e.
‣ NonLeadingTerms( e ) | ( attribute ) |
Returns: IsPathAlgebraElement (2.1-3)
Returns the sum of all the non-leading terms of the path algebra element e.
‣ DivideByList( e, divisors ) | ( operation ) |
Returns: list
Performs division of the path algebra element e by the elements in the list divisors.
When dividing an element \(e\) by a list \(d_1, \ldots, d_n\) of divisors, the goal is to find a remainder \(r\) and left/right quotients \(L_{i,j}\) and \(R_{i,j}\) (for \(1 \le i \le n\) and \(1 \le j \le m_i\), where \(m_i\) is some integer depending on \(i\)) such that
\[ e = r + \sum_{i=1}^n \sum_{j=1}^{m_i} L_{i,j} \cdot d_i \cdot R_{i,j}. \]
This operation returns a list [ quotients, remainder ], where quotients is a list containing the left/right quotients, and remainder is the remainder. The left quotient \(L_{i,j}\) is accessible as quotients[ i ][ j ][ 1 ], and the right quotient \(R_{i,j}\) as quotients[ i ][ j ][ 2 ].
‣ Reduce( e, divisors ) | ( operation ) |
Returns: IsPathAlgebraElement (2.1-3)
Reduce the path algebra element e by the elements in the list divisors.
This operation returns the remainder produced by DivideByList (2.7-5).
‣ OverlapRelation( f, g, b, c ) | ( operation ) |
Returns: IsPathAlgebraElement (2.1-3)
Computes an overlap relation. Given two path algebra elements f and g, and two paths b and c, such that LeadingPath( f ) * c = b * LeadingPath( g ), this operation produces the overlap relation
\[ \frac{1}{LC(f)} fc - \frac{1}{LC(g)} bg \]
f and g with respect to b and c.
‣ OverlapRelations( f, g ) | ( operation ) |
Returns: IsPathAlgebraElement (2.1-3)
Finds all overlap relations between the path algebra elements f and g.
We consider two elements \(f\) and \(g\) to have an overlap when there are paths \(b\) and \(c\) such that \(LP(f) \cdot c = b \cdot LP(g)\). The corresponding overlap relation is then the element
\[ \frac{1}{LC(f)} fc - \frac{1}{LC(g)} bg. \]
For a given pair \((f,g)\), there may be several such overlap relations, corresponding to several choices of paths \((b,c)\). This operation constructs all these overlap relations, and returns them as a list.
Overlap relations are interesting because they point to obstructions to a list \(G\) of generators of an ideal forming a Groebner basis: if some overlap relation between two elements of \(G\) reduces to a nonzero remainder \(r\) when divided by \(G\), then \(G\) is not a Groebner basis. In Buchberger's algorithm, we then add the remainder \(r\) to the list \(G\).
Note that our definition of overlaps does not include situations of the form \(LP(f) = a \cdot LP(g) \cdot a'\), although they too give obstructions to a set being a Groebner basis, and would be considered as overlaps by some authors.
‣ TipReduce( G ) | ( operation ) |
Returns: list of IsPathAlgebraElement (2.1-3)
Returns a tip reduced version of the list G of path algebra elements. The original list is not modified.
The resulting list has the following properties: (1) It generates the same ideal as G does. (2) No element in the list has a leading path which divides the leading path of another element in the list.
‣ ComputeGroebnerBasis( G ) | ( operation ) |
Returns: list of IsPathAlgebraElement (2.1-3)
Given a list G of generators for an ideal \(I\) in a path algebra, this operation produces a Groebner basis for the ideal \(I\).
‣ GroebnerBasis( I ) | ( attribute ) |
Returns: list of IsPathAlgebraElement (2.1-3)
A Groebner basis for the ideal I.
‣ OppositeAlgebra( A ) | ( attribute ) |
Returns: IsQuiverAlgebra (2.1-2)
Returns the opposite algebra of A.
‣ OppositeAlgebraElement( e ) | ( attribute ) |
Returns: IsQuiverAlgebraElement (2.1-1)
Returns the element corresponding to e in the opposite algebra.
‣ TensorProductOfAlgebras( A, B ) | ( operation ) |
Returns: IsQuiverAlgebra (2.1-2)
Returns the tensor product of the quiver algebras A and B.
‣ IsTensorProductOfAlgebras( T, A, B ) | ( operation ) |
Returns: true or false
Returns true if the algebra T is the tensor product of the algebras A and B; false otherwise.
generated by GAPDoc2HTML