Haftungsausschluß.gi KontaktUnknown {[0] [0] [0]}diese Dinge liegen außhalb unserer Verantwortung
#######################################################################
##
#O PushOut(<f>, <g>)
##
## This function finds the pushout of the homomorphisms
## f
## A ---------> B
## | |
## | g | g'
## | |
## V f' V
## C ---------> E
## in that it returns the homomorphisms [f', g'].
##
InstallMethod( PushOut,
"for two homomorphisms starting in a common module over a path algebra",
[ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 0,
function( f, g )
local B, C, CplusB, inclusions, projections, h;
if Source(f) = Source(g) then
B := Range(f);
C := Range(g);
CplusB := DirectSumOfQPAModules([C,B]);
inclusions := DirectSumInclusions(CplusB);
h := f*inclusions[2]-g*inclusions[1];
h := CoKernelProjection(h);
return [inclusions[1]*h,inclusions[2]*h];
else
Print("Error: The two maps entered don't start in the same module.\n");
return fail;
fi;
end
);
#######################################################################
##
#O PullBack(<f>, <g>)
##
## This function finds the pullback of the homomorphisms
## f'
## E ---------> C
## | |
## | g' | g
## | |
## V f V
## A ---------> B
## in that it returns the homomorphisms [f', g'].
##
InstallMethod( PullBack,
"for two homomorphisms ending in a common module over a path algebra",
[ IsPathAlgebraMatModuleHomomorphism, IsPathAlgebraMatModuleHomomorphism ], 0,
function( f, g )
local A, C, AplusC, projections, h;
if Range(f) = Range(g) then
A := Source(f);
C := Source(g);
AplusC := DirectSumOfQPAModules([A,C]);
projections := DirectSumProjections(AplusC);
h := projections[1]*f-projections[2]*g;
h := KernelInclusion(h);
return [h*projections[2],h*projections[1]];
else
Print("Error: The two maps entered don't end in the same module.\n");
return fail;
fi;
end
);
#######################################################################
##
#O IsOmegaPeriodic( <M>, <n> )
##
## This function tests if the module <M> is \Omega-periodic, that is,
## if M \simeq \Omega^i(M) when i ranges over the set {1,2,...,n}.
## Otherwise it returns false.
##
InstallMethod( IsOmegaPeriodic,
"for a path algebra matmodule and an integer",
[ IsPathAlgebraMatModule, IS_INT ], 0,
function( M, n )
local N0, N1, i;
N0 := M;
for i in [1..n] do
Print("Computing syzygy number: ",i,"\n");
N1 := 1stSyzygy(N0);
if IsomorphicModules(M,N1) then
return i;
else
N0 := N1;
fi;
od;
return false;
end
);
#######################################################################
##
#O IsTauPeriodic( <M>, <n> )
##
## This function tests if the module <M> is \tau-periodic, that is,
## if M \simeq \tau^i(M) when i ranges over the set {1,2,...,n}.
## Otherwise it returns false.
##
InstallMethod( IsTauPeriodic,
"for a path algebra matmodule and an integer",
[ IsPathAlgebraMatModule, IS_INT ], 0,
function( M, n )
local N0, N1, i;
N0 := M;
for i in [1..n] do
N1 := DTr(N0);
if IsomorphicModules(M,N1) then
return i;
else
N0 := N1;
fi;
od;
return false;
end
);
#######################################################################
##
#O 1stSyzygy( <M> )
##
## This function computes the first syzygy of the module <M> by first
## finding a minimal set of generators for <M>, then finding the
## projective cover and computing the first syzygy as a submodule of
## this module.
##
InstallMethod( 1stSyzygy,
"for a path algebra",
[ IsPathAlgebraMatModule ], 0,
function( M );
if Dimension( M ) = 0 then
return ZeroModule( RightActingAlgebra( M ) );
else
return Kernel( ProjectiveCover( M ) );
fi;
end
);
#######################################################################
##
#O NthSyzygy( <M>, <n> )
##
## This function computes the <n>-th syzygy of the module <M>.
##
InstallMethod( NthSyzygy,
"for a path algebra module and a positive integer",
[ IsPathAlgebraMatModule, IsInt ], 0,
function( M, n )
local projres, diff;
if n < 0 then
Error( "Entered integer is negative.\n" );
fi;
if n = 0 then
return M;
fi;
projres := ProjectiveResolution( M );
diff := DifferentialOfComplex( projres, n - 1 );
return Kernel( diff );
end
);
#######################################################################
##
#O RightApproximationByAddM( <M>, <C> )
##
## This function computes a right add<M>-approximation of the module
## <C>, and the approximation is not necessarily minimal.
##
InstallMethod ( RightApproximationByAddM,
"for two PathAlgebraMatModules",
true,
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
0,
function( M, C )
local K, HomMC, EndM, radEndM, radHomMC, i, j, FlatHomMC,
FlatradHomMC, V, BB, W, f, VoverW, B, gens, approx, approxmap;
if RightActingAlgebra(M) <> RightActingAlgebra(C) then
Error(" the two modules entered into MinimalRightApproximation are not modules over the same algebra.");
return fail;
fi;
if Dimension(C) = 0 then
return ZeroMapping(ZeroModule(RightActingAlgebra(M)),C);
fi;
K := LeftActingDomain(M);
HomMC := HomOverAlgebra(M,C);
if Length(HomMC) = 0 then
return ZeroMapping(ZeroModule(RightActingAlgebra(M)),C);
else
EndM := EndOverAlgebra(M);
radEndM := RadicalOfAlgebra(EndM);
radEndM := BasisVectors(Basis(radEndM));
radEndM := List(radEndM, x -> FromEndMToHomMM(M,x));
radHomMC := [];
for i in [1..Length(HomMC)] do
for j in [1..Length(radEndM)] do
Add(radHomMC,radEndM[j]*HomMC[i]);
od;
od;
FlatHomMC := List(HomMC, x -> Flat(x!.maps));
FlatradHomMC := List(radHomMC, x -> Flat(x!.maps));
V := VectorSpace(K,FlatHomMC,"basis");
BB := Basis(V,FlatHomMC);
W := Subspace(V,FlatradHomMC);
f := NaturalHomomorphismBySubspace( V, W );
VoverW := Range(f);
B := BasisVectors(Basis(VoverW));
gens := List(B, x -> PreImagesRepresentative(f,x));
gens := List(gens, x -> Coefficients(BB,x));
gens := List(gens, x -> LinearCombination(HomMC,x));
approx := List(gens, x -> Source(x));
approx := DirectSumOfQPAModules(approx);
approxmap := ShallowCopy(DirectSumProjections(approx));
approxmap := List([1..Length(approxmap)], x -> approxmap[x]*gens[x]);
approxmap := Sum(approxmap);
return approxmap;
fi;
end
);
#######################################################################
##
#O MinimalRightApproximation( <M>, <C> )
##
## This function computes the minimal right add<M>-approximation of the
## module <C>. TODO/CHECK: If one can modify the algorithm as indicated
## below with ####.
##
InstallMethod ( MinimalRightApproximation,
"for two PathAlgebraMatModules",
true,
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
0,
function( M, C )
local f;
f := RightApproximationByAddM( M, C );
return RightMinimalVersion( f )[ 1 ];
end
);
#######################################################################
##
#O LeftApproximationByAddM( <C>, <M> )
##
## This function computes a left add<M>-approximation of the module
## <C>.
##
InstallMethod ( LeftApproximationByAddM,
"for two PathAlgebraMatModules",
true,
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
0,
function( C, M )
local K, HomCM, EndM, radEndM, radHomCM, i, j, FlatHomCM,
FlatradHomCM, V, BB, W, f, VoverW, B, gens,
approx, approxmap;
if RightActingAlgebra(M) <> RightActingAlgebra(C) then
Error(" the two modules entered into LeftApproximationByAddM are not modules over the same algebra.");
return fail;
fi;
if Dimension(C) = 0 then
return ZeroMapping(C, ZeroModule(RightActingAlgebra(M)));
fi;
K := LeftActingDomain(M);
HomCM := HomOverAlgebra(C,M);
if Length(HomCM) = 0 then
return ZeroMapping(C,ZeroModule(RightActingAlgebra(M)));
else
EndM := EndOverAlgebra(M);
radEndM := RadicalOfAlgebra(EndM);
radEndM := BasisVectors(Basis(radEndM));
radEndM := List(radEndM, x -> FromEndMToHomMM(M,x));
radHomCM := [];
for i in [1..Length(HomCM)] do
for j in [1..Length(radEndM)] do
Add(radHomCM,HomCM[i]*radEndM[j]);
od;
od;
FlatHomCM := List(HomCM, x -> Flat(x!.maps));
FlatradHomCM := List(radHomCM, x -> Flat(x!.maps));
V := VectorSpace(K,FlatHomCM,"basis");
BB := Basis(V,FlatHomCM);
W := Subspace(V,FlatradHomCM);
f := NaturalHomomorphismBySubspace( V, W );
VoverW := Range(f);
B := BasisVectors(Basis(VoverW));
gens := List(B, x -> PreImagesRepresentative(f,x));
gens := List(gens, x -> Coefficients(BB,x));
gens := List(gens, x -> LinearCombination(HomCM,x));
approx := List(gens, x -> Range(x));
approx := DirectSumOfQPAModules(approx);
approxmap := ShallowCopy(DirectSumInclusions(approx));
for i in [1..Length(approxmap)] do
approxmap[i] := gens[i]*approxmap[i];
od;
approxmap := Sum(approxmap);
return approxmap;
fi;
end
);
#######################################################################
##
#O MinimalLeftApproximation( <C>, <M> )
##
## This function computes the minimal left add<M>-approximation of the
## module <C>.
##
InstallMethod ( MinimalLeftApproximation,
"for two PathAlgebraMatModules",
true,
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
0,
function( C, M )
local f;
f := LeftApproximationByAddM( C, M );
return LeftMinimalVersion( f )[ 1 ];
end
);
#######################################################################
##
#O ProjectiveCover(<M>)
##
## This function finds the projective cover P(M) of the module <M>
## in that it returns the map from P(M) ---> M.
##
InstallMethod ( ProjectiveCover,
"for a PathAlgebraMatModule",
true,
[ IsPathAlgebraMatModule ],
0,
function( M )
local mingen, maps, PN, projections;
if Dimension(M) = 0 then
return ZeroMapping(ZeroModule(RightActingAlgebra(M)), M);
else
mingen := MinimalGeneratingSetOfModule(M);
maps := List(mingen, x -> HomFromProjective(x,M));
PN := List(maps, x -> Source(x));
PN := DirectSumOfQPAModules(PN);
projections := DirectSumProjections(PN);
return projections*maps;;
fi;
end
);
#######################################################################
##
#A InjectiveEnvelope(< M >)
##
## This function finds the injective envelope I(M) of the module <M>
## in that it returns the map from M ---> I(M).
##
InstallMethod ( InjectiveEnvelope,
"for a PathAlgebraMatModule",
true,
[ IsPathAlgebraMatModule ],
0,
function( M );
return DualOfModuleHomomorphism( ProjectiveCover( DualOfModule( M ) ) );
end
);
#######################################################################
##
#O ExtOverAlgebra(<M>,<N>)
##
## This function returns a list of three elements: (1) the kernel of
## the projective cover Omega(<M>) --> P(M), (2) a basis of
## Ext^1(<M>,<N>) inside Hom(Omega(<M>),<N>) and (3) 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>), if the group is non-zero.
## Otherwise it returns an empty list.
##
InstallMethod( ExtOverAlgebra,
"for two PathAlgebraMatModule's",
true,
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 0,
function( M, N )
local index, fromflatHomToHom, K, f, g, PM, syzygy, G, H, Img1, zero,
genssyzygyN, VsyzygyN, Img, gensImg, VImg, pi, ext, preimages,
homvecs, dimsyz, dimN, vec, t, l, i, H2, coefficients;
#
# Defining functions for later use.
#
index := function( n )
if n = 0 then
return 1;
else
return n;
fi;
end;
fromflatHomToHom := function( flat, dim, dim2 )
local totalmat, matrix, i, start, j, d, d2;
d := List(dim, index);
d2 := List(dim2, index);
start := 0;
totalmat := [];
for i in [1..Length(dim)] do
matrix := [];
for j in [1..d[i]] do
Add(matrix, flat{[start+1..start+d2[i]]});
start := start+d2[i];
od;
Add(totalmat,matrix);
od;
return totalmat;
end;
#
# Test of input.
#
if RightActingAlgebra(M) <> RightActingAlgebra(N) then
Error(" the two modules entered are not modules over the same algebra.\n");
else
K := LeftActingDomain(M);
#
# creating a short exact sequence 0 -> Syz(M) -> P(M) -> M -> 0
# f: P(M) -> M, g: Syz(M) -> P(M)
#
f := ProjectiveCover(M);
g := KernelInclusion(f);
PM := Source(f);
syzygy := Source(g);
#
# using Hom(-,N) on the s.e.s. above
#
G := HomOverAlgebra(PM,N);
H := HomOverAlgebra(syzygy,N);
#
# Making a vector space of Hom(Syz(M),N)
# by first rewriting the maps as vectors
#
genssyzygyN := List(H, x -> Flat(x!.maps));
if Length(genssyzygyN) = 0 then
return [ g, [ ], [ ] ];
else
VsyzygyN := VectorSpace(K, genssyzygyN);
#
# finding a basis for im(g*)
# first, find a generating set of im(g*)
#
Img1 := g*G;
#
# removing 0 maps by comparing to zero = Zeromap(syzygy,N)
#
zero := ZeroMapping(syzygy,N);
Img := Filtered(Img1, x -> x <> zero);
#
# Rewriting the maps as vectors
#
gensImg := List(Img, x -> Flat(x!.maps));
#
# Making a vector space of <Im g*>
VImg := Subspace(VsyzygyN, gensImg);
#
# Making the vector space Ext1(M,N)
#
pi := NaturalHomomorphismBySubspace(VsyzygyN, VImg);
ext := Range(pi);
if Dimension(Range(pi)) = 0 then
return [ g, [ ], [ ] ];
else
#
# Sending elements of ext back to Hom(Syz(M),N)
#
preimages := List(BasisVectors(Basis(ext)), x -> PreImagesRepresentative(pi,x));
#
# need to put the parentheses back in place
#
homvecs := []; # to store all lists of matrices, one list for each element (homomorphism)
dimsyz := DimensionVector(syzygy);
dimN := DimensionVector(N);
homvecs := List(preimages, x -> fromflatHomToHom(x,dimsyz,dimN));
#
# Making homomorphisms of the elements
#
H2 := List(homvecs, x -> RightModuleHomOverAlgebra(syzygy,N,x));
coefficients := function( map )
local vector, B;
vector := ImageElm(pi,Flat(map!.maps));
B := Basis(Range(pi));
return Coefficients(B,vector);
end;
return [g,H2,coefficients];
fi;
fi;
fi;
end
);
#######################################################################
##
#O ExtAlgebraGenerators(<M>,<n>)
##
## This function computes a set of generators of the Ext-algebra Ext^*(M,M)
## up to degree <n>. It 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 a set generators in the degrees [0..n], and the
## third element is the generators in these degrees. TODO: Create a
## minimal set of generators. Needs to take the radical of the degree
## zero part into account.
##
InstallMethod( ExtAlgebraGenerators,
"for a module over a quotient of a path algebra",
[ IsPathAlgebraMatModule, IS_INT ], 0,
function( M, n )
local N, projcovers, f, i, EndM, J, gens, extgroups, dim_ext_groups,
generators, productelements, j, induced, k, liftings, products,
l, m, productsinbasis, W, V, K, extalggenerators, p, tempgens,
I, g, templist, idealsquare;
K := LeftActingDomain(M);
N := M;
projcovers := [];
for i in [1..n] do
f := ProjectiveCover(N);
Add(projcovers,f);
N := Kernel(f);
od;
extgroups := [];
#
# Computing Ext^i(M,M) for i = 0, 1, 2,...., n.
#
for i in [0..n] do
if i = 0 then
EndM := EndOverAlgebra(M);
J := RadicalOfAlgebra(EndM);
gens := GeneratorsOfAlgebra(J);
Add(extgroups, [[],List(gens, x -> FromEndMToHomMM(M,x))]);
elif i = 1 then
Add(extgroups, ExtOverAlgebra(M,M));
else
Add(extgroups, ExtOverAlgebra(Kernel(projcovers[i-1]),M));
fi;
od;
dim_ext_groups := List(extgroups, x -> Length(x[2]));
# Print(Dimension(EndM) - Dimension(J)," generators in degree 0.\n");
#
# Computing Ext^j(M,M) x Ext^(i-j)(M,M) for j = 1..i-1 and i = 2..n.
#
generators := List([1..n + 1], x -> 0);
extalggenerators := List([1..n + 1], x -> []);
for i in [1..n] do
productelements := [];
for j in [0..i] do
if ( dim_ext_groups[i+1] <> 0 ) and ( dim_ext_groups[j+1] <> 0 ) and ( dim_ext_groups[i-j+1] <> 0 ) then
induced := ShallowCopy(extgroups[i-j+1][2]);
for k in [1..j] do
liftings := List([1..dim_ext_groups[i-j+1]], x -> projcovers[i-j+k]*induced[x]);
liftings := List([1..dim_ext_groups[i-j+1]], x -> LiftingMorphismFromProjective(projcovers[k],liftings[x]));
induced := List([1..dim_ext_groups[i-j+1]], x -> MorphismOnKernel(projcovers[i-j+k],projcovers[k],liftings[x],induced[x]));
od;
products := [];
for l in [1..dim_ext_groups[j+1]] do
for m in [1..dim_ext_groups[i-j+1]] do
Add(products,induced[m]*extgroups[j+1][2][l]);
od;
od;
productsinbasis := List(products, x -> extgroups[i+1][3](x));
productsinbasis := Filtered(productsinbasis, x -> x <> Zero(x));
if Length(productsinbasis) <> 0 then
Append(productelements,productsinbasis);
fi;
fi;
od;
if Length(productelements) <> 0 then
W := FullRowSpace(K,Length(extgroups[i+1][2]));
V := Subspace(W,productelements);
if dim_ext_groups[i+1] > Dimension(V) then
generators[i+1] := Length(extgroups[i+1][2]) - Dimension(V);
p := NaturalHomomorphismBySubspace(W,V);
tempgens := List(BasisVectors(Basis(Range(p))), x -> PreImagesRepresentative(p,x));
extalggenerators[i+1] := List(tempgens, x -> LinearCombination(extgroups[i+1][2],x));
# Print(Length(extgroups[i+1][2]) - Dimension(V)," new generator(s) in degree ",i,".\n");
fi;
elif dim_ext_groups[i+1] <> 0 then
generators[i+1] := Length(extgroups[i+1][2]);
extalggenerators[i+1] := extgroups[i+1][2];
# Print(Length(extgroups[i+1][2])," new generator(s) in degree ",i,".\n");
fi;
od;
dim_ext_groups[1] := Dimension(EndM);
templist := [];
for i in [1..Length(gens)] do
for j in [1..Dimension(EndM)] do
Add(templist,BasisVectors(Basis(EndM))[j]*gens[i]);
od;
od;
templist := Filtered(templist, x -> x <> Zero(x));
idealsquare := [];
for i in [1..Length(templist)] do
for j in [1..Length(gens)] do
Add(idealsquare,gens[j]*templist[i]);
od;
od;
I := Ideal(EndM,idealsquare);
g := NaturalHomomorphismByIdeal(EndM,I);
extalggenerators[1] := List(BasisVectors(Basis(Range(g))), x -> FromEndMToHomMM(M,PreImagesRepresentative(g,x)));
generators[1] := Length(extalggenerators[1]);
return [dim_ext_groups,generators,extalggenerators];
end
);
#######################################################################
##
#O PartialIyamaGenerator( <M> )
##
## Given a module <M> this function returns the submodule of <M>
## given by the radical of the endomorphism ring of <M> times <M>.
## If <M> is zero, then <M> is returned.
##
InstallMethod( PartialIyamaGenerator,
"for a path algebra",
[ IsPathAlgebraMatModule ], 0,
function( M )
local B, EndM, radEndM, Brad, subgens, b, r;
if Dimension(M) = 0 then
return M;
fi;
B := CanonicalBasis(M);
EndM := EndOverAlgebra(M);
radEndM := RadicalOfAlgebra(EndM);
Brad := BasisVectors(Basis(radEndM));
Brad := List(Brad, x -> FromEndMToHomMM(M,x));
subgens := [];
for b in B do
for r in Brad do
Add(subgens, ImageElm(r,b));
od;
od;
return SubRepresentation(M,subgens);
end
);
#######################################################################
##
#O IyamaGenerator( <M> )
##
## Given a module <M> this function 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.
##
InstallMethod( IyamaGenerator,
"for a path algebra",
[ IsPathAlgebraMatModule ], 0,
function( M )
local iyamagen, N, IG, L;
iyamagen := [];
N := M;
repeat
Add(iyamagen,N);
N := PartialIyamaGenerator(N);
until
Dimension(N) = 0;
IG := DirectSumOfQPAModules(iyamagen);
if IsFinite(LeftActingDomain(M)) then
L := DecomposeModuleWithMultiplicities(IG);
IG := DirectSumOfQPAModules(L[1]);
fi;
return IG;
end
);
#######################################################################
##
#O GlobalDimensionOfAlgebra( <A>, <n> )
##
## Returns the global dimension of the algebra <A> if it is less or
## equal to <n>, otherwise it returns false.
##
InstallMethod ( GlobalDimensionOfAlgebra,
"for a finite dimensional quotient of a path algebra",
true,
[ IsQuiverAlgebra, IS_INT ],
0,
function( A, n )
local simples, S, projres, dimension, j;
if not IsFiniteDimensional(A) then
TryNextMethod();
fi;
if HasGlobalDimension(A) then
return GlobalDimension(A);
fi;
if Trace(AdjacencyMatrixOfQuiver(QuiverOfPathAlgebra(A))) > 0 then
SetGlobalDimension(A,infinity);
return infinity;
fi;
simples := SimpleModules(A);
dimension := 0;
for S in simples do
projres := ProjectiveResolution(S);
j := 0;
while ( j < n + 1 ) and ( Dimension(ObjectOfComplex(projres,j)) <> 0 ) do
j := j + 1;
od;
if ( j < n + 1 ) then
dimension := Maximum(dimension, j - 1 );
else
if ( Dimension(ObjectOfComplex(projres,n + 1)) <> 0 ) then
return false;
else
dimension := Maximum(dimension, n );
fi;
fi;
od;
SetGlobalDimension(A,dimension);
return dimension;
end
);
#######################################################################
##
#O DominantDimensionOfModule( <M>, <n> )
##
## Returns the dominant dimension of the module <M> if it is less or
## equal to <n>. If the module <M> is injective and projective, then
## it returns infinity. Otherwise it returns false.
##
InstallMethod ( DominantDimensionOfModule,
"for a finite dimensional quotient of a path algebra",
true,
[ IsPathAlgebraMatModule, IS_INT ],
0,
function( M, n )
local A, Mop, resop, dimension, j;
A := RightActingAlgebra(M);
#
# If the algebra A is not a finite dimensional, try another method.
#
if not IsFiniteDimensional(A) then
TryNextMethod();
fi;
#
# If the module <M> is injective and projective, then the dominant dimension of
# <M> is infinite.
if IsInjectiveModule( M ) and IsProjectiveModule( M ) then
return infinity;
fi;
Mop := DualOfModule( M );
#
# Check how far out the modules in the minimal projective resolution of Mop
# is injective.
#
resop := ProjectiveResolution( Mop );
dimension := 0;
j := 0;
while ( j < n ) and ( IsInjectiveModule( ObjectOfComplex( resop, j ) ) ) do
j := j + 1;
od;
if ( j < n ) then # if this happens, then j-th projective is not injective and domdim equal to j for <M>.
dimension := Maximum( dimension, j );
else # if this happens, then j = n.
if not IsInjectiveModule( ObjectOfComplex( resop, n ) ) then # then domdim is n of <M>.
dimension := Maximum( dimension, n );
else # then domdim is > n for <M>.
return false;
fi;
fi;
# SetDominantDimension(M,dimension);
return dimension;
end
);
#######################################################################
##
#O DominantDimensionOfAlgebra( <A>, <n> )
##
## Returns the dominant dimension of the algebra <A> if it is less or
## equal to <n>. If the algebra <A> is selfinjectiv, then it returns
## infinity. Otherwise it returns false.
##
InstallMethod ( DominantDimensionOfAlgebra,
"for a finite dimensional quotient of a path algebra",
true,
[ IsQuiverAlgebra, IS_INT ],
0,
function( A, n )
local P, domdimlist, pos_infinite, pos_false, pos_finite;
#
# If the algebra <A> is not a finite dimensional, try another method.
#
if not IsFiniteDimensional( A ) then
TryNextMethod( );
fi;
#
# If the algebra <A> is selfinjective, then the dominant dimension of
# <A> is infinite.
if IsSelfinjectiveAlgebra( A ) then
return infinity;
fi;
P := IndecProjectiveModules( A );
domdimlist := List( P, p -> DominantDimensionOfModule( p, n ) ); # Checking the dominant dimension of each indec. projective module.
pos_infinite := Positions( domdimlist, infinity ); # positions of the indec. projective modules with infinite domdim.
pos_false := Positions( domdimlist, false ); # positions of the indec. projective modules with bigger dom.dim. than n.
pos_finite := [ 1..Length( P ) ];
SubtractSet( pos_finite, Union( pos_infinite, pos_false ) ); # positions of the indec. projective modules with domdim less or equal to n.
if Length( pos_finite ) = 0 then
return false;
else
return Minimum( domdimlist{ pos_finite } );
fi;
end
);
#######################################################################
##
#O ProjDimensionOfModule( <M>, <n> )
##
## Returns the projective dimension of the module <M> if it is less
## or equal to <n>, otherwise it returns false.
##
InstallMethod ( ProjDimensionOfModule,
"for a PathAlgebraMatModule",
true,
[ IsPathAlgebraMatModule, IS_INT ],
0,
function( M, n )
local projres, i;
if HasProjDimension(M) then
if ProjDimension(M) > n then
return false;
else
return ProjDimension(M);
fi;
fi;
projres := ProjectiveResolution(M);
i := 1;
while i < n + 2 do
if Dimension(ObjectOfComplex(projres,i)) = 0 then # the projective dimension is i - 1.
SetProjDimension(M, i - 1);
return i-1;
fi;
i := i + 1;
od;
return false;
end
);
#######################################################################
##
#O GorensteinDimensionOfAlgebra( <A>, <n> )
##
## Returns the Gorenstein dimension of the algebra <A> if it is less
## or equal to <n>, otherwise it returns false.
##
InstallMethod ( GorensteinDimensionOfAlgebra,
"for a quiver algebra",
true,
[ IsQuiverAlgebra, IS_INT ],
0,
function( A, n )
local Ilist, dimension_right, I, projdim, Ilistop, dimension_left;
#
# If <A> has finite global dimension, then the Gorenstein
# dimension of <A> is equal to the global dimension of <A>.
#
if HasGlobalDimension(A) then
if GlobalDimension(A) <> infinity then
SetGorensteinDimension(A, GlobalDimension(A));
return GlobalDimension(A);
fi;
fi;
if HasGorensteinDimension(A) then
return GorensteinDimension(A);
fi;
#
# First checking the injective dimension of the indecomposable
# projective left <A>-modules.
#
Ilist := IndecInjectiveModules(A);
dimension_right := 0;
for I in Ilist do
projdim := ProjDimensionOfModule(I,n);
if projdim = false then # projective dimension of I is bigger than n.
return false;
else # projective dimension of I is less or equal to n.
dimension_right := Maximum(dimension_right, projdim );
fi;
od;
#
# Secondly checking the injective dimension of the indecomposable
# projective right <A>-modules.
#
Ilistop := IndecInjectiveModules(OppositeAlgebra(A));
dimension_left := 0;
for I in Ilistop do
projdim := ProjDimensionOfModule(I,n);
if projdim = false then # projective dimension of I is bigger than n.
return false;
else # projective dimension of I is less or equal to n.
dimension_left := Maximum(dimension_left, projdim );
fi;
od;
if dimension_left <> dimension_right then
Print("You have a counterexample to the Gorenstein conjecture!\n\n");
fi;
SetGorensteinDimension(A, Maximum(dimension_left, dimension_right));
return Maximum(dimension_left, dimension_right);
end
);
#######################################################################
##
#O N_RigidModule( <M>, <n> )
##
## Returns true if the module <M> is n-rigid, otherwise false.
##
InstallMethod ( N_RigidModule,
"for a PathAlgebraMatModule",
true,
[ IsPathAlgebraMatModule, IS_INT ],
0,
function( M, n )
local i, N;
i := 1;
N := M;
while i < n + 1 do
if Length(ExtOverAlgebra(N,M)[2]) > 0 then # Ext^i(M,M) <> 0.
return false;
else # Ext^i(M,M) = 0.
i := i + 1;
N := NthSyzygy(N,1);
fi;
od;
return true;
end
);
#######################################################################
##
#O LeftFacMApproximation( <C>, <M> )
##
## This function computes a left, not necessarily left minimal,
## Fac<M>-approximation of the module <C> by doing the following:
## p
## P(C) -------> C (projective cover)
## | |
## f | | g - the returned homomorphism
## V V
## M^{P(C)} ----> E
##
InstallMethod( LeftFacMApproximation,
"for a representations of a quiver",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 0,
function( C, M )
local p, f;
#
# Checking if the modules <C> and <M> are modules over the same algebra.
#
if RightActingAlgebra(C) <> RightActingAlgebra(M) then
Error("the entered modules are not modules over the same algebra,\n");
fi;
p := ProjectiveCover(C);
f := MinimalLeftAddMApproximation(Source(p),M);
return PushOut(p,f)[2];
end
);
#######################################################################
##
#O MinimalLeftFacMApproximation( <C>, <M> )
##
## This function computes a minimal left Fac<M>-approximation of the
## module <C>.
##
InstallMethod( MinimalLeftFacMApproximation,
"for a representations of a quiver",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 0,
function( C, M );
return LeftMinimalVersion(LeftFacMApproximation(C,M))[1];
end
);
#######################################################################
##
#O RightSubMApproximation( <M>, <C> )
##
## This function computes a right, not necessarily a right minimal,
## Sub<M>-approximation of the module <C> by doing the following:
##
## E -----> M^{I(C)} (minimal right Add<M>-approximation)
## | |
## g | | f g - the returned homomorphism
## V i V
## C -------> I(C) (injective envelope)
##
InstallMethod( RightSubMApproximation,
"for a representations of a quiver",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 0,
function( M, C )
local iop, i, f;
#
# Checking if the modules <M> and <C> are modules over the same algebra.
#
if RightActingAlgebra(M) <> RightActingAlgebra(C) then
Error("the entered modules are not modules over the same algebra,\n");
fi;
iop := ProjectiveCover(DualOfModule(C));
i := DualOfModuleHomomorphism(iop);
f := MinimalRightAddMApproximation(M, Range(i));
return PullBack(i,f)[2];
end
);
#######################################################################
##
#O MinimalRightSubMApproximation( <M>, <C> )
##
## This function computes a minimal right Sub<M>-approximation of the module
## <C>.
##
InstallMethod( MinimalRightSubMApproximation,
"for a representations of a quiver",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 0,
function( M, C );
return RightMinimalVersion(RightSubMApproximation(M,C))[1];
end
);
#######################################################################
##
#O LeftSubMApproximation( <C>, <M> )
##
## This function computes a minimal left Sub<M>-approximation of the
## module <C> by doing the following:
## f
## C -------> M^{C} = the minimal left Add<M>-approxiamtion
##
## Returns the natural projection C --------> Im(f).
##
InstallMethod( LeftSubMApproximation,
"for a representations of a quiver",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ], 0,
function( C, M )
local f;
#
# Checking if the modules <C> and <M> are modules over the same algebra.
#
if RightActingAlgebra(C) <> RightActingAlgebra(M) then
Error("the entered modules are not modules over the same algebra,\n");
fi;
f := MinimalLeftAddMApproximation(C,M);
return ImageProjection(f);
end
);
#######################################################################
##
#O InjDimensionOfModule( <M>, <n> )
##
## Returns the injective dimension of the module <M> if it is less
## or equal to <n>, otherwise it returns false.
##
InstallMethod ( InjDimensionOfModule,
"for a PathAlgebraMatModule and a positive integer",
true,
[ IsPathAlgebraMatModule, IS_INT ],
0,
function( M, n )
local DM, projresop, i;
if HasInjDimension(M) then
if InjDimension(M) > n then
return false;
else
return InjDimension(M);
fi;
fi;
DM := DualOfModule(M);
if HasProjDimension(DM) then
return ProjDimension(DM);
fi;
projresop := ProjectiveResolution(DM);
i := 1;
while i < n + 2 do
if Dimension(ObjectOfComplex(projresop,i)) = 0 then # the projective dimension of DM is i - 1.
SetInjDimension(M, i - 1);
return i-1;
fi;
i := i + 1;
od;
return false;
end
);
#######################################################################
##
#O HaveFiniteCoresolutionInAddM( <N>, <M>, <n> )
##
## This function checks if the module <N> has a finite coresolution
## in add<M> of length at most <n>. If it does, then this
## coresoultion is returned, otherwise false is returned.
##
InstallMethod( HaveFiniteCoresolutionInAddM,
"for two PathAlgebraMatModules and a positive integer",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule, IS_INT ],
function( N, M, n )
local U, differentials, g, f, i, cat, coresolution;
#
# Checking if <N> and <M> are modules over the same algebra.
#
if RightActingAlgebra(M) <> RightActingAlgebra(N) then
Error("the entered modules are not modules over the same algebra,\n");
fi;
#
# If n = 0, then this is the same as N being in add M.
#
# Computing successive minimal left add<M>-approximation to produce
# a coresolution of <N> in add<M>.
#
cat := CatOfRightAlgebraModules(RightActingAlgebra(M));
U := N;
differentials := [];
g := IdentityMapping(U);
f := MinimalLeftAddMApproximation(U,M);
if n = 0 then
if IsIsomorphism( f ) then
return FiniteComplex(cat, 0, [ f ] );
else
return false;
fi;
fi;
for i in [0..n] do
if not IsInjective(f) then
return false;
fi;
Add(differentials, g*f);
g := CoKernelProjection(f);
if Dimension(Range(g)) = 0 then
break;
fi;
f := MinimalLeftAddMApproximation(Range(g),M);
od;
differentials := Reversed(differentials);
coresolution := FiniteComplex(cat, -Length(differentials) + 1, differentials);
return coresolution;
end
);
#######################################################################
##
#O TiltingModule( <M>, <n> )
##
## This function checks if the module <M> is a tilting module of
## projective dimension at most <n>.
##
InstallMethod( TiltingModule,
"for a PathAlgebraMatModule and a positive integer",
[ IsPathAlgebraMatModule, IS_INT ],
function( M, n )
local m, N, i, P, t, coresolution, temp;
#
# Checking if the module has projective dimension at most <n>.
#
if HasProjDimension(M) then
if ProjDimension(M) > n then
return false;
fi;
else
if not IS_INT(ProjDimensionOfModule(M,n)) then
return false;
fi;
fi;
#
# Now we know that the projective dimension of <M> is at most <n>.
# Next we check if the module <M> is selforthogonal.
#
m := ProjDimension(M);
N := M;
i := 0;
repeat
if Length(ExtOverAlgebra(N,M)[2]) <> 0 then
return false;
fi;
i := i + 1;
if i < m then
N := NthSyzygy(N,1);
fi;
until i = m + 1;
#
# Now we know that the projective dimension of <M> is at most <n>,
# and that the module <M> is selforthogonal. Next we check if all the
# indecomposable projectives can be coresolved in add<M>.
#
P := IndecProjectiveModules(RightActingAlgebra(M));
t := Length(P);
coresolution := [];
for i in [1..t] do
temp := HaveFiniteCoresolutionInAddM(P[i], M, m);
if temp = false then
return false;
fi;
Add(coresolution, temp);
od;
#
# Now we know that the module <M> is a tilting module of projective
# dimension m.
#
SetIsTiltingModule(M, true);
return [m, coresolution];
end
);
#######################################################################
##
#O HaveFiniteResolutionInAddM( <N>, <M>, <n> )
##
## This function checks if the module <N> has a finite resolution
## in add<M> of length at most <n>. If it does, then this
## resolution is returned, otherwise false is returned.
##
InstallMethod( HaveFiniteResolutionInAddM,
"for two PathAlgebraMatModules and a positive integer",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule, IS_INT ],
function( N, M, n )
local U, differentials, g, f, i, cat, resolution;
#
# Checking if <N> and <M> are modules over the same algebra.
#
if RightActingAlgebra(M) <> RightActingAlgebra(N) then
Error("the entered modules are not modules over the same algebra,\n");
fi;
#
# If n = 0, then this is the same as N being in add M.
#
# Computing successive minimal right add<M>-approximation to produce
# a resolution of <N> in add<M>.
#
U := N;
differentials := [];
g := IdentityMapping(U);
f := MinimalRightAddMApproximation(M,U);
if n = 0 then
if IsIsomorphism( f ) then
return true;
else
return false;
fi;
fi;
for i in [0..n] do
if not IsSurjective(f) then
return false;
fi;
Add(differentials, f*g);
g := KernelInclusion(f);
if Dimension(Source(g)) = 0 then
break;
fi;
f := MinimalRightAddMApproximation(M, Source(g));
od;
cat := CatOfRightAlgebraModules(RightActingAlgebra(M));
resolution := FiniteComplex(cat, 1, differentials);
return resolution;
end
);
#######################################################################
##
#O CotiltingModule( <M>, <n> )
##
## This function checks if the module <M> is a cotilting module of
## projective dimension at most <n>.
##
InstallMethod( CotiltingModule,
"for a PathAlgebraMatModule and a positive integer",
[ IsPathAlgebraMatModule, IS_INT ],
function( M, n )
local m, N, i, I, t, resolution, temp;
#
# Checking if the module has injective dimension at most <n>.
#
if HasInjDimension(M) then
if InjDimension(M) > n then
return false;
fi;
else
if not IS_INT(InjDimensionOfModule(M,n)) then
return false;
fi;
fi;
#
# Now we know that the injective dimension of <M> is at most <n>.
# Next we check if the module <M> is selforthogonal.
#
m := InjDimension(M);
N := M;
i := 0;
repeat
if Length(ExtOverAlgebra(N,M)[2]) <> 0 then
SetIsCotiltingModule(M, false);
return false;
fi;
i := i + 1;
if i < m then
N := NthSyzygy(N,1);
fi;
until i = m + 1;
#
# Now we know that the injective dimension of <M> is at most <n>,
# and that the module <M> is selforthogonal. Next we check if all the
# indecomposable injectives can be resolved in add<M>.
#
I := IndecInjectiveModules(RightActingAlgebra(M));
t := Length(I);
resolution := [];
for i in [1..t] do
temp := HaveFiniteResolutionInAddM(I[i], M, m);
if temp = false then
return false;
fi;
Add(resolution, temp);
od;
#
# Now we know that the module <M> is a cotilting module of injective
# dimension <M>.
#
SetIsCotiltingModule(M, true);
return [m, resolution];
end
);
#######################################################################
##
#O AllComplementsOfAlmostCompleteTiltingModule( <M>, <X> )
##
## This function constructs all complements of an almost complete
## tilting module <M> given a complement <X> of <M>. The
## complements are returned as a long exact sequence (whenever possible)
## of minimal left and minimal right add<M>-approximations.
##
InstallMethod( AllComplementsOfAlmostCompleteTiltingModule,
"for two PathAlgebraMatModules",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
function( M, X)
local U, leftdifferentials, g, f, cat, resolution,
rightdifferentials, coresolution;
#
# Checking if <M> and <X> are modules over the same algebra.
#
if RightActingAlgebra(M) <> RightActingAlgebra(X) then
Error("the entered modules are not modules over the same algebra,\n");
fi;
#
# Computing successive minimal right add<M>-approximation to produce
# a resolution of <X> in add<M>.
#
U := X;
leftdifferentials := [];
g := IdentityMapping(U);
f := MinimalRightAddMApproximation(M,U);
while IsSurjective(f) do
Add(leftdifferentials, f*g);
g := KernelInclusion(f);
if Dimension(Source(g)) = 0 then
break;
fi;
f := MinimalRightAddMApproximation(M, Source(g));
od;
cat := CatOfRightAlgebraModules(RightActingAlgebra(M));
if Length(leftdifferentials) = 0 then
resolution := [];
else
Add(leftdifferentials, KernelInclusion(leftdifferentials[Length(leftdifferentials)]));
resolution := FiniteComplex(cat, 1, leftdifferentials);
fi;
#
# Computing successive minimal left add<M>-approximation to produce
# a coresolution of <X> in add<M>.
#
U := X;
rightdifferentials := [];
g := IdentityMapping(U);
f := MinimalLeftAddMApproximation(U,M);
while IsInjective(f) do
Add(rightdifferentials, g*f);
g := CoKernelProjection(f);
f := MinimalLeftAddMApproximation(Range(g),M);
od;
if Length(rightdifferentials) = 0 then
coresolution := [];
else
Add(rightdifferentials, CoKernelProjection(rightdifferentials[Length(rightdifferentials)]));
rightdifferentials := Reversed(rightdifferentials);
coresolution := FiniteComplex(cat, -Length(rightdifferentials) + 1, rightdifferentials);
fi;
return [resolution,coresolution];
end
);
#######################################################################
##
#A FaithfulDimension( <M> )
##
## This function computes the faithful dimension of a module <M>.
##
InstallMethod( FaithfulDimension,
"for a PathAlgebraMatModules",
[ IsPathAlgebraMatModule ],
function( M )
local P, lengths, p, tempdim, U, g, f;
P := IndecProjectiveModules(RightActingAlgebra(M));
#
# For all indecomposable projective A-modules computing successive
# minimal left add<M>-approximation to produce find the faithful
# dimension <M> has with respect to that indecomposable
# projective.
#
lengths := [];
for p in P do
tempdim := 0;
U := p;
f := MinimalLeftAddMApproximation( U, M );
if not IsInjective( f ) then
return 0;
fi;
while IsInjective( f ) do
tempdim := tempdim + 1;
g := CoKernelProjection( f );
if Dimension( Range( g ) ) = 0 then
Add( lengths, infinity );
break;
else
f := MinimalLeftAddMApproximation( Range( g ), M );
fi;
od;
if Dimension( Range( g ) ) <> 0 then
Add( lengths, tempdim );
fi;
od;
return Minimum( lengths );
end
);
#######################################################################
##
#O NumberOfComplementsOfAlmostCompleteTiltingModule( <M> )
##
## This function computes the number complements of an almost
## complete tilting/cotilting module <M>, assuming that <M>
## is an almost complete tilting module.
##
InstallMethod( NumberOfComplementsOfAlmostCompleteTiltingModule,
"for a PathAlgebraMatModules",
[ IsPathAlgebraMatModule ],
function( M );
return FaithfulDimension(M) + 1;
end
);
#######################################################################
##
#O LeftMutationOfTiltingModuleComplement( <M>, <N> )
##
## This function computes the left mutation of a complement <N> of
## an almost complete tilting module <M>, assuming that <M> is an
## almost complete tilting module. If it doesn't exist, then the
## function returns false.
##
InstallMethod( LeftMutationOfTiltingModuleComplement,
"for a PathAlgebraMatModules",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
function( M, N )
local f;
f := MinimalLeftAddMApproximation(N, M);
if IsInjective(f) then
return CoKernel(f);
else
return false;
fi;
end
);
#######################################################################
##
#O RightMutationOfTiltingModuleComplement( <M>, <N> )
##
## This function computes the right mutation of a complement <N> of
## an almost complete tilting module <M>, assuming that <M> is an
## almost complete tilting module. If it doesn't exist, then the
## function returns false.
##
InstallMethod( RightMutationOfTiltingModuleComplement,
"for a PathAlgebraMatModules",
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
function( M, N )
local f;
f := MinimalRightAddMApproximation(M, N);
if IsSurjective(f) then
return Kernel(f);
else
return false;
fi;
end
);
##########################################################################
##
#P DeclareProperty( "IsHereditaryAlgebra", [ A ] )
##
## The function is defined for an admissible quotient <A> of a path
## algebra, and it returns true if <A> is a hereditary algebra and
## false otherwise.
##
InstallMethod( IsHereditaryAlgebra,
"for an algebra",
[ IsAdmissibleQuotientOfPathAlgebra ],
function( A )
local test;
if HasGlobalDimension(A) then
return GlobalDimension(A) < 2;
fi;
test := GlobalDimensionOfAlgebra(A, 1);
#
# test = false => gldim(A) > 1
# test = infinity => gldim(A) = infinity
# test = integer > 1 => gldim(A) > 1
# if all these are not true, then gldim(A) < 1, and A is hereditary.
#
if IsBool(test) or ( test = infinity ) or ( IS_INT(test) and test > 1 ) then
return false;
else
return true;
fi;
end
);
#######################################################################
##
#O RightApproximationByPerpT( <T>, <M> )
##
## Returns the minimal right $\widehat{\add T}$-approximation of the
## module <M>. It checks if <T> is a cotilting module, and if not
## it returns an error message.
##
InstallMethod ( RightApproximationByPerpT,
"for a cotilting PathAlgebraMatModule and a PathAlgebraMatModule",
true,
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
0,
function( T, M )
local n, projres, exactsequences, f, i, beta, g, h,
alpha, fprime;
if not IsCotiltingModule( T ) then
Error("the first argument is not a cotilting module,\n");
fi;
if IsZero( M ) then
return ZeroMapping( ZeroModule( RightActingAlgebra( M ) ), M );
fi;
n := InjDimension( T );
projres := ProjectiveResolution( M );
ObjectOfComplex( projres, n);
exactsequences := List( [ 0..n - 1 ], i -> [ KernelInclusion(DifferentialOfComplex(projres, i)),
ImageProjection(DifferentialOfComplex(projres, i)) ]);
f := MinimalLeftApproximation( Source( exactsequences[ n ][ 1 ] ), T );
for i in [ 1..n ] do
beta := IsomorphismOfModules( Source( exactsequences[ n + 1 - i ][ 1 ] ), Source( f ) );
f := beta * f;
g := PushOut( exactsequences[ n + 1 - i ][ 1 ], f )[ 1 ];
h := CoKernelProjection( g );
alpha := IsomorphismOfModules( Range( h ), Range( exactsequences[ n + 1 - i ][ 2 ] ) );
h := h * alpha;
if i < n then
fprime := MinimalLeftApproximation( Source( h ), T );
f := PushOut( fprime, h )[ 1 ];
fi;
od;
return RightMinimalVersion( h )[ 1 ];
end
);
#######################################################################
##
#O LeftApproximationByAddTHat( <T>, <M> )
##
## Returns the minimal left $\widehat{\add T}$-approximation of the
## module <M>. It checks if <T> is a cotilting module, and if not
## it returns an error message.
##
InstallMethod ( LeftApproximationByAddTHat,
"for a cotilting PathAlgebraMatModule and a PathAlgebraMatModule",
true,
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
0,
function( T, M )
local n, projres, exactsequences, currentsequences, f, i, g,
h, alpha, t, fprime;
if not IsCotiltingModule( T ) then
Error("the first argument is not a cotilting module,\n");
fi;
if IsZero( M ) then
return ZeroMapping( M, ZeroModule( RightActingAlgebra( M ) ) );
fi;
n := InjDimension( T );
projres := ProjectiveResolution( M );
ObjectOfComplex( projres, n);
exactsequences := List( [ 0..n - 1 ], i -> [ KernelInclusion(DifferentialOfComplex(projres, i)),
ImageProjection(DifferentialOfComplex(projres, i)) ]);
f := MinimalLeftApproximation( Source( exactsequences[ n ][ 1 ] ), T );
for i in [ 1..n ] do
g := PushOut( exactsequences[ n + 1 - i ][ 1 ], f )[ 1 ];
h := CoKernelProjection( g );
alpha := IsomorphismOfModules( Range( h ), Range( exactsequences[ n + 1 - i ][ 2 ] ) );
h := h * alpha;
fprime := MinimalLeftApproximation( Source( h ), T );
f := PushOut( fprime, h )[ 1 ];
od;
return LeftMinimalVersion( f )[ 1 ];
end
);
InstallMethod( IsNthSyzygy,
"for a PathAlgebraMatModule",
true,
[ IsPathAlgebraMatModule, IS_INT ],
0,
function( M, n )
local N;
N := NthSyzygy( DualOfModule( NthSyzygy( DualOfModule( M ), n ) ), n );
N := DirectSumOfQPAModules( [ N, Source( ProjectiveCover( M ) ) ] );
return IsDirectSummand( M, N );
end
);
#######################################################################
##
#O RightApproximationByAddM( <L>, <C> )
##
## Given a list of module <L> over a finite dimensional quotient A of
## a path algebra and a module <C> over A, this function computes
## a right approximation of <C> in the additive closure of the modules
## in the list <L>.
##
InstallMethod ( RightApproximationByAddM,
"for a list of modules and one module",
true,
[ IsList, IsPathAlgebraMatModule ],
0,
function( L, C )
local A, K, approximation, i, homL_iC, homL_ilessthanL_i,
homL_iapproxC, endL_i, radendL_i, RadendL_i, radmaps,
generators, radgenerators, generatorshomL_iC, g, V,
t, M, projections, f;
A := RightActingAlgebra( C );
if Length( L ) = 0 then
return ZeroMapping( ZeroModule( A ), C );
fi;
if not ForAll( L, l -> RightActingAlgebra( l ) = A ) then
Error( "Not all modules in the list of modules entered are modules over the same algebra.\n" );
fi;
K := LeftActingDomain( A );
approximation := [ ];
for i in [ 1..Length( L ) ] do
homL_iC := HomOverAlgebra( L[ i ], C );
if Length( homL_iC ) > 0 then
homL_ilessthanL_i := List( [ 1..Length(approximation) ], r -> HomOverAlgebra( L[ i ], Source( approximation[ r ] ) ) );
homL_iapproxC := Flat( List( [ 1..Length(approximation) ], r -> homL_ilessthanL_i[ r ] * approximation[ r ] ) );
homL_iapproxC := Filtered( homL_iapproxC, h -> not IsZero( h ) );
endL_i := EndOverAlgebra( L[ i ] );
radendL_i := RadicalOfAlgebra( endL_i );
RadendL_i := List( BasisVectors( Basis( radendL_i ) ), x -> FromEndMToHomMM( L[i], x) );
radmaps := Flat( List( homL_iC, h -> RadendL_i * h ) );
generators := List( homL_iapproxC, h -> Flat( MatricesOfPathAlgebraMatModuleHomomorphism( h ) ) );
radgenerators := List( radmaps, h -> Flat( MatricesOfPathAlgebraMatModuleHomomorphism( h ) ) );
Append( generators, radgenerators );
generatorshomL_iC := List( homL_iC, h -> Flat( MatricesOfPathAlgebraMatModuleHomomorphism( h ) ) );
if Length( generators ) = 0 then
generators := [ Flat( MatricesOfPathAlgebraMatModuleHomomorphism( ZeroMapping( L[ i ],C ) ) ) ];
fi;
for g in generatorshomL_iC do
V := VectorSpace( K, generators );
if not g in V then
Add( generators, g );
t := Position( generatorshomL_iC, g );
Add( approximation, homL_iC[ t ] );
fi;
od;
fi;
od;
M := DirectSumOfQPAModules( List( approximation, Source ) );
projections := DirectSumProjections( M );
f := Sum( List( [ 1..Length( projections ) ], i -> projections[ i ] * approximation[ i ] ) );
return f;
end
);
InstallMethod ( RadicalRightApproximationByAddM,
"for a list of modules and a module",
true,
[ IsList, IsInt ],
0,
function( modulelist, t )
local length, moduleset, N, f, K, M, endoN, radendoN,
BradendoN, gen_NtoM, radhomNN, Vgen_NtoM, VradhomNN,
U, pi, addhoms, i, newM, projections, homs;
length := Length( modulelist );
if not t in [ 1..length ] then
Error( "The entered integer is not in the correct interval.\n" );
fi;
moduleset := [ 1..length ];
RemoveSet( moduleset, t );
N := modulelist[ t ];
f := RightApproximationByAddM( modulelist{ moduleset }, N );
K := LeftActingDomain( N );
M := Source( f );
endoN := EndOverAlgebra( N );
radendoN := RadicalOfAlgebra( endoN );
BradendoN := Basis( radendoN );
gen_NtoM := List( HomOverAlgebra( N, M ), h -> h * f );
radhomNN := List( BradendoN, b -> FromEndMToHomMM( N, b ) );
if Length( radhomNN ) > 0 then
Vgen_NtoM := List( gen_NtoM, h -> Flat( MatricesOfPathAlgebraMatModuleHomomorphism( h ) ) );
VradhomNN := List( radhomNN, h -> Flat( MatricesOfPathAlgebraMatModuleHomomorphism( h ) ) );
U := FullRowSpace( K, Length( VradhomNN[ 1 ] ) );
pi := NaturalHomomorphismBySubspace( U, Subspace( U, Vgen_NtoM ) );
addhoms := [ ];
for i in [ 1..Length( VradhomNN ) ] do
if not IsZero( ImageElm( pi, VradhomNN[ i ] ) ) then
Add( addhoms, i );
fi;
od;
newM := [ M ];
for i in addhoms do
Add( newM, N );
od;
M := DirectSumOfQPAModules( newM );
projections := DirectSumProjections( M );
homs := [ f ];
for i in addhoms do
Add( homs, radhomNN[ i ] );
od;
f := Sum( List( [ 1..Length( projections ) ], i -> projections[ i ] * homs[ i ] ) );
fi;
return f;
end
);
InstallMethod ( ProjectiveResolutionOfSimpleModuleOverEndo,
"for a list of modules, an index of the list, and an integer",
true,
[ IsList, IsInt, IsInt ],
0,
function( modulelist, t, length )
local f, syzygies, n, U, m, test;
if length < 0 then
Error( "The entered length is less than zero.\n" );
fi;
f := RadicalRightApproximationByAddM( modulelist, t );
syzygies := [ ];
for n in [ 1..length - 2 ] do
if Dimension( Source( f ) ) = 0 then
return [ n - 1, syzygies ];
fi;
if IsInjective( f ) then
return [ n, syzygies ];
fi;
U := Kernel( f );
for m in modulelist do
repeat
test := CommonDirectSummand( U, m );
if test <> false then
U := test[ 2 ];
fi;
until
test = false;
od;
if Dimension( U ) = 0 then
return [ n + 1, syzygies ];
fi;
Add( syzygies, U );
f := RightApproximationByAddM( modulelist, U );
od;
return [ Concatenation( "projdim > ", String( t ) ), syzygies ];
end
);
