GAP (QPA) - Chapter 8: Homological algebra

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 on]

8 Homological algebra
8.1 Homological algebra
8.1-1 1stSyzygy
8.1-2 AllComplementsOfAlmostCompleteTiltingModule
8.1-3 CotiltingModule
8.1-4 DominantDimensionOfAlgebra
8.1-5 DominantDimensionOfModule
8.1-6 ExtAlgebraGenerators
8.1-7 ExtOverAlgebra
8.1-8 FaithfulDimension
8.1-9 GlobalDimensionOfAlgebra
8.1-10 GorensteinDimension
8.1-11 GorensteinDimensionOfAlgebra
8.1-12 HaveFiniteCoresolutionInAddM
8.1-13 HaveFiniteResolutionInAddM
8.1-14 InjDimension
8.1-15 InjDimensionOfModule
8.1-16 InjectiveEnvelope
8.1-17 IsCotiltingModule
8.1-18 IsNthSyzygy
8.1-19 IsOmegaPeriodic
8.1-20 IsTtiltingModule
8.1-21 IyamaGenerator
8.1-22 LeftApproximationByAddTHat
8.1-23 LeftFacMApproximation
8.1-24 LeftMutationOfTiltingModuleComplement
8.1-25 LeftSubMApproximation
8.1-26 LiftingInclusionMorphisms
8.1-27 LiftingMorphismFromProjective
8.1-28 MinimalLeftAddMApproximation
8.1-29 MinimalRightApproximation
8.1-30 MorphismOnKernel
8.1-31 NthSyzygy
8.1-32 NthSyzygyNC
8.1-33 NumberOfComplementsOfAlmostCompleteTiltingModule
8.1-34 ProjDimension
8.1-35 ProjDimensionOfModule
8.1-36 ProjectiveCover
8.1-37 ProjectiveResolutionOfPathAlgebraModule
8.1-38 PullBack
8.1-39 PushOut
8.1-40 RightApproximationByPerpT
8.1-41 RightFacMApproximation
8.1-42 RightMutationOfTiltingModuleComplement
8.1-43 RightSubMApproximation
8.1-44 N_RigidModule
8.1-45 TiltingModule

### 8 Homological algebra

This chapter describes the homological algebra that is implemented in QPA.

The example used throughout this chapter is the following.

    gap> Q := Quiver(3,[[1,2,"a"],[1,2,"b"],[2,2,"c"],[2,3,"d"],
    > [3,1,"e"]]);;
    gap> KQ := PathAlgebra(Rationals, Q);;
    gap> AssignGeneratorVariables(KQ);;
    gap> rels := [d*e,c^2,a*c*d-b*d,e*a];;
    gap> A := KQ/rels;;
    gap> mat := [["a",[[1,2],[0,3],[1,5]]],["b",[[2,0],[3,0],[5,0]]],
    > ["c",[[0,0],[1,0]]],["d",[[1,2],[0,1]]],["e",[[0,0,0],[0,0,0]]]];;
    gap> N := RightModuleOverPathAlgebra(A,mat);;

#### 8.1 Homological algebra

##### 8.1-1 1stSyzygy

`‣ 1stSyzygy`( M ) | ( attribute )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: the first syzygy of the representation M as a representation.

##### 8.1-2 AllComplementsOfAlmostCompleteTiltingModule

`‣ AllComplementsOfAlmostCompleteTiltingModule`( M, X ) | ( operation )

`‣ AllComplementsOfAlmostCompleteCotiltingModule`( M, X ) | ( operation )

Arguments: M, X - two PathAlgebraMatModule's.

Returns: all the complements of the almost complete (co-)tilting module M as two exact sequences, the first is all complements which are gotten as an add M-resolution of X and the second is all complements which are gotten as an add M-coresolution of X. If there are no complements to the left of X, then an empty list is returned. Similarly for to the right of X. In particular, if X has no other complements the list `[[],[]]` is returned.

##### 8.1-3 CotiltingModule

`‣ CotiltingModule`( M, n ) | ( operation )

Arguments: M, n - a PathAlgebraMatModule and a positive integer.

Returns: false if M is not a cotilting module of injective dimension at most a. Otherwise, it returns the injective dimension of M and the resolution of all indecomposable injective modules in add M.

##### 8.1-4 DominantDimensionOfAlgebra

`‣ DominantDimensionOfAlgebra`( A, n ) | ( operation )

