13 Degeneration order for modules in finite type

This is an implementation of several tools for computing degeneration order for modules over algebras of finite type. It can be treated as a "subpackage" of QPA and used separately since the functions do not use any of QPA routines so far.

This subpackage has a little bit different philosophy than QPA in general. Namely, the "starting point" is not an algebra A defined by a Gabriel quiver with relations but an Auslander-Reiten (A-R) quiver of the category mod A, defined by numerical data (see `ARQuiverNumerical`

(13.3-1)). All the indecomposables (actually their isoclasses) have unique natural numbers established at the beginning, by invoking `ARQuiverNumerical`

(13.3-1). This function should be used before all further computations. An arbitrary module M is identified by its multiplicity vector (the sequence of multiplicities of all the indecomposables appearing in a direct sum decomposition of M).

Here we always assume that A is an algebra of finite representation type. Note that in this case deg-order coincide with Hom-order, and this fact is used in the algorithms of this subpackage. The main goal of this subpackage is to give tools for testing a deg-order relation between two A-modules and determining (direct) deg-order predecessors and successors (see 13.2 for basic definitions from this theory). As a side effect one can also obtain the dimensions of Hom-spaces between arbitrary modules (and in particular the dimension vectors of indecomposable modules).

Here we briefly recall the basic notions we use in all the functions from this chapter.

Let A be an algebra. We say that for two A-modules M and N of the same dimension vector d, M degenerates to N (N is a degeneration of M) iff N belongs to a Zariski closure of the orbit of M in a variety mod_A(d) of A-modules of dimension vector d. If it is the case, we write M <= N. It is well known that

(1) The relation <= is a partial order on the set of isomorphism classes of A-modules of dimension vector d.

(2) If A is an algebra of finite representation type, <= coincides with so-called Hom-order <=_{Hom}, defined as follows: M <=_{Hom} N iff [X,M] <= [X,N] for all indecomposable A-modules X, where by [Y,Z] we denote always the dimension of a Hom-space between Y and Z.

Further, if M < N (i.e. M <= N and M is not isomorphic to N), we say that M is a deg-order predecessor of N (resp. N is a deg-order successor of M). Moreover, we say that M is a direct deg-order predecessor of N if M < N and there is no M' such that M < M' < N (similarly for successors).

`‣ ARQuiverNumerical` ( ind, proj, list ) | ( function ) |

`‣ ARQuiverNumerical` ( name ) | ( function ) |

`‣ ARQuiverNumerical` ( name, param1 ) | ( function ) |

`‣ ARQuiverNumerical` ( name, param1, param2 ) | ( function ) |

Arguments: `ind` - number of indecomposable modules in our category;

`proj` - number of indecomposable projective modules in our category;

`list` - list of lists containing description of meshes in A-R quiver defined as follows:

`list`[i] = description of mesh ending in vertex (indec. mod.) number i having the shape [a1,...,an,t] where

a1,...,an = numbers of direct predecessors of i in A-R quiver;

t = number of tau(i), or 0 if tau i does not exist (iff i is projective).

In particular if i is projective `list`[i]=[a1,...,an,0] where a1,...,an are indec. summands of rad(i).

OR:

`list` second version - if the first element of `list` is a string "orbits" then the remaining elements should provide an alternative (shorter than above) description of A-R quiver as follows.

`list`[2] is a list of descriptions of orbits identified by chosen representatives. We assume that in case an orbit is non-periodic, then a projective module is its representative. Each element of list `list`[2] is a description of i-th orbit and has the shape:

`[l, [i1,t1], ... , [is,ts]]`

where

l = length of orbit - 1

`[i1,t1], ... , [is,ts]`

all the direct predecessors of a representative of this orbit, of the shape tau^{-t1}(i1), and i1 denotes the representative of orbit no. i1, and so on.

We assume first p elements of `list`[2] are the orbits of projectives.

REMARK: we ALWAYS assume that indecomposables with numbers 1..`proj` are projectives and the only projectives (further dimension vectors are interpreted according to this order of projectives!).

Alternative arguments:

`name` = string with the name of predefined A-R quiver;

`param1` = (optional) parameter for `name`;

`param2` = (optional) second parameter for `name`.

Call ARQuiverNumerical("what") to get a description of all the names and parameters for currently available predefined A-R quivers.

Returns: an object from the category `IsARQuiverNumerical`

