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

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 LeftApproximationByAddM
8.1-29 RightApproximationByAddM
8.1-30 RadicalRightApproximationByAddM
8.1-31 MorphismOnKernel
8.1-32 NthSyzygy
8.1-33 NumberOfComplementsOfAlmostCompleteTiltingModule
8.1-34 ProjDimension
8.1-35 ProjDimensionOfModule
8.1-36 ProjectiveCover
8.1-37 ProjectiveResolutionOfPathAlgebraModule
8.1-38 ProjectiveResolutionOfSimpleModuleOverEndo
8.1-39 PullBack
8.1-40 PushOut
8.1-41 RightApproximationByPerpT
8.1-42 RightFacMApproximation
8.1-43 RightMutationOfTiltingModuleComplement
8.1-44 RightSubMApproximation
8.1-45 N_RigidModule
8.1-46 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, \(\Omega(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 injective 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 \(\widehat{\add 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 LeftApproximationByAddM

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

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

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

Arguments: C, M - two modules.

Returns: the minimal left \(\add M\)-approximation in the two last versions of the module C. In the first it returns some left approximation. Note: The order of the arguments is opposite of the order for minimal right approximations.

##### 8.1-29 RightApproximationByAddM

`‣ RightApproximationByAddM`( M, C/modulelist, C ) | ( operation )

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

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

Arguments: M, C - two modules.

Returns: the minimal right \(\add M\)-approximation in the two last versions of the module C. In the two first it returns some right approximation, where in the first version the input is two modules, while in the second version the input is a list of modules and a module. Note: The order of the arguments is opposite of the order for minimal left approximations.

##### 8.1-30 RadicalRightApproximationByAddM

`‣ RadicalRightApproximationByAddM`( modulelist, t ) | ( operation )

Arguments: modulelist, t - a list of modules and an index of this list.

Returns: a radical right approximation of `moduleslist[ t ]` by the additive closure of the modules in the list of modules modulelist, that is, returns a homomorphism \(f\colon M_{M_t} \to M_t\), where \(M_t\) is the t-th module in the modulelist.

##### 8.1-31 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\colon A\to B\), \(\beta\colon B\to B'\), \(\alpha\colon A\to A'\) and \(g\colon A'\to 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-32 NthSyzygy

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

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

Returns: the n-th syzygy of M.

This functions computes a projective resolution of M and finds the n-th syzygy of the module M.

##### 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, n ) | ( 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 ProjectiveResolutionOfSimpleModuleOverEndo

`‣ ProjectiveResolutionOfSimpleModuleOverEndo`( modulelist, t, length ) | ( operation )

Arguments: modulelist - a list of module, t - an index of the list of modules, length - length of the resolution.

Returns: information about the projective dimension and non-projective summands of the syzygies of the simple module corresponding to the t-th indecomposable projective module over the endomorphism ring of the direct sum of all the modules in modulelist (all assumed to be indecomposable). The non-projective summands in the syzygies from the second syzygy up to the length-syzygy are always returned. If the projective dimension is less or equal to length, the projective dimension is returned. Otherwise, it returns that the projective dimension is bigger that length. The output has the format `[ info on projective dimension, syzygies ]`.

##### 8.1-39 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-40 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-41 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-42 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-43 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-44 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-45 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-46 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