Arguments: A, n - a quiver algebra, a positive integer.

Returns: the dominant dimension of the algebra A if the dominant dimension is less or equal to n. If the function can decide that the dominant dimension is infinite, it returns `infinity`. Otherwise, if the dominant dimension is larger than n, then it returns `false`.

##### 8.1-5 DominantDimensionOfModule

`‣ DominantDimensionOfModule`( M, n ) | ( operation )

Arguments: M, n - a PathAlgebraMatModule, a positive integer.

Returns: the dominant dimension of the module M if the dominant dimension is less or equal to n. If the function can decide that the dominant dimension is infinite, it returns `infinity`. Otherwise, if the dominant dimension is larger than n, then it returns `false`.

##### 8.1-6 ExtAlgebraGenerators

`‣ ExtAlgebraGenerators`( M, n ) | ( operation )

Arguments: M - a module, n - a positive integer.

Returns: a list of three elements, where the first element is the dimensions of Ext^[0..n](M,M), the second element is the number of minimal generators in the degrees [0..n], and the third element is the generators in these degrees.

This function computes the generators of the Ext-algebra Ext^*(M,M) up to degree n.

##### 8.1-7 ExtOverAlgebra

`‣ ExtOverAlgebra`( M, N ) | ( operation )

Arguments: M, N - two modules.

Returns: a list of three elements `ExtOverAlgebra`, where the first element is the map from the first syzygy, Ω(M) to the projective cover, P(M) of the module M, the second element is a basis of \Ext^1(M,N) in terms of elements in \Hom(\Omega(M),N) and the third element is a function that takes as an argument a homomorphism in `Hom(Omega(M),N)` and returns the coefficients of this element when written in terms of the basis of \Ext^1(M,N).

The function checks if the arguments M and N are modules of the same algebra, and returns an error message otherwise. It \Ext^1(M,N) is zero, an empty list is returned.

##### 8.1-8 FaithfulDimension

`‣ FaithfulDimension`( M ) | ( attribute )

Arguments: M - a PathAlgebraMatModule.

Returns: the faithful dimension of the module M.

##### 8.1-9 GlobalDimensionOfAlgebra

`‣ GlobalDimensionOfAlgebra`( A, n ) | ( operation )

Arguments: A, n - a quiver algebra, a positive integer.

Returns: the global dimension of A if the global dimension is less or equal to n. If the function can decide that the global dimension is infinite, it returns `infinity`. Otherwise, if the global dimension is larger than n, then it returns `false`.

##### 8.1-10 GorensteinDimension

`‣ GorensteinDimension`( A ) | ( attribute )

Arguments: A - a quiver algebra.

Returns: the Gorenstein dimension of A, if the Gorenstein dimension has been computed. Otherwise it returns an error message.

##### 8.1-11 GorensteinDimensionOfAlgebra

`‣ GorensteinDimensionOfAlgebra`( A, n ) | ( operation )

Arguments: A, n - a quiver algebra, a positive integer.

Returns: the Gorenstein dimension of A if the Gorenstein dimension is less or equal to n. Otherwise, if the Gorenstein dimension is larger than n, then it returns `false`.

##### 8.1-12 HaveFiniteCoresolutionInAddM

`‣ HaveFiniteCoresolutionInAddM`( N, M, n ) | ( operation )

Arguments: N, M, n - two PathAlgebraMatModule's and an integer.

Returns: false if N does not have a coresolution of length at most n in add M, otherwise it returns the coresolution of N of length at most n.

##### 8.1-13 HaveFiniteResolutionInAddM

`‣ HaveFiniteResolutionInAddM`( N, M, n ) | ( operation )

Arguments: N, M, n - two PathAlgebraMatModule's and an integer.

Returns: false if N does not have a resolution of length at most n in add M, otherwise it returns the resolution of N of length at most n.

##### 8.1-14 InjDimension

`‣ InjDimension`( M ) | ( attribute )

Arguments: M - a PathAlgebraMatModule.

If the injetive dimension of the module M has been computed, then the projective dimension is returned.

##### 8.1-15 InjDimensionOfModule

`‣ InjDimensionOfModule`( M, n ) | ( operation )

Arguments: M, n - a PathAlgebraMatModule, a positive integer.

Returns: Returns the injective dimension of the module M if it is less or equal to n. Otherwise it returns false.

##### 8.1-16 InjectiveEnvelope