(13.3-2).

This function "initializes" Auslander-Reiten quiver and performs all necessary preliminary computations concerning mainly determining the matrix of dimensions of all Hom-spaces between indecomposables.

Examples.

Below we define an A-R quiver of a path algebra of the Dynkin quiver D4 with subspace orientation of arrows.

gap> a := ARQuiverNumerical(12, 4, [ [0],[1,0],[1,0],[1,0],[2,3,4,1],[5,2],[5,3],[5,4],[6,7,8,5],[9,6],[9,7],[9,8] ]); <ARQuiverNumerical with 12 indecomposables and 4 projectives>

The same A-R quiver (with possibly little bit different enumeration of indecomposables) can be obtained by invoking:

gap> b := ARQuiverNumerical(12, 4, ["orbits", [ [2], [2,[1,0]], [2,[1,0]], [2,[1,0]] ] ]); <ARQuiverNumerical with 12 indecomposables and 4 projectives>

This A-R quiver can be also obtained by:

gap> a := ARQuiverNumerical("D4 subspace"); <ARQuiverNumerical with 12 indecomposables and 4 projectives>

since this is one of the predefined A-R quivers.

Another example of predefined A-R quiver: for an algebra from Bongartz-Gabriel list of maximal finite type algebras with two simple modules. This is an algebra with number 5 on this list.

gap> a := ARQuiverNumerical("BG", 5); <ARQuiverNumerical with 72 indecomposables and 2 projectives>

`‣ IsARQuiverNumerical` | ( category ) |

Objects from this category represent Auslander-Reiten (finite) quivers and additionally contain all data necessary for further computations (as components accessed as usual by !.name-of-component):

ARdesc = numerical description of AR quiver (as `list` in `ARQuiverNumerical`

(13.3-1)),

DimHomMat = matrix [dim Hom (i,j)] (=> rows 1..p contain dim. vectors of all indecomposables),

Simples = list of numbers of simple modules.

`‣ NumberOfIndecomposables` ( AR ) | ( attribute ) |

Argument: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2).

Returns: the number of indecomposable modules in `AR`.

`‣ NumberOfProjectives` ( AR ) | ( attribute ) |

Argument: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2).

Returns: the number of indecomposable projective modules in `AR`.

`‣ DimensionVector` ( AR, M ) | ( operation ) |

Arguments: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of an indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: a dimension vector of a module `M` in the form of a list. The order of dimensions in this list corresponds to an order of projectives defined in `AR` (cf. `ARQuiverNumerical`

(13.3-1)).

gap> a := ARQuiverNumerical("D4 subspace"); <ARQuiverNumerical with 12 indecomposables and 4 projectives> gap> DimensionVector(a, 7); [ 1, 1, 0, 1 ] gap> DimensionVector(a, [0,1,0,0,0,0,2,0,0,0,0,0]); [ 3, 3, 0, 2 ]

`‣ DimHom` ( AR, M, N ) | ( operation ) |

Arguments: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector;

`N` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: the dimension of the homomorphism space between modules `M` and `N`.

`‣ DimEnd` ( AR, M ) | ( operation ) |

Arguments: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: the dimension of the endomorphism algebra of a module `M`.

`‣ OrbitDim` ( AR, M ) | ( operation ) |

Arguments: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: the dimension of the orbit of module `M` (in the variety of representations of quiver with relations).

OrbitDim(`M`) = d_1^2+...+d_p^2 - dim End(`M`), where (d_i)_i = DimensionVector(`M`).

`‣ OrbitCodim` ( AR, M, N ) | ( operation ) |

Arguments: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector;

`N` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: the codimension of orbits of modules `M` and `N` (= dim End(`N`) - dim End(`M`)). [explain more???]

NOTE: The function does not check if it makes sense, i.e. if `M` and `N` are in the same variety ( = dimension vectors coincide)!

`‣ DegOrderLEQ` ( AR, M, N ) | ( operation ) |

Arguments: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector;

`N` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: true if `M`<=`N` in a degeneration order i.e. if `N` is a degeneration of `M` (see 13.2), and false otherwise.

NOTE: Function checks if it makes sense, i.e. if `M` and `N` are in the same variety ( = dimension vectors coincide). If not, it returns false and additionally prints warning.

