‣ IsPath( arg ) | ( filter ) |
‣ IsLeftPath( arg ) | ( filter ) |
‣ IsRightPath( arg ) | ( filter ) |
Returns: true or false
Every path is in the category IsPath. Additionally, every path in a left-oriented quiver is in the category IsLeftPath, and every path in a right-oriented quiver is in the category IsRightPath.
‣ IsPrimitivePath( arg ) | ( filter ) |
Returns: true or false
A primitive path is a path which can not be decomposed in a nontrivial way, that is, a vertex or an arrow.
‣ IsNontrivialPath( arg ) | ( filter ) |
Returns: true or false
A nontrivial path is a path which has length at least one, that is, any path which is not a vertex.
‣ IsCompositePath( arg ) | ( filter ) |
Returns: true or false
A composite path is a path which can be decomposed in a nontrivial way, that is, a path which is a product of two or more arrows. Any path is either a primitive path or a composite path.
‣ IsVertex( arg ) | ( filter ) |
Returns: true or false
‣ IsArrow( arg ) | ( filter ) |
Returns: true or false
‣ IsQuiver( arg ) | ( filter ) |
Returns: true or false
Every quiver is in the category IsQuiver. Additionally, a left-oriented quiver is in the category IsLeftQuiver (1.1-8), and a right-oriented quiver is in the category IsRightQuiver.
‣ IsLeftQuiver( arg ) | ( filter ) |
Returns: true or false
Category for left-oriented quivers.
‣ IsRightQuiver( arg ) | ( filter ) |
Returns: true or false
Category for right-oriented quivers.
‣ LeftQuiver( label_with_patterns, num_vertices, arrows ) | ( operation ) |
‣ LeftQuiver( label_with_patterns, vertex_labels, arrows ) | ( operation ) |
‣ LeftQuiver( description ) | ( operation ) |
‣ LeftQuiver( label_with_patterns_list, num_vertices, vertex_labels, arrows ) | ( operation ) |
‣ LeftQuiver( label, vertex_labels, arrow_labels, source_indices, target_indices ) | ( operation ) |
Returns: IsLeftQuiver (1.1-8)
Constructor for left-oriented quivers.
The three first forms of the constructor are the most useful ones for interactive use and for creating specific quivers in programs. The two last forms are mainly intended for use in programmatic generation of quivers, that is, for functions that create quivers based on some dynamic data.
In the first form, the quiver is specified by a label (an arbitrary name for the quiver), the number of vertices, and a list of lists describing the arrows; for example LeftQuiver( "Q", 2, [ [ 'a', 1, 2 ], [ 'b', 2, 1 ] ] ). The first argument can optionally contain patterns for automatic labelling of vertices and arrows, for example: LeftQuiver( "Q(u1)[a]", 2, [ [ "u1", "u2" ], [ "u2", "u1" ] ] ).
In the second form of the constructor, the vertices are specified by a list of labels instead of just a number. The number of vertices is determined by the length of this list. For example: LeftQuiver( "Q", [ 'u', 'v' ], [ [ 'a', 'u', 'v' ], [ 'b', 'v', 'u' ] ] ).
In the third form, the quiver is described by just one string, for example: LeftQuiver( "Q(u,v)[a:u->v,b:v->u]" ).
In the fourth form, the number of vertices and the labels for vertices are given as separate arguments. This makes it possible to assign labels to only some of the vertices, and let the rest be labelled automatically. Additionally, this form of the constructor takes the quiver label and the patterns for labels of vertices and arrows as a list of three strings, instead of a single string.
In the last form of the constructor, the source and target vertices of each arrow must be specified by indices, and not by labels (all other forms of the constructor accept both labels and indices). This makes it possible to unambigously use indices even if the vertices have integers as labels. This form also allows the quiver label to be any object, not necessarily a string.
The arguments to the LeftQuiver constructor have the following meanings:
A string containing a label for the quiver (this is just an arbitrary name decided by the user or program who creates the quiver), optionally followed by patterns for labelling the vertices and arrows. The pattern for vertices, if present, is enclosed by parentheses: (); the pattern for arrows, if present, is enclosed by brackets: []. If both patterns are present, then the pattern for vertices should appear before the one for arrows.
For example, the value can be "Q" to give the quiver the label "Q" and use the default pattern for vertices and no pattern for arrows; or "Q(0)" to give the vertices labels 0, 1, 2, ...; or "Q[a]" to give the arrows labels 'a', 'b', 'c', ...; or "Q(u1)[alpha_1]" to give the vertices labels "u1", "u2", "u3", ..., and the arrows labels "alpha_1", "alpha_2", "alpha_3", ....
For vertices, the default pattern is "1", which means that the vertices are labelled with positive integers 1, 2, 3, .... For arrows, there is no default pattern; if the arrow pattern is not specified, then every arrow must be assigned a label explicitly.
Writing an empty string as a pattern is equivalent to not specifying the pattern (for example, "Q()[]" is equivalent to "Q").
The number of vertices in the quiver.
A list of arrow descriptions. Each arrow is described by either a list [ label, source, target ] or a list [ source, target ], where label is the label of the arrow (an arbitrary object), source is the label or index of the source vertex, and target is the label or index of the target vertex. If the second form (without label) is used for some arrows, then a pattern for labelling the arrows must be specified in the argument label_with_patterns (or label_with_patterns_list).
A list of labels for the vertices, given in the order of the vertices. Each label is an arbitrary object. All the labels should be distinct, and they should also be different from all arrow labels.
When the argument num_vertices is not used, the number of vertices is determined by the length of the list vertex_labels. In this case, the list must be dense.
When used together with the argument num_vertices, the list vertex_labels must not be longer than num_vertices, but it may be shorter, and it may contain holes. In this case, the vertices which are not present in the list are assigned labels automatically according to the vertex label pattern specified (if no pattern is specified, then they are labelled 1, 2, 3, ...).
A string containing all the information needed for creating the quiver. The string contains first the label for the quiver, then a specification of the vertices, enclosed in parentheses, then a specification of the arrows, enclosed in brackets.
The specification of the vertices has one of the following forms:
A positive integer, which is the number of vertices. With this form, the vertices are labelled in the default way, with integers 1, 2, 3, ... .
A label for each vertex, separated by commas.
Two patterns of the same form, separated by "..", specifying a range. For example, the vertex specification "u1..u4" produces four vertices labelled "u1", "u2", "u3", "u4". The vertex specification "g..k" produces five vertices labelled 'g', 'h', 'i', 'j', 'k'.
The specification of the arrows contains descriptions of the form "label:source->target" for each arrow, separated by commas.
As an example of a complete quiver description string, the string "Q(3)[a:1->2,b:2->3]" describes a quiver named "Q", with three vertices labelled 1, 2, 3, and two arrows 'a' and 'b'.
Contains the same information as the argument label_with_patterns, but as a list [ label, vertex_pattern, arrow_pattern ] of three strings. Each of the strings vertex_pattern and arrow_pattern may be the empty string. For the vertex pattern, the empty string is equivalent to the string "1", meaning that the vertices are labelled with positive integers 1, 2, 3, .... For the arrow pattern, the empty string means that no pattern is used, and thus every arrow needs to be labelled explicitly.
The label for the quiver.
A dense list containing labels for all the arrows. The number of arrows is determined by the length of this list, which must be the same as the lengths of the lists source_indices and target_indices.
A dense list containing the source vertex of each arrow, given as a positive integer (the index of the vertex).
A dense list containing the target vertex of each arrow, given as a positive integer (the index of the vertex).
gap> LeftQuiver( "Q", 2, [ [ 'a', 1, 2 ], [ 'b', 2, 1 ] ]); Q(2)[a:1->2,b:2->1] gap> LeftQuiver( "Q[a]", 2, [ [ 1, 2 ], [ 2, 1 ] ]); Q(2)[a:1->2,b:2->1] gap> LeftQuiver( "R[a]", ['u','v'], [ [ 'u', 'v' ], [ 'v', 'u' ] ]); R(u,v)[a:u->v,b:v->u] gap> LeftQuiver( "R(u)[a]", 2, [ [ 'u', 'v' ], [ 'v', 'u' ] ]); R(u,v)[a:u->v,b:v->u] gap> LeftQuiver( "Q(u1)[alpha_1]", 3, [ [ 2, 1 ], [ 2, 3 ] ] ); Q(u1,u2,u3)[alpha_1:u2->u1,alpha_2:u2->u3] gap> LeftQuiver( "Q(u1)[alpha_1]", 3, [ [ "u2", "u1" ], [ "u2", "u3" ] ] ); Q(u1,u2,u3)[alpha_1:u2->u1,alpha_2:u2->u3] gap> LeftQuiver( "Q(0)[a]", 2, [ [ 0, 0 ], [ 0, 1 ] ] ); Q(0,1)[a:0->0,b:0->1] gap> LeftQuiver( "A3", 3, [ [ 'a', 1, 2 ], [ 'b', 2, 3 ] ] ); A3(3)[a:1->2,b:2->3] gap> LeftQuiver( "A3(3)[a:1->2,b:2->3]" ); A3(3)[a:1->2,b:2->3] gap> LeftQuiver( "Q(u0..u3)[a:u0->u3,b:u1->u2,c:u2->u3]" ); Q(u0,u1,u2,u3)[a:u0->u3,b:u1->u2,c:u2->u3]
‣ RightQuiver( label_with_patterns, num_vertices, arrows ) | ( operation ) |
‣ RightQuiver( label_with_patterns, vertex_labels, arrows ) | ( operation ) |
‣ RightQuiver( description ) | ( operation ) |
‣ RightQuiver( label_with_patterns_list, num_vertices, vertex_labels, arrows ) | ( operation ) |
‣ RightQuiver( label, vertex_labels, arrow_labels, source_indices, target_indices ) | ( operation ) |
Returns: IsLeftQuiver (1.1-8)
Constructor for right-oriented quivers.
This works exactly like LeftQuiver (1.2-1), except that the quiver is right-oriented (that is, the convention for order in multiplication of paths is the opposite of that used for left-oriented quivers).
gap> RQ := RightQuiver( "Q(3)[a:1->2,b:2->3]" ); Q(3)[a:1->2,b:2->3] gap> RQ.a * RQ.b; (a*b) gap> RQ.b * RQ.a; fail gap> LQ := LeftQuiver( "Q(3)[a:1->2,b:2->3]" ); Q(3)[a:1->2,b:2->3] gap> LQ.b * LQ.a; (b*a) gap> LQ.a * LQ.b; fail
‣ Quiver( quiver_cat, label_with_patterns, num_vertices, arrows ) | ( operation ) |
‣ Quiver( quiver_cat, label_with_patterns, vertex_labels, arrows ) | ( operation ) |
‣ Quiver( quiver_cat, description ) | ( operation ) |
‣ Quiver( quiver_cat, label_with_patterns_list, num_vertices, vertex_labels, arrows ) | ( operation ) |
‣ Quiver( quiver_cat, label, vertex_labels, arrow_labels, source_indices, target_indices ) | ( operation ) |
Returns: IsQuiver (1.1-7)
Constructor for quivers.
These operations are exactly the same as LeftQuiver (1.2-1) and RightQuiver (1.2-2), except that they have an additional first argument quiver_cat, which specifies whether the quiver should be left- or right-oriented. The value of this argument should be either IsLeftQuiver (1.1-8) or IsRightQuiver (1.1-9).
gap> LQ := Quiver( IsLeftQuiver, "Q(2)[a:1->2,b:1->2]" ); Q(2)[a:1->2,b:1->2] gap> RQ := Quiver( IsRightQuiver, "Q(2)[a:1->2,b:1->2]" ); Q(2)[a:1->2,b:1->2] gap> IsLeftQuiver( LQ ); true gap> IsRightQuiver( RQ ); true
‣ MakeLabelsFromPattern( pattern, n ) | ( operation ) |
‣ MakeLabelsFromPattern( pattern, n, fixed_labels ) | ( operation ) |
Returns: list
Make a list of n labels (for vertices or arrows) from the pattern pattern. The argument fixed_labels may be used to specify some labels that deviate from the pattern.
This is useful in combination with the quiver constructors that have the arguments vertex_labels, arrow_labels, source_indices, and target_indices. This operation gives a convenient way to produce the lists vertex_labels and arrow_labels.
gap> MakeLabelsFromPattern( "a", 5 ); "abcde" gap> MakeLabelsFromPattern( "F", 5 ); "FGHIJ" gap> MakeLabelsFromPattern( "0", 5 ); [ 0, 1, 2, 3, 4 ] gap> MakeLabelsFromPattern( "-2", 5 ); [ -2, -1, 0, 1, 2 ] gap> MakeLabelsFromPattern( "foo38", 5 ); [ "foo38", "foo39", "foo40", "foo41", "foo42" ] gap> MakeLabelsFromPattern( "spam3", 5, [,,"egg"] ); [ "spam3", "spam4", "egg", "spam6", "spam7" ] gap> LeftQuiver( "Q", MakeLabelsFromPattern( "u", 3 ), > MakeLabelsFromPattern( "a", 4 ), > [ 1, 1, 2, 3 ], [ 1, 2, 3, 2 ] ); Q(u,v,w)[a:u->u,b:u->v,c:v->w,d:w->v]
‣ Label( Q ) | ( attribute ) |
The label of the quiver Q.
‣ LabelAsString( Q ) | ( attribute ) |
Returns: IsString
The label of the quiver Q, as a string.
‣ QuiverCategory( Q ) | ( attribute ) |
Returns: category
Returns the category Q belongs to; either IsLeftQuiver (1.1-8) or IsRightQuiver (1.1-9).
‣ Vertices( Q ) | ( attribute ) |
Returns: list of IsVertex (1.1-5)
Returns the vertices of the quiver Q as a list.
The ordering of the list corresponds to the ordering of the vertices in the quiver. That is, the vertex at position i in the list has number i (see VertexNumber (1.5-6)) and is the vertex which is returned by Vertex( Q, i ).
‣ Arrows( Q ) | ( attribute ) |
Returns: list of IsArrow (1.1-6)
Returns the arrows of the quiver Q as a list.
The ordering of the list corresponds to the ordering of the arrows in the quiver. That is, the arrow at position i in the list has number i (see ArrowNumber) and is the arrow which is returned by Arrow( Q, i ).
‣ VertexLabels( Q ) | ( attribute ) |
Returns: list
Returns the labels of the vertices of the quiver Q as a list.
The ordering of the list corresponds to the ordering of the vertices in the quiver.
‣ ArrowLabels( Q ) | ( attribute ) |
Returns: list
Returns the arrows of the quiver Q as a list.
The ordering of the list corresponds to the ordering of the arrows in the quiver.
‣ NumberOfVertices( Q ) | ( attribute ) |
Returns: integer
The number of vertices in the quiver Q.
‣ NumberOfArrows( Q ) | ( attribute ) |
Returns: integer
The number of arrows in the quiver Q.
‣ ArrowSourceIndices( Q ) | ( attribute ) |
Returns: list of positive integers
Returns the sources of all arrows in the quiver, given as a list L of positive integers, such that L[i] is the index of the source vertex of the arrow with index i.
‣ ArrowTargetIndices( Q ) | ( attribute ) |
Returns: list of positive integers
Returns the targets of all arrows in the quiver, given as a list L of positive integers, such that L[i] is the index of the target vertex of the arrow with index i.
‣ PrimitivePaths( Q ) | ( attribute ) |
Returns: list of IsPrimitivePath (1.1-2)
Returns the primitive paths of the quiver Q as a list.
This list contains the vertices first and then the arrows, all ordered in the usual way. That is, we have PrimitivePaths( Q ) = Concatenation( Vertices( Q ), Arrows( Q ) ).
‣ Vertex( Q, i ) | ( operation ) |
Returns: IsVertex
The vertex with number i in the quiver Q.
‣ Arrow( Q, i ) | ( operation ) |
Returns: IsArrow (1.1-6)
The arrow with number i in the quiver Q.
‣ PrimitivePathByLabel( Q, label ) | ( operation ) |
‣ \[\]( Q, label ) | ( operation ) |
Returns: IsPrimitivePath (1.1-2) or fail
Returns the primitive path (vertex or arrow) of the quiver Q which has label as label, if any. If no such path exists, then fail is returned. The operation Q[ label ] is equivalent to PrimitivePathByLabel( Q, label ).
‣ PathFromString( arg1, arg2 ) | ( operation ) |
‣ \.( arg1, arg2 ) | ( operation ) |
‣ QuiverOfPath( p ) | ( attribute ) |
Returns: IsQuiver (1.1-7)
The quiver containing the path p.
‣ Source( p ) | ( attribute ) |
‣ Target( p ) | ( attribute ) |
‣ LeftEnd( p ) | ( attribute ) |
‣ RightEnd( p ) | ( attribute ) |
Returns: IsVertex (1.1-5)
The source of a path is the vertex where the path starts; the target of a path is the vertex where the path ends. The left end and right end of a path p are defined as the vertices with the property LeftEnd( p ) * p * RightEnd( p ) = p.
In a left-oriented quiver, the left end of a path is the target and the right end is the source. In a right-oriented quiver, the left end of a path is the source and the right end is the target.
‣ Length( p ) | ( attribute ) |
Returns: nonnegative integer
The length of the path p.
‣ Label( p ) | ( attribute ) |
The label of the primitive path p. This is normally a character (such as 'a' or 'b') or a string (such as "alpha"), but can be any object.
‣ LabelAsString( p ) | ( attribute ) |
Returns: IsString
The label of the primitive path p, as a string.
‣ VertexNumber( v ) | ( attribute ) |
Returns: positive integer
The number of the vertex v. In a quiver with n vertices, the vertices are assigned numbers 1, \ldots, n when the quiver is constructed.
‣ ArrowNumber( a ) | ( attribute ) |
Returns: positive integer
The number of the arrow a. In a quiver with m arrows, the arrows are assigned numbers 1, \ldots, m when the quiver is constructed.
‣ ComposePaths( p_1, p_2, ..., p_n ) | ( function ) |
‣ ComposePathsLR( p_1, p_2, ..., p_n ) | ( function ) |
‣ ComposePaths2( p1, p2 ) | ( operation ) |
Returns: IsPath (1.1-1) or fail
Compose the paths p_1, p_2, ..., p_n, if possible.
For the operation ComposePaths, the paths should be given in source-to-target order. For the operation ComposePathsLR, the paths should be given in multiplication order.
The function ComposePaths, which takes an arbitrary number of arguments, is implemented by repeated calls to the two-argument operation ComposePaths2.
The functions ComposePaths and ComposePathsLR can also be called with a single argument, which is a list of paths.
‣ Composable( p1, p2 ) | ( operation ) |
Returns: true or false
Checks if the paths p1 and p2 can be composed in source-to-target order; that is, if the target of p1 equals the source of p2.
If this operation returns true, then calling Compose( p1, p2 ) will produce a path. If this operation returns false, then Compose( p1, p2 ) will return fail.
‣ ComposableLR( p1, p2 ) | ( operation ) |
Returns: true or false
Checks if the paths p1 and p2 can be composed in multiplication order.
If this operation returns true, then p1 * p2 will produce a path. If this operation returns false, then p1 * p2 will return fail.
‣ PathFromArrowList( list ) | ( operation ) |
‣ PathFromArrowListLR( list ) | ( operation ) |
‣ PathFromArrowListNC( list ) | ( operation ) |
Returns: IsPath (1.1-1)
Combine the arrows in the list list to a path. This operation is used internally. For users of QPA, it is usually more convenient to use the more general function ComposePaths. The variant PathFromArrowListLR assumes the arrows to be given in the multiplication order of the quiver. The variant PathFromArrowListNC does not check that the arrows are composable.
‣ \*( p1, p2 ) | ( function ) |
Returns: IsPath or fail
Compose the paths p1 and p2 in the multiplication order of the quiver. In a left-oriented quiver, we have p * q = ComposePaths( q, p ) for any paths p and q. In a right-oriented quiver, we have p * q = ComposePaths( p, q ) for any paths p and q.
‣ ArrowList( p ) | ( attribute ) |
‣ ArrowListLR( p ) | ( attribute ) |
Returns: list of IsArrow (1.1-6) list of arrows
The path p decomposed as a list of arrows.
‣ AsList( p ) | ( attribute ) |
‣ AsListLR( arg ) | ( attribute ) |
Returns: list of IsPrimitivePath (1.1-2) list of primitive paths
The path p decomposed as a list of primitive paths.
gap> Q := LeftQuiver( "Q", 3, [ [ 'a', 1, 2 ], [ 'b', 2, 3 ] ] );; gap> AsList( Q.ba ); [ (a), (b) ] gap> AsListLR( Q.ba ); [ (b), (a) ] gap> ArrowList( Q.ba ); [ (a), (b) ] gap> ArrowListLR( Q.ba ); [ (b), (a) ] gap> AsList( Q[ 1 ] ); [ (1) ] gap> ArrowList( Q[ 1 ] ); [ ]
‣ TranslatePath( p, f ) | ( operation ) |
‣ Subpath( p, from, to ) | ( operation ) |
‣ SubpathLR( p, from, to ) | ( operation ) |
Returns: IsPath (1.1-1)
Extract a subpath of the path p.
The integers from and to identify vertices that the path passes through, counted from 0 to Length( p ). The operation Subpath counts the vertices from the source of the path to the target; the operation SubpathLR counts the vertices from left to right in multiplication order. The resulting subpath is the part of p between vertices from and to.
This is a path of length to - from. In particular, if from = to, then the result is a vertex.
gap> Q := LeftQuiver( "Q", 7, [ [ 'a', 1, 2 ], [ 'b', 2, 3 ], [ 'c', 3, 4 ], > [ 'd', 4, 5 ], [ 'e', 5, 6 ], [ 'f', 6, 7 ] ] );; gap> Subpath( Q.fedcba, 0, 4 ); (d*c*b*a) gap> Subpath( Q.fedcba, 1, 3 ); (c*b) gap> SubpathLR( Q.fedcba, 1, 3 ); (e*d)
‣ SubpathIndex( p, q ) | ( operation ) |
‣ SubpathIndexLR( arg1, arg2 ) | ( operation ) |
Returns: nonnegative integer or fail
Finds the first position (if any) in the path p where q appears as a subpath.
If q is not a subpath of p, then fail is returned. If q is a subpath of p, then SubpathIndex( p, q ) returns an integer i such that Subpath( p, i, i + Length( q ) ) = q, and SubpathIndexLR( p, q ) returns an integer j such that SubpathLR( p, j, j + Length( q ) ) = q.
Both SubpathIndex and SubpathIndexLR search through the path p from source to target for the first occurence of q. This means that in a left-oriented quiver, the rightmost occurence is found, while in a right-oriented quiver, the leftmost occurence is found.
gap> Q := LeftQuiver( "Q", 3, [ [ 'a', 1, 2 ], [ 'b', 2, 3 ], [ 'c', 3, 1 ] ] );; gap> SubpathIndex( Q.acbacba, Q.ac ); 2 gap> SubpathIndexLR( Q.acbacba, Q.ac ); 3
‣ ExtractSubpath( p, q ) | ( operation ) |
Returns: list containing two paths or fail
Finds the paths that remain if we remove the subpath q from the path p.
If q is not a subpath of p, then fail is returned. If q is a subpath of p, then the result is a list [ r1, r2 ] of two paths such that ComposePaths( r1, q, r2 ) = p.
If q occurs more than once as a subpath of p, then the first occurence (in source-to-target order) is used; that is, the same occurence that would be found by SubpathIndex( p, q ).
gap> Q := LeftQuiver( "Q", 3, [ [ 'a', 1, 2 ], [ 'b', 2, 3 ], [ 'c', 3, 1 ] ] );; gap> ExtractSubpath( Q.acbacba, Q.ac ); [ (b*a), (a*c*b) ]
‣ \/( p, q ) | ( operation ) |
Returns: list containing two paths or fail
Divide the path p by the path q, if possible.
If q is not a subpath of p, then fail is returned. If q is a subpath of p, then the result is a list [ r1, r2 ] of two paths such that r1 * q * r2 = p.
In a right-oriented quiver, this operation is exactly the same as ExtractSubpath. In a left-oriented quiver, this operation is the same as ExtractSubpath except that the paths r1 and r2 in the result occur in the opposite order.
gap> Q := LeftQuiver( "Q", 3, [ [ 'a', 1, 2 ], [ 'b', 2, 3 ], [ 'c', 3, 1 ] ] );; gap> Q.acbacba / Q.ac; [ (a*c*b), (b*a) ]
‣ PathOverlaps( p, q ) | ( operation ) |
Returns: list of pairs of paths
Finds overlaps between the paths p and q.
Returns a list of all pairs [ b, c ] of paths such that p * c = b * q.
gap> Q := LeftQuiver( "Q", 3, [ [ 'a', 1, 2 ], [ 'b', 2, 3 ], [ 'c', 3, 1 ] ] );; gap> PathOverlaps( Q.acbacba, Q.bacbac ); [ [ (a*c*b*a*c), (c*b*a*c) ], [ (a*c), (c) ] ]
‣ OppositeQuiver( Q ) | ( attribute ) |
Returns: IsQuiver (1.1-7)
Returns the opposite quiver of Q.
‣ OppositePath( p ) | ( attribute ) |
Returns: IsPath (1.1-1)
Returns the path corresponding to p in the opposite quiver.
‣ QuiverProduct( Q, R ) | ( operation ) |
Returns: IsQuiver (1.1-7)
Returns the product quiver of Q and R.
‣ QuiverProduct( L ) | ( operation ) |
Returns: IsQuiver (1.1-7)
Returns the product quiver of the quivers in the list L.
‣ ProjectPathFromProductQuiver( n, p ) | ( operation ) |
‣ IncludePathInProductQuiver( PQ, n, vertices, p ) | ( operation ) |
‣ PathInProductQuiver( PQ, paths, permutation ) | ( operation ) |
‣ PathInProductQuiver( PQ, paths ) | ( operation ) |
generated by GAPDoc2HTML