`‣ InjectiveEnvelope`( M ) | ( attribute )

Arguments: M - a module.

Returns: the injective envelope of M, that is, returns the map M\to I(M).

If the module M is zero, then the zero map from M is returned.

##### 8.1-17 IsCotiltingModule

`‣ IsCotiltingModule`( M ) | ( attribute )

Arguments: M - a PathAlgebraMatModule.

Returns: true if the module M has been checked to be a cotilting mdoule, otherwise it returns an error message.

##### 8.1-18 IsNthSyzygy

`‣ IsNthSyzygy`( M, n ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`), n -- a positive integer.

Returns: `true`, if the representation M is isomorphic to a n-th syzygy of some module, and false otherwise.

##### 8.1-19 IsOmegaPeriodic

`‣ IsOmegaPeriodic`( M, n ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`), n -- a positive integer.

Returns: `i`, where `i` is the smallest positive integer less or equal `n` such that the representation M is isomorphic to the `i`-th syzygy of M, and false otherwise.

##### 8.1-20 IsTtiltingModule

`‣ IsTtiltingModule`( M ) | ( attribute )

Arguments: M - a PathAlgebraMatModule.

Returns: true if the module M has been checked to be a tilting mdoule, otherwise it returns an error message.

##### 8.1-21 IyamaGenerator