gap> a := ARQuiverNumerical("R nilp"); <ARQuiverNumerical with 7 indecomposables and 2 projectives> gap> DimensionVector(a, 2); DimensionVector(a, 3); [ 2, 1 ] [ 2, 1 ] gap> DegOrderLEQ(a, 2, 3); true gap> DegOrderLEQ(a, 3, 2); false

`‣ DegOrderLEQNC` ( AR, M, N ) | ( operation ) |

`AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector;

`N` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: true if `M`<=`N` in a degeneration order i.e. if `N` is a degeneration of `M` (see 13.2), and false otherwise.

NOTE: Function does Not Check ("NC") if it makes sense, i.e. if `M` and `N` are in the same variety ( = dimension vectors coincide). If not, the result doesn't make sense!

It is useful when one wants to speed up computations (does not need to check the dimension vectors).

`‣ PrintMultiplicityVector` ( M ) | ( operation ) |

`M` - a list = multiplicity vector (cf. 13.1).

This function prints the multiplicity vector `M` in a more "readable" way (especially useful if `M` is long and sparse). It prints a "sum" of non-zero multiplicities in the form "multiplicity * (number-of-indecomposable)".

`‣ PrintMultiplicityVectors` ( list ) | ( operation ) |

`list` - a list of multiplicity vectors (cf. 13.1).

This function prints all the multiplicity vectors from the `list` in a more "readable" way, as `PrintMultiplicityVector`

(13.4-8).

The functions from this section use quite advanced algorithms on (potentially) big amount of data, so their runtimes can be long for "big" A-R quivers!

`‣ ModulesOfDimVect` ( AR, which ) | ( operation ) |

Arguments: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`which` - a number of an indecomposable module in `AR` or a dimension vector (see `DimensionVector`

(13.4-1)).

Returns: a list of all modules (= multiplicity vectors, see 13.1) with dimension vector equal to `which`.

`‣ DegOrderPredecessors` ( AR, M ) | ( operation ) |

Arguments: `AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: a list of all modules (= multiplicity vectors) which are the predecessors of module `M` in a degeneration order (see 13.2).

gap> a := ARQuiverNumerical("BG", 5); <ARQuiverNumerical with 72 indecomposables and 2 projectives> gap> preds := DegOrderPredecessors(a, 60);; Length(preds); 18 gap> DegOrderLEQ(a, preds[7], 60); true gap> dpreds := DegOrderDirectPredecessors(a, 60);; Length(dpreds); 5 gap> PrintMultiplicityVectors(dpreds); 1*(14) + 1*(64) 1*(10) + 1*(71) 1*(9) + 1*(67) 1*(5) + 1*(17) + 1*(72) 1*(1) + 1*(5) + 1*(20)

`‣ DegOrderDirectPredecessors` ( AR, M ) | ( operation ) |

`AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: a list of all modules (= multiplicity vectors) which are the direct predecessors of module `M` in a degeneration order (see 13.2).

`‣ DegOrderPredecessorsWithDirect` ( AR, M ) | ( operation ) |

`AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: a pair (2-element list) [`p`, `dp`] where

`p` = the same as a result of `DegOrderPredecessors`

(13.5-2);

`dp` = the same as a result of `DegOrderDirectPredecessors`

(13.5-3);

The function generates predecessors only once, so the runtime is exactly the same as DegOrderDirectPredecessors.

`‣ DegOrderSuccessors` ( AR, M ) | ( operation ) |

`AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: a list of all modules (= multiplicity vectors) which are the successors of module `M` in a degeneration order (see 13.2).

`‣ DegOrderDirectSuccessors` ( AR, M ) | ( operation ) |

`AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: a list of all modules (= multiplicity vectors) which are the direct successors of module `M` in a degeneration order (see 13.2).

`‣ DegOrderSuccessorsWithDirect` ( AR, M ) | ( operation ) |

`AR` - an object from the category `IsARQuiverNumerical`

(13.3-2);

`M` - a number of indecomposable module in `AR` or a multiplicity vector (cf. 13.1).

Returns: a pair (2-element list) [`s`, `ds`] where

`s` = the same as a result of `DegOrderSuccessors`

(13.5-5);

`ds` = the same as a result of `DegOrderDirectSuccessors`

(13.5-6);

The function generates successors only once, so the runtime is exactly the same as DegOrderDirectSuccessors.

generated by GAPDoc2HTML