Many people learn by doing. This chapter is for them. Here, we provide a guided tour of the the SBStrips package together with commentary.
Before discussing string modules, we have to specify a SB algebra to GAP. We use functionality from the QPA package for this. Indeed, our GAP definition of SB algebra is an object for which IsSpecialBiserialAlgebra (QPA: IsSpecialBiserialAlgebra) returns true.
The first step is to define the presenting quiver quiv1. We use just one of the many methods QPA affords; see Quiver (QPA: Quiver no. of vertices, list of arrows) for details.
gap> quiv1 := Quiver( 2, > [ [ 1, 1, "a" ], [ 1, 2, "b" ], [ 2, 1, "c" ], [ 2, 2, "d" ] ] > ); <quiver with 2 vertices and 4 arrows>
The second step is to create a path algebra pa1. We need the quiver quiv1 that we just created and some field. For convenience, take Rationals (the ℚ object in GAP).
gap> pa1 := PathAlgebra( Rationals, quiv1 ); <Rationals[<quiver with 2 vertices and 4 arrows>]>
The third step is to define a list rels of relations over that path algebra. Relations are linear combinations of paths in pa1. The addition, subtraction and multiplication of elements can be performed using +, - and *, as normal. Paths are *-products of arrows in pa1. For details on refer to arrows of pa1, see . (QPA: . for a path algebra).
gap> rels := [ pa1.a * pa1.a, pa1.b * pa1.d, > pa1.c * pa1.b, pa1.d * pa1.c, > pa1.c * pa1.a * pa1.b, (pa1.d)^4, > pa1.a * pa1.b * pa1.c - pa1.b * pa1.c * pa1.a ]; [ (1)*a^2, (1)*b*d, (1)*c*b, (1)*d*c, (1)*c*a*b, (1)*d^4, (1)*a*b*c+(-1)*b*c*a ]
We impose a rule on the relations: they must be monomial relations or commutativity relations. This imposition causes no mathematical loss of generality, of course.
The fourth step is to create the ideal ideal generated by the relations and to tell GAP that the relations form a Gröbner basis of ideal.
gap> gb := GBNPGroebnerBasis( rels, pa1 ); [ (1)*a^2, (1)*b*d, (1)*c*b, (1)*d*c, (-1)*a*b*c+(1)*b*c*a, (1)*c*a*b, (1)*d^4 ] gap> ideal := Ideal( pa1, gb ); <two-sided ideal in <Rationals[<quiver with 2 vertices and 4 arrows>]>, (7 generators)> gap> GroebnerBasis( ideal, gb ); <complete two-sided Groebner basis containing 7 elements>
The final step is to quotient pa1 by ideal, and hence finally obtain the SB algebra object alg1
gap> alg1 := pa1/ideal; <Rationals[<quiver with 2 vertices and 4 arrows>]/ <two-sided ideal in <Rationals[<quiver with 2 vertices and 4 arrows>]>, (7 generators)>>
(This algebra is the same as SBStripsExampleAlgebra( 1 ). See A.2-1 for more information.)
We continue with the example SB algebra alg1, created in the previous section.
Consider the following string (graph) for alg1 (given in non-LaTeX versions of this documentation as a formal word).
(a)^{-1} (b) (c) (a)^{-1} (b) (d)^{-1} (c) (a)^{-1} (c)^{-1} (d)
Reading from left to right, the first symbol in this string graph is a and it has exponent -1. It's followed by 2 arrows with positive exponent (which we record as the positive integer "2"), then 1 with negative exponent (recorded as negative integer "-1"), then 1 positive ("1"), 1 negative ("-1"), 1 positive ("1"), 2 negative ("-2") and 1 positive ("1").
This is the information used when specifying the string graph to SBStrips. The operation Stripify (4.2-1) returns the strip representing this string graph. What gets printed is the formal word associated to the original string graph.
gap> s := Stripify( alg1.a, -1, [ 2, -1, 1, -1, 1, -2, 1 ] ); (a)^-1(b*c) (a)^-1(b) (d)^-1(c) (c*a)^-1(d) gap> IsStripRep( s ); true;
The reader will note that reading the string graph "from left to right" a moment ago was only possible of how the graph was written on the page. That same graph may be written equally well in the "reflected" format, as follows.
(d)^{-1} (c) (a) (c)^{-1} (d) (b)^{-1} (a) (c)^{-1} (b)^{-1} (a)
This gives us different defining data for the string. However, SBStrips is smart enough to know that these two are representations of the same object.
gap> t := Stripify( alg1.d, -1, [ 2, -1, 1, -1, 1, -2, 1 ] ); (d)^-1(c*a) (c)^-1(d) (b)^-1(a) (b*c)^-1(a) gap> s = t; true
We continue with the strip s for the SB algebra alg1 from the previous sections.
We know that s represents some (string) module X for alg1. The syzygy of that string module X is a direct sum of indecomposable string modules, each of which may be represented by string graph. Those string graphs, or rather strips representing them, can be calculated directly from s. This is the heart of the SBStrips package!
So, let's start calculating the "syzygy strips" of s. This calls for the attribute SyzygyOfStrip (4.5-1), which returns a list of strips, one for each indecomposable direct summand of the syzygy of its input.
gap> SyzygyOfStrip( s ); [ (v2)^-1(c) (a)^-1(b*c) (c*a)^-1(d^2), (a)^-1(v1), (d)^-1(v2) ] gap> Length( last ); 3
The call to Length (Reference: Length) reveals that the the syzygy of s has 3 indecomposable summands.
Of course, there's no reason to stop at 1st syzygies. SBStrips is able to take Nth syzygies very easily for N≥0. For example, we can calculate the 4th syzygy of s as follows.
gap> 4th_syz := NthSyzygyOfStrip( s, 4 ); [ (v2)^-1(c*a) (c)^-1(v2), (v2)^-1(d^2), (a)^-1(v1), (v2)^-1(d^2), (a)^-1(b*c) (a)^-1(v1), (d^2)^-1(v2), (v1)^-1(a), (v2)^-1(v2), (v2)^-1(c) (c*a)^-1(v2), (v1)^-1(a), (v2)^-1(v2), (v2)^-1(c) (c*a)^-1(v2), (v2)^-1(v2), (a)^-1(v1), (v2)^-1(c*a) (c)^-1(v2), (v2)^-1(d), (a)^-1(v1), (v2)^-1(d^2), (a)^-1(v1), (d^2)^-1(v2) ] gap> Length( 4th_syz ); 20
We find that the 4th syzygy of s has 20 indecomposable direct summands.
The reader will spot that many strips appear multiple times in 4th_syz. If you want to remove duplicates, then the most efficient way is with Set (Reference: Set). (Mathematically, this is like asking for just the isomorphism types of modules in the 4th syzygy of the module represented by s, ignoring how often that type is witnessed.)
Alternatively, you can use Collected (Reference: Collected), which turns the list into something that a mathematician might call a multiset. This means that the distinct strips are recorded along with their frequency in the list. For example, the second output below means that (v2)^-1(v2) occurs 3 times in 4th_syz while (v1)^-1(a) occurs 6 times.
gap> Set( 4th_syz ); [ (v2)^-1(v2), (v1)^-1(a), (v2)^-1(d), (v2)^-1(d^2), (v2)^-1(c*a) (c)^-1(v2), (a)^-1(b*c) (a)^-1(v1) ] gap> Collected( 4th_syz ); [ [ (v2)^-1(v2), 3 ], [ (v1)^-1(a), 6 ], [ (v2)^-1(d), 1 ], [ (v2)^-1(d^2), 5 ], [ (v2)^-1(c*a) (c)^-1(v2), 4 ], [ (a)^-1(b*c) (a)^-1(v1), 1 ] ]
This package uses the term collected lists for these multisets, and it offers several built-in functionalities for calculating collected lists of syzygies. Principal among these are CollectedSyzygyOfStrip (4.5-3) and CollectedNthSyzygyOfStrip (4.5-4).
gap> CollectedSyzygyOfStrip( s ); [ [ (a)^-1(v1), 1 ], [ (d)^-1(v2), 1 ], [ (v2)^-1(c) (a)^-1(b*c) (c*a)^-1(d^2), 1 ] ] gap> CollectedNthSyzygyOfStrip( s, 4 ); [ [ (v2)^-1(c) (c*a)^-1(v2), 4 ], [ (v2)^-1(v2), 3 ], [ (v1)^-1(a), 6 ], [ (v2)^-1(d^2), 5 ], [ (v2)^-1(d), 1 ], [ (a)^-1(b*c) (a)^-1(v1), 1 ] ]
The author recommends that, if calculating kth syzygies for large k (say k ≥ 10), you use a Collected method. Details can be found in 6.1.
This section is a short digression, more philosophical than computational.
A central point of the author's doctoral studies (refer [All ]) is that the syzygies of a string module should be arranged in a particular format. (A little more specifically, they should be written into a certain kind of array.) Most of the time this format does not print nicely onto the Euclidean plane so, sadly, there is little hope of GAP displaying syzygies in the most "optimal" way. The closest it can get -- which is not very close at all, frankly -- is the list format returned by SyzygyOfStrip or NthSyzygyOfStrip. However, this format compresses lots into a single line. This loses information and becomes a very inefficient way to store data (let along compute with them). By using functions like Collected, CollectedSyzygyOfStrip and CollectedNthSyzygyOfStrip, we lose what little information the list presentation holds onto, but we streamline out calculations greatly.
To see this, let s be the example strip from above and consider the 20th syzygy of s. The following calculation shows that it has 344732 distinct summands (many of which will be isomorphic). On the author's device, this took over 2 minutes to perform.
gap> NthSyzygyOfStrip( s, 20 );; gap> time; 130250 gap> Length( last2 ); 344732
Compare this with a Collected approach, wherein the 20th syzygy was calculated in a heartbeat and the 200th syzygy is not much more. For comparison, and as a small boast, we also include times for the 2000th, 20000th and 200000th syzygies for comparison.
gap> CollectedNthSyzygyOfStrip( s, 20 ); [ [ (v2)^-1(c) (c*a)^-1(v2), 66012 ], [ (v2)^-1(v2), 55403 ], [ (v1)^-1(a), 121414 ], [ (v2)^-1(d^2), 101901 ], [ (v2)^-1(d), 1 ], [ (a)^-1(b*c) (a)^-1(v1), 1 ] ] gap> time; 62 gap> CollectedNthSyzygyOfStrip( s, 200 ); [ [ (v2)^-1(c) (c*a)^-1(v2), 28610320653810477165032088685001500201865067503083660 ], [ (v2)^-1(v2), 24012263187173292438733091914788756514219413052446981 ] , [ (v1)^-1(a), 52622583840983769603765180599790256716084480555530640 ], [ (v2)^-1(d^2), 44165437642884416151601614150885951220530708429827491 ], [ (v2)^-1(d), 1 ], [ (a)^-1(b*c) (a)^-1(v1), 1 ] ] gap> time; 547 gap> CollectedNthSyzygyOfStrip( s, 2000 );; time; 5422 gap> CollectedNthSyzygyOfStrip( s, 20000 );; time; 54172 gap> CollectedNthSyzygyOfStrip( s, 200000 );; time; 548922
We warn the reader that, even in this easier-to-store collected form, the integers involved may become too big for GAP to handle. Effective book-keeping only increases the upper bound on information we can store; it doesn't remove it!
We continue with the SB algebra alg1 from before which, we remind the reader, was defined in terms of the quiver quiv1. There is nothing very special about the running example strip s that previous sections have focussed on. The associated string module is certainly not canonical in any way.
However, there are some string modules which really are canonical for one reason or another, and which SBStrips has methods to call. This includes the simple modules and, more generally, uniserial modules. It also includes the indecomposable projective or injective modules, provided that they are string modules (which is not guaranteeed).
To obtain the list of strips that describe the simple modules, use SimpleStripsOfSBAlg (4.3-1).
gap> SimpleStripsOfSBAlg( alg1 ); [ (v1)^-1(v1), (v2)^-1(v2) ]
The ith entry is the strip describing the ith simple module S_i.
The uniserial modules are also string modules. They correspond to paths in the SB algebra. There is a method for Stripify (4.2-1) that turns a path for the SB algebra into the corresponding strip.
gap> Stripify( alg1.a * alg1.b ); (a*b)^-1(v1) gap> Stripify( alg1.c ); (c)^-1(v2) gap> Stripify( alg1.d^3 ); (d^3)^-1(v2) gap> Stripify( alg1.v1 ); (v1)^-1(v1)
(A quick reminder on QPA syntax. Here, a, b, c and d are the names of arrows in quiv1. The corresponding elements of alg1 are called by alg1.a and alg1.b and so on. As in quiv1, paths are products of arrows. Thus, alg1.a * alg1.b is the element of alg1 corresponding to the path a * b ("a then b") in quiv1. We see that vertices or arrows of the SB algebra (such as alg1.v1 and alg1.c) are paths too. We also see an example of the ^ operation: alg2.d^3 is equivalent to alg2.d * alg2.d * alg2.d.)
Since vertices are still paths (trivially) and simple modules are uniserial (trivially), we therefore have a second way to access the simple modules of a SB algebra.
gap> s1 := Stripify( alg2.v1 );; gap> s2 := Stripify( alg2.v2 );; gap> SimpleStripsOfSBAlg( alg1 ); [ (v1)^-1(v1), (v2)^-1(v2) ] gap> [ s1, s2 ] = SimpleStripsOfSbAlg( alg2 ); true
Some of the indecomposable projective modules are string modules. The attribute IndecProjectiveStripsOfSBAlg (4.3-4) returns a list, whose rth entry is the strip describing the module P_r (if P_r is indeed a string module) or the boolean fail (if not). The attribute IndecInjectiveStripsOfSBAlg (4.3-5) is similar.
gap> ProjectiveStripsOfSbAlg( alg1 ); [ fail, (c*a)^-1(d^3) ] gap> InjectiveStripsOfSbAlg( alg1 ); [ fail, (v1)^-1(a*b) (d^3)^-1(v2) ]
The objective of the SBStrips package is to investigate the syzygies of string modules over SB algebras for patterns. There are some patterns, described in 3.3-2, that it already knows to look for. This section describes those functionalities. We will also see syzygies put to use in calculating the delooping level of modules and algebras, as explained more in 3.3-3.
We keep the algebra alg1 defined in previous sections. For comparison, we introduce an additional algebra using SBStripsExampleAlgebra (A.1-1), giving it the very imaginative name alg2.
gap> SetInfoLevel( InfoSBStrips, 3 ); gap> alg2 := SBStripsExampleAlgebra( 2 ); #I The quiver of this algebra has 3 vertices #I v1 #I v2 #I v3 #I and 3 arrows #I a: v1 --> v2 #I b: v2 --> v3 #I c: v3 --> v1 <Rationals[<quiver with 3 vertices and 3 arrows>]/ <two-sided ideal in <Rationals[<quiver with 3 vertices and 3 arrows>]>, (3 generators)>> gap> SetInfoLevel( InfoSBStrips, 2 );
By raising the level of InfoSBStrips (1.5-1) to 3, we make SBStrips provide a bit more detail about this example algebra. Full details can be found in A.2-2 but, for now, it suffices to say that alg2 is a Nakayama algebra: this means an algebra for which all indecomposable modules are uniserial. It follows that alg2 is representation finite and, a fortiori, syzygy finite.
Let's pick any old uniserial module U for alg2 and then call the associated strip u.
gap> UniserialStripsOfSBAlg( alg2 ); [ (v1)^-1(v1), (v2)^-1(v2), (v3)^-1(v3), (a)^-1(v1), (b)^-1(v2), (c)^-1(v3), (a*b)^-1(v1), (b*c)^-1(v2), (c*a)^-1(v3), (a*b*c)^-1(v1), (b*c*a)^-1(v2), (c*a*b)^-1(v3) ] gap> u := last[8]; (a*b)^-1(v1)
Is U weakly periodic? Recall that U is weakly periodic if there is some k>0 such that U is a direct summand of Ω^k(U). We'll test this by hunting for u amongst the syzygy strips of u. Initially, let's look amongst the first 4 syzygies using the operation IsWeaklyPeriodicStripByNthSyzygy (4.5-14).
gap> IsWeaklyPeriodicStripByNthSyzygy( u, 4 ); #I Examining strip: (a*b)^-1(v1) #I This strip does not occur as a summand of its first 4 syzygies false
No luck so far but observe that, since InfoSBStrips is currently at level 2, SBStrips has also provided some commentary alongside our non-result. Let us raise the threshold from 4 to 10 and try again.
gap> IsWeaklyPeriodicStripByNthSyzygy( u, 10 ); #I Examining strip: (a*b)^-1(v1) #I This strip first appears as a direct summand of its 6th syzygy true
Fantastic! We learn that strip u does appear among its first 10 syzygies. In fact, SBStrips is even kind enough to tell us the index of the earliest recurrence of u: at the 6th syzygy. (This information would not be printed if InfoSBStrips had value 1 or 0.)
Now let us take a uniserial module U -- for alg1, this time -- and conduct a similar investigation.
gap> UniserialStripsOfSBAlg( alg1 ); [ (v1)^-1(v1), (v2)^-1(v2), (a)^-1(v1), (b)^-1(v1), (c)^-1(v2), (d)^-1(v2), (a*b)^-1(v1), (b*c)^-1(v1), (c*a)^-1(v2), (d^2)^-1(v2), (d^3)^-1(v2) ] gap> uu := last[7]; (a*b)^-1(v1) gap> IsWeaklyPeriodicStripByNthSyzygy( uu, 10 ); #I Examining strip: (a*b)^-1(v1) #I This strip does not occur as a summand of its first 10 syzygies false gap> IsWeaklyPeriodicStripByNthSyzygy( uu, 100 ); #I Examining strip: (a*b)^-1(v1) #I This strip does not occur as a summand of its first 100 syzygies false gap> IsWeaklyPeriodicStripByNthSyzygy( uu, 10000 ); time; #I Examining strip: (a*b)^-1(v1) #I This strip does not occur as a summand of its first 10000 syzygies false 6703
We find that uu does not occur amongst its first 10000 syzygies. This certainly suggests that uu is not weakly periodic, but "absence of evidence is not evidence of absence" so this does not constitute a proof. On the basis of this test alone, we cannot rule out its first reccurence being at index 10001. Hunting among syzygy strips of uu for uu itself has been fruitless, therefore we should change tactic. We will now use the test IsFiniteSyzygyTypeStripByNthSyzygy (4.5-13) to calculate the set of syzygy strips of uu appearing at or before index 0, then the strips at or before index 1, then index 2 and so on up until a specified index N. If this ascending sequence of finite sets stabilizes at or before index N, then we may conclude that uu has finite syzygy type.
gap> IsFiniteSyzygyTypeStripByNthSyzygy( uu, 10000 ); #I Examining strip: (a*b)^-1(v1) #I This strip has finite syzygy type. #I The set of strings appearing as summands of its first N syzygies st\ abilizes at N=4, at which point it has cardinality 6 true
This is indeed what happens. Handily, SBStrips also tells us the index at which stabilization occurs (namely 4) and how many distinct strips were seen at or before this index. We deduce that any strips that are going to occur would do so by the 4th syzygy. Since uu did not recur by then, we know that it never will.
If we seek modules of infinite syzygy type, we should not test any strips over alg2. We know the answer will be negative in that case, since alg2 is a representation finite algebra and so all of its modules are trivially of finite syzygy type. Instead, we turn again to strips over alg1.
We need look no further than the simple module at vertex 1.
gap> s1 := SimpleStripsOfSBAlg( alg1 )[1]; (v1)^-1(v1) gap> IsFiniteSyzygyTypeStripByNthSyzygy( s1, 10 ); #I Examining strip: (v1)^-1(v1) #I The set of strings appearing as summands of its first 10 syzygies h\ as cardinality 15 false gap> IsFiniteSyzygyTypeStripByNthSyzygy( s1, 100 ); #I Examining strip: (v1)^-1(v1) #I The set of strings appearing as summands of its first 100 syzygies \ has cardinality 105 false gap> IsFiniteSyzygyTypeStripByNthSyzygy( s1, 1000 ); #I Examining strip: (v1)^-1(v1) #I The set of strings appearing as summands of its first 1000 syzygies\ has cardinality 1005 false gap> time; 284860
(Of course these non-results can only be suggestive rather than conclusive.)
One can also explore whether a string module X is a direct summand of syzygy Y for some Y or, more generally, whether syzygy^k X is a direct summand of syzygy^k+1 Y for some Y. When this happens, we say X can be k-delooped. The delooping level of a module is the smallest k ≥ 0 for which it can be k-delooped or +∞ if no such k exists.
SBStrips provides the operation DeloopingLevelOfStripIfAtMostN (4.5-15) to determine the delooping level of a module, aborting the calculation and returning fail if it finds the delooping level exceeds a user-specified threshold.
gap> U := UniserialStripsOfSBAlg( alg1 );; gap> a := U[3]; b := U[4]; ab := U[7]; (a)^-1(v1) (b)^-1(v1) (a*b)^-1(v1) gap> DeloopingLevelOfStripIfAtMostN( a, 0 ); 0 gap> DeloopingLevelOfStripIfAtMostN( a, 1 ); 0 gap> DeloopingLevelOfStripIfAtMostN( b, 0 ); fail gap> DeloopingLevelOfStripIfAtMostN( b, 1 ); 1 gap> DeloopingLevelOfStripIfAtMostN( ab, 10 ); 2
The delooping level of a SB algebra is the supremum of the delooping levels of its simple modules. SBStrips provides DeloopingLevelOfSBAlgIfAtMostN (4.6-2) to calculate this quantity for algebras in a fashion similar to above with modules.
gap> DeloopingLevelOfSBAlgIfAtMostN( alg1, 10 ); 0 gap> DeloopingLevelOfSBAlgIfAtMostN( alg2, 10 ); 10 gap> for k in [ 1 .. 5 ] do > Print( > DeloopingLevelOfSBAlgIfAtMostN( SBStripsExampleAlgebra( k ), 10 ) > ); > Print( "\n" ); > od; 0 0 2 0 1
We highlight that all of these examples return finite answers. Whether an arbitrary SB algebra has finite delooping level remains an open question. In general, if A has finite delooping level then A^op satisfies the big finitistic dimension conjecture, and this is still open for SB algebras. (The little finitistic dimension conjecture is settled in the affirmative; see [EHIS ]).
Another sufficient condition for A^op to satisfy the big finitistic dimension conjecture is that the injective A-modules have finite syzygy type [Ric ]. It is trivial that projective modules obviously have finite syzygy type. Over a SB algebra, the nonprojective (indecomposable) injective modules are string modules.
To explore this question, SBStrips provides the function TestInjectiveStripsUpToNthSyzygy (4.6-1). It calculates up to the Nth syzygy of each injective string module of a SB algebra, and prints a message whether they all have syzygy type at most N.
gap> SetInfoLevel( InfoSBStrips, 1 ); gap> alg_list := List( [ 1..5 ], SBStripsExampleAlgebra );; gap> SetInfoLevel( InfoSBStrips, 2 ); gap> for A in alg_list do > TestInjectiveStripsUpToNthSyzygy( A, 200 ); > Print( "\n" ); > od; #I Examining strip: (v1)^-1(a*b) (d*d*d)^-1(v2) #I This strip has finite syzygy type. #I The set of strings appearing as summands of its first N syzygies st\ abilizes at N=3, at which point it has cardinality 5 The given SB algebra has passed the test! #I Examining strip: (v1)^-1(a*b*c) #I This strip has finite syzygy type. #I The set of strings appearing as summands of its first N syzygies st\ abilizes at N=0, at which point it has cardinality 1 [...lengthy output omitted from documentation for space reasons...] The given SB algebra has passed the test! #I Examining strip: (v1)^-1(a*b*c*d) (f*g*h*f*g*h)^-1(v1) #I This strip has finite syzygy type. #I The set of strings appearing as summands of its first N syzygies st\ abilizes at N=7, at which point it has cardinality 14 [...omitted...] The given SB algebra has passed the test! #I Examining strip: (v7)^-1(n*o*p*a) (n*o*p)^-1(v7) #I This strip has finite syzygy type. #I The set of strings appearing as summands of its first N syzygies st\ abilizes at N=8, at which point it has cardinality 21 [...omitted...] The given SB algebra has passed the test! #I Examining strip: (v1)^-1(a*b*c*d*a) (e*f*g*e*f*g*e)^-1(v1) #I This strip has finite syzygy type. #I The set of strings appearing as summands of its first N syzygies st\ abilizes at N=6, at which point it has cardinality 13 [...omitted...] The given SB algebra has passed the test!
A combinatorial approach is all very well and good but perhaps you really do want a module for your SB algebra. SBStrips can provide!
For the following, recall from preceding sections the strip s for the algebra alg1. Further recall that alg1 was defined in terms of the quiver quiv1.
The strip s stands for a string module for alg1. That string module can be modelled as a representation of quiv1. To obtain that quiver representation from s, use ModuleOfStrip (4.5-5).
gap> module := ModuleOfStrip( s ); <[ 6, 5 ]> gap> Print( module ); <Module over <Rationals[<quiver with 2 vertices and 4 arrows>]/ <two-sided ideal in <Rationals[<quiver with 2 vertices and 4 arrows>]> , (7 generators)>> with dimension vector [ 6, 5 ]>
You can turn a list of strips into a list of modules using ModuleOfStrip (4.5-5).
gap> 4th_syz := NthSyzygyOfStrip( s, 4 );; gap> ModuleOfStrip( 4th_syz ); [ <[ 2, 2 ]>, <[ 0, 3 ]>, <[ 2, 0 ]>, <[ 0, 3 ]>, <[ 4, 1 ]>, <[ 0, 3 ]>, <[ 2, 0 ]>, <[ 0, 1 ]>, <[ 2, 2 ]>, <[ 2, 0 ]>, <[ 0, 1 ]>, <[ 2, 2 ]>, <[ 0, 1 ]>, <[ 2, 0 ]>, <[ 2, 2 ]>, <[ 0, 2 ]>, <[ 2, 0 ]>, <[ 0, 3 ]>, <[ 2, 0 ]>, <[ 0, 3 ]> ]
You can turn a collected list (see 6.1) of strips into a collected list of modules using ModuleOfStrip (4.5-5).
gap> coll_4th_syz := CollectedNthSyzygyOfStrip( s, 4 ); [ [ (v2)^-1(c) (c*a)^-1(v2), 4 ], [ (v2)^-1(v2), 3 ], [ (v1)^-1(a), 6 ], [ (v2)^-1(d^2), 5 ], [ (v2)^-1(d), 1 ], [ (a)^-1(b*c) (a)^-1(v1), 1 ] ] gap> ModuleOfStrip( coll_4th_syz ); [ [ <[ 2, 2 ]>, 4 ], [ <[ 0, 1 ]>, 3 ], [ <[ 2, 0 ]>, 6 ], [ <[ 0, 3 ]>, 5 ], [ <[ 0, 2 ]>, 1 ], [ <[ 4, 1 ]>, 1 ] ]
The latter two methods take a list (or collected list) of strips and return a list of modules (or a collected list, as appropriate). Perhaps you want the direct sum of all the modules in that list or collected list. Naive calls to QPA's inbuilt functionality turn out to be resource intensive. In its place, SBStrips offers the operation DirectSumModuleOfListOfStrips (4.5-6) or DirectSumModuleOfListOfStrips (4.5-6).
gap> 4th_syz := NthSyzygyOfStrip( s, 4 );; gap> coll_4th_syz := CollectedNthSyzygyOfStrip( s, 4 );; gap> DirectSumModuleOfListOfStrips( 4th_syz ); <[ 24, 29 ]> gap> DirectSumModuleOfListOfStrips( coll_4th_syz ); <[ 24, 29 ]>
generated by GAPDoc2HTML