`‣ IyamaGenerator`( M ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`).

Returns: a module N such that M is a direct summand of N and such that the global dimension of the endomorphism ring of N is finite using the algorithm provided by Osamu Iyama (add reference here).

##### 8.1-22 LeftApproximationByAddTHat

`‣ LeftApproximationByAddTHat`( T, M ) | ( operation )

Arguments: T, M -- two path algebra modules (`PathAlgebraMatModule`).

Returns: the minimal left widehatadd T-approximation of M.

The function checks if the first argument is a cotilting module, that is, checks if the attribute of `IsCotiltingModule` is set. This attribute can be set by giving the command `CotiltingModule( T, n )` for some positive integer `n` which is at least the injective dimension of the module T.

##### 8.1-23 LeftFacMApproximation

`‣ LeftFacMApproximation`( C, M ) | ( operation )

`‣ MinimalLeftFacMApproximation`( C, M ) | ( operation )

Arguments: C, M -- two path algebra modules (`PathAlgebraMatModule`).

Returns: a left \operatorname{Fac} M-approximation of the module C, where the first version returns a not necessarily minimal left \operatorname{Fac} M-approximation and the second returns a minimal approximation.

##### 8.1-24 LeftMutationOfTiltingModuleComplement

`‣ LeftMutationOfTiltingModuleComplement`( M, N ) | ( operation )

`‣ LeftMutationOfCotiltingModuleComplement`( M, N ) | ( operation )

Arguments: M, N -- two path algebra modules (`PathAlgebraMatModule`).

Returns: a left mutation of the complement N of the almost complete tilting/cotilting module M, if such a complement exists. Otherwise it returns false.

##### 8.1-25 LeftSubMApproximation

`‣ LeftSubMApproximation`( C, M ) | ( operation )

`‣ MinimalLeftSubMApproximation`( C, M ) | ( operation )

Arguments: C, M -- two path algebra modules (`PathAlgebraMatModule`).

Returns: a minimal left \operatorname{Sub} M-approximation of the module C.

##### 8.1-26 LiftingInclusionMorphisms

`‣ LiftingInclusionMorphisms`( f, g ) | ( operation )

Arguments: f, g - two homomorphisms with common range.

Returns: a factorization of g in terms of f, whenever possible and `fail` otherwise.

Given two inclusions f\colon B\to C and g\colon A\to C, this function constructs a morphism from A to B, whenever the image of g is contained in the image of f. Otherwise the function returns fail. The function checks if f and g are one-to-one, if they have the same range and if the image of g is contained in the image of f.

##### 8.1-27 LiftingMorphismFromProjective

`‣ LiftingMorphismFromProjective`( f, g ) | ( operation )

Arguments: f, g - two homomorphisms with common range.

Returns: a factorization of g in terms of f, whenever possible and `fail` otherwise.

Given two morphisms f\colon B\to C and g\colon P\to C, where P is a direct sum of indecomposable projective modules constructed via `DirectSumOfQPAModules` and f an epimorphism, this function finds a lifting of g to B. The function checks if P is a direct sum of indecomposable projective modules, if f is onto and if f and g have the same range.

    gap> B := BasisVectors(Basis(N));
    [ [ [ 1, 0, 0 ], [ 0, 0 ], [ 0, 0 ] ],
      [ [ 0, 1, 0 ], [ 0, 0 ], [ 0, 0 ] ],
      [ [ 0, 0, 1 ], [ 0, 0 ], [ 0, 0 ] ],
      [ [ 0, 0, 0 ], [ 1, 0 ], [ 0, 0 ] ],
      [ [ 0, 0, 0 ], [ 0, 1 ], [ 0, 0 ] ],
      [ [ 0, 0, 0 ], [ 0, 0 ], [ 1, 0 ] ],
      [ [ 0, 0, 0 ], [ 0, 0 ], [ 0, 1 ] ] ]
    gap> g := SubRepresentationInclusion(N,[B[1],B[4]]);
    <<[ 1, 2, 2 ]> ---> <[ 3, 2, 2 ]>>

    gap> f := SubRepresentationInclusion(N,[B[1],B[2]]);
    <<[ 2, 2, 2 ]> ---> <[ 3, 2, 2 ]>>

    gap> LiftingInclusionMorphisms(f,g);
    <<[ 1, 2, 2 ]> ---> <[ 2, 2, 2 ]>>

    gap> S := SimpleModules(A);
    [ <[ 1, 0, 0 ]>, <[ 0, 1, 0 ]>, <[ 0, 0, 1 ]> ]
    gap> homNS := HomOverAlgebra(N,S[1]);
    [ <<[ 3, 2, 2 ]> ---> <[ 1, 0, 0 ]>>
        , <<[ 3, 2, 2 ]> ---> <[ 1, 0, 0 ]>>
        , <<[ 3, 2, 2 ]> ---> <[ 1, 0, 0 ]>>
         ]
    gap> f := homNS[1];
    <<[ 3, 2, 2 ]> ---> <[ 1, 0, 0 ]>>

    gap> p := ProjectiveCover(S[1]);
    <<[ 1, 4, 3 ]> ---> <[ 1, 0, 0 ]>>

    gap> LiftingMorphismFromProjective(f,p);
    <<[ 1, 4, 3 ]> ---> <[ 3, 2, 2 ]>>
    [ [(1)*v1], [(1)*v2], [(1)*v3], [(1)*a], [(1)*b], [(1)*c], [(1)*d], [(1)*e]
     ] )> >

##### 8.1-28 MinimalLeftAddMApproximation

`‣ MinimalLeftAddMApproximation`( C, M ) | ( attribute )

`‣ MinimalLeftApproximation`( C, M ) | ( attribute )

Arguments: C, M - two modules.

Returns: the minimal left add M-approximation of the module C. Note: The order of the arguments is opposite of the order for minimal right approximations.

##### 8.1-29 MinimalRightApproximation

`‣ MinimalRightApproximation`( M, C ) | ( attribute )

`‣ MinimalRightAddMApproximation`( M, C ) | ( attribute )

Arguments: M, C - two modules.

Returns: the minimal right add M-approximation of the module C. Note: The order of the arguments is opposite of the order for minimal left approximations.

##### 8.1-30 MorphismOnKernel

`‣ MorphismOnKernel`( f, g, alpha, beta ) | ( operation )

`‣ MorphismOnImage`( f, g, alpha, beta ) | ( operation )

`‣ MorphismOnCoKernel`( f, g, alpha, beta ) | ( operation )

Arguments: f, g, alpha, beta - four homomorphisms of modules.

Returns: the morphism induced on the kernels, the images or the cokernels of the morphisms f and g, respectively, whenever f: A-> B, β: B-> B', α: A-> A' and g: A'-> B' forms a commutative diagram.

It is checked if f, g, alpha, beta forms a commutative diagram, that is, if f \beta - \alpha g = 0.

    gap> hom := HomOverAlgebra(N,N);
    [ <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
        , <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
        , <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
        , <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
        , <<[ 3, 2, 2 ]> ---> <[ 3, 2, 2 ]>>
         ]
    gap> g := MorphismOnKernel(hom[1],hom[2],hom[1],hom[2]);
    <<[ 2, 2, 2 ]> ---> <[ 2, 2, 2 ]>>

    gap> IsomorphicModules(Source(g),Range(g));
    true
    gap> p := ProjectiveCover(N);
    <<[ 3, 12, 9 ]> ---> <[ 3, 2, 2 ]>>

    gap> N1 := Kernel(p);
    <[ 0, 10, 7 ]>
    gap> pullback := PullBack(p,hom[1]);
    [ <<[ 3, 12, 9 ]> ---> <[ 3, 2, 2 ]>>
        , <<[ 3, 12, 9 ]> ---> <[ 3, 12, 9 ]>>
         ]
    gap> Kernel(pullback[1]);
    <[ 0, 10, 7 ]>
    gap> IsomorphicModules(N1,Kernel(pullback[1]));
    true
    gap> t := LiftingMorphismFromProjective(p,p*hom[1]);
    <<[ 3, 12, 9 ]> ---> <[ 3, 12, 9 ]>>

    gap> s := MorphismOnKernel(p,p,t,hom[1]);
    <<[ 0, 10, 7 ]> ---> <[ 0, 10, 7 ]>>

    gap> Source(s) = N1;
    true
    gap> q := KernelInclusion(p);
    <<[ 0, 10, 7 ]> ---> <[ 3, 12, 9 ]>>

    gap> pushout := PushOut(q,s);
    [ <<[ 0, 10, 7 ]> ---> <[ 3, 12, 9 ]>>
        , <<[ 3, 12, 9 ]> ---> <[ 3, 12, 9 ]>>
         ]
    gap> U := CoKernel(pushout[1]);
    <[ 3, 2, 2 ]>
    gap> IsomorphicModules(U,N);
    true

##### 8.1-31 NthSyzygy

`‣ NthSyzygy`( M, n ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`), n -- a positive integer.

