GAP (QPA) - Chapter 13: Degeneration order for modules in finite type

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

13 Degeneration order for modules in finite type
13.1 Introduction
13.2 Basic definitions
13.3 Defining Auslander-Reiten quiver in finite type
13.3-1 ARQuiverNumerical
13.3-2 IsARQuiverNumerical
13.3-3 NumberOfIndecomposables
13.3-4 NumberOfProjectives
13.4 Elementary operations
13.4-1 DimensionVector
13.4-2 DimHom
13.4-3 DimEnd
13.4-4 OrbitDim
13.4-5 OrbitCodim
13.4-6 DegOrderLEQ
13.4-7 DegOrderLEQNC
13.4-8 PrintMultiplicityVector
13.4-9 PrintMultiplicityVectors
13.5 Operations returning families of modules
13.5-1 ModulesOfDimVect
13.5-2 DegOrderPredecessors
13.5-3 DegOrderDirectPredecessors
13.5-4 DegOrderPredecessorsWithDirect
13.5-5 DegOrderSuccessors
13.5-6 DegOrderDirectSuccessors
13.5-7 DegOrderSuccessorsWithDirect

### 13 Degeneration order for modules in finite type

#### 13.1 Introduction

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).

#### 13.2 Basic definitions

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).

#### 13.3 Defining Auslander-Reiten quiver in finite type

##### 13.3-1 ARQuiverNumerical

`‣ 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>

##### 13.3-2 IsARQuiverNumerical

`‣ 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.

##### 13.3-3 NumberOfIndecomposables

`‣ NumberOfIndecomposables`( AR ) | ( attribute )

Argument: AR - an object from the category `IsARQuiverNumerical` (13.3-2).

Returns: the number of indecomposable modules in AR.

##### 13.3-4 NumberOfProjectives

`‣ NumberOfProjectives`( AR ) | ( attribute )

Argument: AR - an object from the category `IsARQuiverNumerical` (13.3-2).

Returns: the number of indecomposable projective modules in AR.

#### 13.4 Elementary operations

##### 13.4-1 DimensionVector

`‣ 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 ]

##### 13.4-2 DimHom

`‣ 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.

##### 13.4-3 DimEnd

`‣ 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.

##### 13.4-4 OrbitDim

`‣ 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).

##### 13.4-5 OrbitCodim

`‣ 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)!

##### 13.4-6 DegOrderLEQ

`‣ 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

##### 13.4-7 DegOrderLEQNC

`‣ DegOrderLEQNC`( 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 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).

##### 13.4-8 PrintMultiplicityVector

`‣ 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)".

##### 13.4-9 PrintMultiplicityVectors

`‣ 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).

#### 13.5 Operations returning families of modules

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!

##### 13.5-1 ModulesOfDimVect

`‣ 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.

##### 13.5-2 DegOrderPredecessors

`‣ 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)

##### 13.5-3 DegOrderDirectPredecessors

`‣ DegOrderDirectPredecessors`( 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 direct predecessors of module M in a degeneration order (see 13.2).

##### 13.5-4 DegOrderPredecessorsWithDirect

`‣ DegOrderPredecessorsWithDirect`( 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 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.

##### 13.5-5 DegOrderSuccessors

`‣ DegOrderSuccessors`( 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 successors of module M in a degeneration order (see 13.2).

##### 13.5-6 DegOrderDirectSuccessors

`‣ DegOrderDirectSuccessors`( 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 direct successors of module M in a degeneration order (see 13.2).

##### 13.5-7 DegOrderSuccessorsWithDirect

`‣ DegOrderSuccessorsWithDirect`( 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 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.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind

generated by GAPDoc2HTML