Returns: the n-th syzygy of M if it has projective dimension at least n, and if the projective dimension is less than n, then it returns the last non-zero projective syzygy.

This functions computes the n-th syzygy of the module M by successively computing first, second, third, ... syzygy of M the operation `1stSyzygy` (8.1-1) and at each stage checking if the is a projective module.

##### 8.1-32 NthSyzygyNC

`‣ NthSyzygyNC`( M, n ) | ( operation )

Arguments: M -- a path algebra module (`PathAlgebraMatModule`), n -- a positive integer.

Returns: the n-th syzygy of the module M, unless the projective dimension of M is less or equal to `n-1`, in which case it returns the zero module. It does not check if the `n`-th syzygy is projective or not.

##### 8.1-33 NumberOfComplementsOfAlmostCompleteTiltingModule

`‣ NumberOfComplementsOfAlmostCompleteTiltingModule`( M ) | ( operation )

`‣ NumberOfComplementsOfAlmostCompleteCotiltingModule`( M ) | ( operation )

Arguments: M -- a PathAlgebraMatModule.

Returns: the number complements of an almost complete tilting/cotilting module M, assuming that M is an almost complete tilting module.

##### 8.1-34 ProjDimension

`‣ ProjDimension`( M ) | ( attribute )

Arguments: M - a PathAlgebraMatModule.

Returns: the projective dimension of the module M, if it has been computed.

##### 8.1-35 ProjDimensionOfModule

`‣ ProjDimensionOfModule`( M ) | ( operation )

Arguments: M, n - a PathAlgebraMatModule, a positive integer.

Returns: Returns the projective dimension of the module M if it is less or equal to n. Otherwise it returns false.

##### 8.1-36 ProjectiveCover

`‣ ProjectiveCover`( M ) | ( attribute )

Arguments: M - a module.

Returns: the projective cover of M, that is, returns the map P(M)\to M.

If the module M is zero, then the zero map to M is returned.

##### 8.1-37 ProjectiveResolutionOfPathAlgebraModule

`‣ ProjectiveResolutionOfPathAlgebraModule`( M, n ) | ( operation )

Arguments: M - a path algebra module (`PathAlgebraMatModule`), n - a positive integer.

Returns: in terms of attributes `RProjectives`, `ProjectivesFList` and `Maps` a projective resolution of M out to stage n, where `RProjectives` are the projectives in the resolution lifted up to projectives over the path algebra, `ProjectivesFList` are the generators of the projective modules given in `RProjectives` in terms of elements in the first projective in the resolution and `Maps` contains the information about the maps in the resolution.

The algorithm for computing this projective resolution is based on the paper [GSZ01]. In addition, the algebra over which the modules are defined is available via the attribute `ParentAlgebra`.

##### 8.1-38 PullBack

`‣ PullBack`( f, g ) | ( operation )

Arguments: f, g - two homomorphisms with a common range.

Returns: the pullback of the maps f and g.

It is checked if f and g have the same range. Given the input f\colon A\to B (horizontal map) and g\colon C\to B (vertical map), the pullback E is returned as the two homomorphisms [f',g'], where f'\colon E\to C (horizontal map) and g'\colon E\to A (vertical map).

##### 8.1-39 PushOut

`‣ PushOut`( f, g ) | ( operation )

Arguments: f, g - two homomorphisms between modules with a common source.

Returns: the pushout of the maps f and g.

It is checked if f and g have the same source. Given the input f\colon A\to B (horizontal map) and g\colon A\to C (vertical map), the pushout E is returned as the two homomorphisms [f',g'], where f'\colon C\to E (horizontal map) and g'\colon B\to E (vertical map).

    gap> S := SimpleModules(A);
    [ <[ 1, 0, 0 ]>, <[ 0, 1, 0 ]>, <[ 0, 0, 1 ]> ]
    gap> Ext := ExtOverAlgebra(S[2],S[2]);
    [ <<[ 0, 1, 2 ]> ---> <[ 0, 2, 2 ]>>
        , [ <<[ 0, 1, 2 ]> ---> <[ 0, 1, 0 ]>>
             ], function( map ) ... end ]
    gap> Length(Ext[2]);
    1
    gap> # i.e. Ext^1(S[2],S[2]) is 1-dimensional
    gap> pushout := PushOut(Ext[2][1],Ext[1]);
    [ <<[ 0, 2, 2 ]> ---> <[ 0, 2, 0 ]>>
        , <<[ 0, 1, 0 ]> ---> <[ 0, 2, 0 ]>>
         ]
    gap> f := CoKernelProjection(pushout[1]);
    <<[ 0, 2, 0 ]> ---> <[ 0, 0, 0 ]>>

    gap> U := Range(pushout[1]);
    <[ 0, 2, 0 ]>

##### 8.1-40 RightApproximationByPerpT

`‣ RightApproximationByPerpT`( T, M ) | ( operation )

Arguments: T, M -- two path algebra modules (`PathAlgebraMatModule`).

Returns: the minimal right ^perp T-approximation of M.

The function checks if the first argument is a cotilting module, that is, checks if the attribute of `IsCotiltingModule` is set. This attribute can be set by giving the command `CotiltingModule( T, n )` for some positive integer `n` which is at least the injective dimension of the module T.

##### 8.1-41 RightFacMApproximation

`‣ RightFacMApproximation`( M, C ) | ( operation )

`‣ MinimalRightFacMApproximation`( M, C ) | ( operation )

Arguments: M, C -- two path algebra modules (`PathAlgebraMatModule`).

Returns: a minimal right \operatorname{Fac} M-approximation of the module C.

##### 8.1-42 RightMutationOfTiltingModuleComplement

`‣ RightMutationOfTiltingModuleComplement`( M, N ) | ( operation )

`‣ RightMutationOfCotiltingModuleComplement`( M, N ) | ( operation )

Arguments: M, N -- two path algebra modules (`PathAlgebraMatModule`).

Returns: a right mutation of the complement N of the almost complete tilting/cotilting module M, if such a complement exists. Otherwise it returns false.

##### 8.1-43 RightSubMApproximation

`‣ RightSubMApproximation`( M, C ) | ( operation )

`‣ MinimalRightSubMApproximation`( M, C ) | ( operation )

Arguments: M, C -- two path algebra modules (`PathAlgebraMatModule`).

Returns: a right \operatorname{Sub} M-approximation of the module C, where the first version returns a not necessarily minimal right \operatorname{Sub} M-approximation and the second returns a minimal approximation.

##### 8.1-44 N_RigidModule

`‣ N_RigidModule`( M, n ) | ( operation )

Arguments: M, n - a PathAlgebraMatModule, an integer.

Returns: true if M is a n-rigid module. Otherwise it returns false.

##### 8.1-45 TiltingModule

`‣ TiltingModule`( M, n ) | ( operation )

Arguments: M, n - a PathAlgebraMatModule and a positive integer.

Returns: false if M is not a tilting module of projective dimension at most n. Otherwise, it returns the projective dimension of M and the coresolution of all indecomposable projective modules in add M.

[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