Spracherkennung für: .gi vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
# GAP Implementation
# This file was generated from
# $Id: functors.gi,v 1.9 2012/05/15 07:12:00 sunnyquiver Exp $
#######################################################################
##
#O DualOfModule(<M>)
##
## This function computes the dual DM of the module <M>, that is,
## it computes Hom_k(M, k). If <M> is a module over A, then DM is a
## module over the opposite algebra of A.
##
InstallMethod ( DualOfModule,
"for a representation of a quiver",
[ IsPathAlgebraMatModule ], 0,
function( M )
#
# M = a representation of the quiver Q over K with rels
#
local A_op, KQ, KQ_op, dim_vect_M, num_vert, vertices, i, j,
count, mat_M, mat_M_op, X, mats, arrows, a,
vert_in_quiver, origin, target, N;
A_op := OppositeAlgebra(RightActingAlgebra(M));
dim_vect_M := DimensionVector(M);
if Sum(dim_vect_M) = 0 then
return ZeroModule(A_op);
else
KQ_op := OriginalPathAlgebra(A_op);
num_vert := Length(DimensionVector(M));
mat_M := MatricesOfPathAlgebraModule(M);
arrows := ArrowsOfQuiver(QuiverOfPathAlgebra(KQ_op));
mat_M_op := List(mat_M, X -> TransposedMat(X));
vert_in_quiver := VerticesOfQuiver(QuiverOfPathAlgebra(KQ_op));
mats := [];
for a in arrows do
i := Position(arrows,a);
origin := Position(vert_in_quiver,SourceOfPath(a));
target := Position(vert_in_quiver,TargetOfPath(a));
if ( dim_vect_M[origin] <> 0 ) and ( dim_vect_M[target] <> 0 ) then
Add( mats, [ String( a ), mat_M_op[ i ] ] );
fi;
od;
N := RightModuleOverPathAlgebra( A_op, dim_vect_M, mats );
SetDualOfModule(N,M);
if HasIsIndecomposableModule(M) and IsIndecomposableModule(M) then
SetIsIndecomposableModule(N, true);
fi;
if HasIsProjectiveModule(M) and IsProjectiveModule(M) then
SetIsInjectiveModule(N, true);
fi;
if HasIsInjectiveModule(M) and IsInjectiveModule(M) then
SetIsProjectiveModule(N, true);
fi;
return N;
fi;
end
);
#######################################################################
##
#O TransposeOfModule(<M>)
##
## This function computes the transpose Tr(M) of the module <M>, that is,
## if P1 ---> P0 ---> M ---> 0 is a projective presentation of <M>,
## and <M> is a module over an algebra A, then Tr(M) is the cokernel
## of the map
##
## Hom_A(P0,A) ---> Hom_A(P1,A)
##
InstallMethod( TransposeOfModule,
"for a path algebra",
[ IsPathAlgebraMatModule ], 0,
function( M )
local A, B, Q, fam, KQ, gens, K,
num_vert, vertices, verticesinalg,
arrows, BB, i, j, B_M, G, MM, projective_cover, r,
test, vertex_list, P, PI_list, zero_in_P, g, temp,
matrix, solutions, Solutions, projective_vector, s,
a, syzygyoverKQ, U, RG, rgb, new_rtgbofI, run_time, rad,
vector, part, newpart, zero, radicalspace, V, W, VW, f,
topofsyzygy, x, Topofsyzygy, PP, P_list, P1_list, P_0, P_1,
min_gen_list, inc_list, supp, Aop, dim, PPop, P_0op_list, P_0op,
matrix_op;
A := RightActingAlgebra(M);
B := CanonicalBasis(A);
Q := QuiverOfPathAlgebra(A);
fam := ElementsFamily(FamilyObj( UnderlyingLeftModule( B ) ));
KQ := OriginalPathAlgebra(A);
K := LeftActingDomain(A);
if IsProjectiveModule(M) then
return ZeroModule(OppositeAlgebra(A));
fi;
num_vert := NumberOfVertices(Q);
vertices := VerticesOfQuiver(Q);
if IsPathAlgebra(A) then
verticesinalg := GeneratorsOfAlgebra(A){[1..num_vert]};
arrows := GeneratorsOfAlgebra(A){[1+num_vert..num_vert+NumberOfArrows(Q)]};
else
verticesinalg := GeneratorsOfAlgebra(A){[2..1+num_vert]};
arrows := GeneratorsOfAlgebra(A){[2+num_vert..1+num_vert+NumberOfArrows(Q)]};
fi;
#
# Finding a basis for all the indecomposable projective A-modules as
# right ideals.
#
BB := [];
for i in [1..num_vert] do
BB[i] := [];
od;
for i in [1..num_vert] do
for j in [1..Length(B)] do
if verticesinalg[i]*B[j] <> Zero(A) then
Add(BB[i],B[j]);
fi;
od;
od;
B_M := CanonicalBasis(M);
G := MinimalGeneratingSetOfModule(M);
#
# Computing the product of all the elements in the
# minimal generating set G of M, with the basis of the
# indecomposable projective covering that generator.
#
MM := [];
projective_cover := [];
for i in [1..Length(G)] do
r := 0;
repeat
r := r + 1;
test := G[i]^verticesinalg[r] <> Zero(M);
until test;
projective_cover[i] := r;
for j in [1..Length(BB[r])] do
Add(MM,G[i]^BB[r][j]);
od;
od;
matrix := NullMat(Length(MM),Dimension(M),K);
for i in [1..Length(MM)] do
matrix[i] := Flat(ExtRepOfObj(MM[i])![1]);
od;
#
# Finding the kernel of the projective cover as a vectorspace
#
solutions := NullspaceMat(matrix);
#
# Finding the kernel of the projective cover as elements of the
# direct sum of the indecomposable projective modules in the
# projective cover.
#
Solutions := [];
for i in [1..Length(solutions)] do
projective_vector := [];
s := 0;
for j in [1..Length(projective_cover)] do
a := Zero(A);
for r in [1..Length(BB[projective_cover[j]])] do
a := a + BB[projective_cover[j]][r]*solutions[i][r+s];
od;
Add(projective_vector,a);
s := s + Length(BB[projective_cover[j]]);
od;
Add(Solutions,projective_vector);
od;
#
# Finding the top of the syzygy, first finding generators of the
# radical of the syzygy, rad.
#
zero := ListWithIdenticalEntries(Length(projective_cover),Zero(A));
rad := [];
for s in Solutions do
for a in arrows do
if s*a <> zero then
Add(rad,s*a);
fi;
od;
od;
#
# Computing the radical as a vectorspace by flattening the vectors.
#
radicalspace := [];
for s in rad do
vector := [];
for i in [1..Length(projective_cover)] do
part := Coefficients(B,s[i]);
newpart := [];
for j in [1..Length(BB[projective_cover[i]])] do
newpart[j] := part[Position(B,BB[projective_cover[i]][j])];
od;
Add(vector,newpart);
od;
vector := Flat(vector);
Add(radicalspace,vector);
od;
#
# Computing a basis for syzygy modulo radical of syzygy as a
# vectorspace and pulling it back to the syzygy.
#
if Length(solutions) = 0 then
Print("The entered module is projective.\n");
return ZeroModule(OppositeAlgebra(A));
else
V := VectorSpace(K,solutions);
W := Subspace(V,radicalspace);
f := NaturalHomomorphismBySubspace(V,W);
VW := CanonicalBasis(Range(f));
topofsyzygy := [];
for x in VW do
Add(topofsyzygy,PreImagesRepresentative(f,x));
od;
#
# Finding the minimal generators of the syzygy as elements of the
# direct sum of the indecomposable projective modules in the
# projective cover.
#
Topofsyzygy := [];
for i in [1..Length(topofsyzygy)] do
projective_vector := [];
s := 0;
for j in [1..Length(projective_cover)] do
a := Zero(A);
for r in [1..Length(BB[projective_cover[j]])] do
a := a + BB[projective_cover[j]][r]*topofsyzygy[i][r+s];
od;
Add(projective_vector,a);
s := s + Length(BB[projective_cover[j]]);
od;
Add(Topofsyzygy,projective_vector);
od;
#
# Finding the indecomposable projective modules in the projective
# cover of M.
#
PP:= IndecProjectiveModules(A);
P_list := [];
for i in [1..Length(projective_cover)] do
Add(P_list,ShallowCopy(PP[projective_cover[i]]));
od;
P_0:= DirectSumOfQPAModules(P_list);
#
# Finding the indecomposable projective modules in the projective
# cover of the syzygy of M.
#
P1_list := [];
for i in [1..Length(Topofsyzygy)] do
supp := [];
for j in [1..Length(vertices)] do
if Topofsyzygy[i]*(vertices[j]*One(A)) <> Topofsyzygy[i]*Zero(A) then
Add(supp,j);
fi;
od;
if Length(supp) = 1 then
Add(P1_list,supp[1]);
else
Print("Error: Minimal generators of the syzygy are not uniform.\n");
return fail;
fi;
od;
#
# Transposing the presentation matrix of the module M,
# and taking the corresponding opposite element in the
# opposite algebra of all entries in the presentation matrix.
#
Aop := OppositeAlgebra(A);
matrix := ShallowCopy(TransposedMat(Topofsyzygy));
dim := DimensionsMat(matrix);
for i in [1..dim[1]] do
matrix[i] := List(matrix[i],x->OppositePathAlgebraElement(x));
od;
#
# Finding all indecomposable projective modules over the opposite algebra.
#
PPop := IndecProjectiveModules(Aop);
#
# Constructing the projective cover of the transpose of M.
#
P_0op_list := List(P1_list,x -> ShallowCopy(PPop[x]));
P_0op := DirectSumOfQPAModules(P_0op_list);
#
# Constructing the transpose as the coker of the inclusion of the image
# of the presentation matrix of the transpose of M.
#
gens := [];
inc_list := DirectSumInclusions(P_0op);
min_gen_list := [];
for i in [1..Length(P_0op_list)] do
Add(min_gen_list,ImageElm(inc_list[i],MinimalGeneratingSetOfModule(P_0op_list[i])[1]));
od;
for i in [1..dim[1]] do
temp := Zero(P_0op);
for j in [1..Length(min_gen_list)] do
temp := temp + min_gen_list[j]^matrix[i][j];
od;
Add(gens,temp);
od;
f := SubRepresentationInclusion(P_0op,gens);
U := CoKernel(f);
if Dimension(U) <> 0 and HasIsIndecomposableModule(M) and IsIndecomposableModule(M) then
SetIsIndecomposableModule(U, true);
fi;
return U;
fi;
end
);
#######################################################################
##
#O DTr(<M>)
##
## This function returns the dual of the transpose of a module <M>,
## sometimes denoted by "tau". It uses the previous methods DualOfModule
## and TransposeOfModule.
##
InstallMethod( DTr,
"for a path algebra module",
[ IsPathAlgebraMatModule ], 0,
function( M );
return DualOfModule(TransposeOfModule(M));
end
);
#######################################################################
##
#O TrD(<M>)
##
## This function returns the transpose of the dual of a module <M>,
## sometimes denoted by "tau inverse". It uses the previous methods DualOfModule
## and TransposeOfModule.
##
InstallMethod( TrD,
"for a path algebra module",
[ IsPathAlgebraMatModule ], 0,
function( M );
return TransposeOfModule(DualOfModule(M));
end
);
#######################################################################
##
#O DTr(<M>, <n>)
##
## This function returns returns DTr^n(<M>) of a module <M>.
## It will also print "Computing step i ..." when computing the ith
## DTr. <n> must be an integer.
##
InstallOtherMethod( DTr,
"for a path algebra module",
[ IsPathAlgebraMatModule, IS_INT ], 0,
function( M, n )
local U, i;
U := M;
if n < 0 then
for i in [1..-n] do
Print("Computing step ",i,"...\n");
U := TrD(U);
od;
else
if n >= 1 then
for i in [1..n] do
Print("Computing step ",i,"...\n");
U := DTr(U);
od;
fi;
fi;
return U;
end
);
#######################################################################
##
#O TrD(<M>, <n>)
##
## This function returns returns TrD^n(<M>) of a module <M>.
## It will also print "Computing step i ..." when computing the ith
## TrD. <n> must be an integer.
##
##
InstallOtherMethod( TrD,
"for a path algebra module",
[ IsPathAlgebraMatModule, IS_INT ], 0,
function( M, n )
local U, i;
U := M;
if n < 0 then
for i in [1..-n] do
Print("Computing step ",i,"...\n");
U := DTr(U);
od;
else
if n >= 1 then
for i in [1..n] do
Print("Computing step ",i,"...\n");
U := TrD(U);
od;
fi;
fi;
return U;
end
);
#######################################################################
##
#A StarOfModule( <M> )
##
## This function takes as an argument a module over an algebra A and
## computes the module Hom_A(M,A) over the opposite of A.
##
InstallMethod( StarOfModule,
"for a matrix",
[ IsPathAlgebraMatModule ],
function( M )
local A, Aop, K, P, V, BV, BasisVflat, b, dimvector, Bproj, arrows,
arrowsop, leftmultwitharrows, a, source, target, matrices, temp;
#
# Setting up necessary infrastructure.
#
A := RightActingAlgebra(M);
Aop := OppositeAlgebra(A);
K := LeftActingDomain(M);
P := IndecProjectiveModules(A);
#
# Finding the vector spaces in each vertex in the representation of
# Hom_A(M,A) and making a vector space of the flatten matrices in
# each basis vector in Hom_A(M,e_iA).
#
V := List(P, p -> HomOverAlgebra(M,p));
BV := List(V, v -> List(v, x ->
Flat(MatricesOfPathAlgebraMatModuleHomomorphism(x))));
BasisVflat := [];
for b in BV do
if Length(b) <> 0 then
Add(BasisVflat,
Basis(Subspace(FullRowSpace(K, Length(b[1])), b, "basis"), b));
else
Add(BasisVflat, []);
fi;
od;
#
# Finding the dimension vector of Hom_A(M,A) and computing the maps
# induced by left multiplication by arrows alpha : i ---> j from
# e_jA ---> e_iA.
#
dimvector := List(V, Length);
Bproj := BasisOfProjectives(A);
Bproj := List([1..Length(dimvector)],
i -> Subspace(A, Flat(Bproj[i]), "basis"));
arrows := ArrowsOfQuiver(QuiverOfPathAlgebra(A));
arrowsop := ArrowsOfQuiver(QuiverOfPathAlgebra(Aop));
leftmultwitharrows := [];
for a in arrows do
source := VertexIndex(SourceOfPath(a));
target := VertexIndex(TargetOfPath(a));
Add(leftmultwitharrows,
HomFromProjective(MinimalGeneratingSetOfModule(P[source])[1]^(a*One(A)), P[source]));
od;
#
# Finally, finding the linear maps in the representation given by Hom_A(M,A) and
# constructing the module/representation over A^op.
#
matrices := [];
for a in arrows do
source := VertexIndex(SourceOfPath(a));
target := VertexIndex(TargetOfPath(a));
if dimvector[source] <> 0 and dimvector[target] <> 0 then
temp := V[target]*leftmultwitharrows[Position(arrows, a)];
temp := List(temp, t -> Coefficients(BasisVflat[source],
Flat(MatricesOfPathAlgebraMatModuleHomomorphism(t))));
Add(matrices, [String(arrowsop[Position(arrows, a)]), temp]);
fi;
od;
return RightModuleOverPathAlgebra(Aop, dimvector, matrices);
end
);
#######################################################################
##
#A StarOfModuleHomomorphism( <f> )
##
## This function takes as an argument a homomorphism f between two
## modules M and N over an algebra A and computes the induced
## homomorphism from the module Hom_A(N, A) to the module
## Hom_A(M, A) over the opposite of A.
##
InstallMethod( StarOfModuleHomomorphism,
"for a matrix",
[ IsPathAlgebraMatModuleHomomorphism ],
function( f )
local M, N, starM, starN, A, Aop, K, P, VN, dimvectorstarN, BfVN,
VM, dimvectorstarM, BVM, BasisVMflat, b, maps, i, map, dimrow,
dimcol;
M := Source(f);
N := Range(f);
#
# Finding the source and range of StarOfModuleHomomorphism(f).
#
starM := StarOfModule(M);
starN := StarOfModule(N);
#
# Setting up necessary infrastructure.
#
A := RightActingAlgebra(M);
Aop := OppositeAlgebra(A);
K := LeftActingDomain(M);
P := IndecProjectiveModules(A);
VN := List(P, p -> HomOverAlgebra(N,p));
dimvectorstarN := List(VN, Length);
#
# Finding the image of the map StarOfModuleHomomorphism(f).
#
VN := List(VN, v -> f*v);
BfVN := List(VN, v -> List(v, x ->
Flat(MatricesOfPathAlgebraMatModuleHomomorphism(x))));
#
# Computing the basis of StarOfModule(Source(f)) used when the module
# was constructed.
#
VM := List(P, p -> HomOverAlgebra(M,p));
dimvectorstarM := List(VM, Length);
BVM := List(VM, v -> List(v, x ->
Flat(MatricesOfPathAlgebraMatModuleHomomorphism(x))));
BasisVMflat := [];
for b in BVM do
if Length(b) <> 0 then
Add(BasisVMflat,
Basis(Subspace(FullRowSpace(K, Length(b[1])), b, "basis"), b));
else
Add(BasisVMflat, []);
fi;
od;
#
# Constructing the map induced by f from StarOfModule(Range(f)) to
# StarOfModule(Source(f)).
#
maps := [];
for i in [1..Length(BfVN)] do
if Length(BfVN[i]) <> 0 and Length( BasisVMflat[ i ] ) <> 0 then
map := List(BfVN[i], t -> Coefficients(BasisVMflat[i], t));
else
if dimvectorstarN[i] = 0 then
dimrow := 1;
else
dimrow := dimvectorstarN[i];
fi;
if dimvectorstarM[i] = 0 then
dimcol := 1;
else
dimcol := dimvectorstarM[i];
fi;
map := NullMat(dimrow,dimcol,K);
fi;
Add(maps, map);
od;
return RightModuleHomOverAlgebra(starN, starM, maps);
end
);
#######################################################################
##
#A NakayamaFunctorOfModule( <M> )
##
## This function takes as an argument a module over an algebra A and
## computes the image of the Nakayama functor, that is, the module
## Hom_K(Hom_A(M, A), K) over A.
##
InstallMethod( NakayamaFunctorOfModule,
"for a matrix",
[ IsPathAlgebraMatModule ],
function( M );
return DualOfModule( StarOfModule( M ) );
end
);
#######################################################################
##
#A OppositeNakayamaFunctorOfModule( <M> )
##
## This function takes as an argument a module over an algebra A and
## computes module Hom_A(Hom_K( M, K ), A ) over A.
##
InstallMethod( OppositeNakayamaFunctorOfModule,
"for a matrix",
[ IsPathAlgebraMatModule ],
function( M );
return StarOfModule( DualOfModule( M ) );
end
);
#######################################################################
##
#A NakayamaFunctorOfModuleHomomorphism( <f> )
##
## This function takes as an argument a homomorphism f between two
## modules M and N over an algebra A and computes the induced
## homomorphism from the module Hom_K(Hom_A(N, A), K) to the module
## Hom_K(Hom_A(M, A), K) over A.
##
InstallMethod( NakayamaFunctorOfModuleHomomorphism,
"for a matrix",
[ IsPathAlgebraMatModuleHomomorphism ],
function( f );
return DualOfModuleHomomorphism( StarOfModuleHomomorphism( f ) );
end
);
#######################################################################
##
#A OppositeNakayamaFunctorOfModuleHomomorphism( <f> )
##
## This function takes as an argument a homomorphism f between two
## modules M and N over an algebra A and computes the induced
## homomorphism from the module Hom_K(Hom_A(N, A), K) to the module
## Hom_K(Hom_A(M, A), K) over A.
##
InstallMethod( OppositeNakayamaFunctorOfModuleHomomorphism,
"for a matrix",
[ IsPathAlgebraMatModuleHomomorphism ],
function( f );
return StarOfModuleHomomorphism( DualOfModuleHomomorphism( f ) );
end
);
#######################################################################
##
#O TensorProductOfModules( <M>, <N> )
##
## Given two representations <Arg>M</Arg> and <Arg>N</Arg>, where
## <Arg>M</Arg> is a right module over <M>A</M> and <Arg>N</Arg> is
## a right module over the opposite of <M>A</M>, then this function
## computes the tensor product <M>M\otimes_A N</M> as a vector space
## and a function <M>M\times N \to M\otimes_A N</M>.
##
InstallMethod ( TensorProductOfModules,
"for two representations of a fin. dim. quotient of a path algebra",
true,
[ IsPathAlgebraMatModule, IsPathAlgebraMatModule ],
0,
function( M, N )
local A, F, topofM, dimvectorN, V, elementarytensor,
projres, pi, d1, inclusionsP1, projectionsP0,
imagesofgensP1, t, projectivesinP0, verticesofquiver,
projectivesinP1, matrix, topofP1, topofP0, dimvectorM,
size_matrix, bigmatrix, i, tempmat, j, m, s, startN,
temp, d1tensoronemap, rowsinblock, r, dim, W, h;
A := RightActingAlgebra( M );
if A <> OppositeAlgebra( RightActingAlgebra( N ) ) then
Error("The entered modules are not over the appropriate algebras,\n");
fi;
F := LeftActingDomain( M );
#
# An easy check if the tensor product is zero, if so, return zero.
#
topofM := DimensionVector( TopOfModule( M ) );
dimvectorN := DimensionVector( N );
if topofM*dimvectorN = 0 then
V := F^1;
elementarytensor := function( m, n );
return Zero(V);
end;
return [ TrivialSubspace( V ), elementarytensor ];
fi;
#
# Computing M \otimes N via taking a projective resolution of M and then tensoring
# with N.
#
projres := ProjectiveResolution( M );
ObjectOfComplex( projres, 1 );
pi := DifferentialOfComplex( projres, 0 );
d1 := DifferentialOfComplex( projres, 1 );
projectionsP0 := DirectSumProjections( Range( d1 ) );
t := Length( projectionsP0 );
projectivesinP0 := List( projectionsP0, p -> SupportModuleElement( MinimalGeneratingSetOfModule( Range( p ) )[ 1 ] ) );
if IsQuotientOfPathAlgebra( A ) then
projectivesinP0 := List( projectivesinP0, t -> CoefficientsAndMagmaElements( t![ 1 ]![ 1 ] )[ 1 ] );
elif IsPathAlgebra( A ) then
projectivesinP0 := List( projectivesinP0, t -> CoefficientsAndMagmaElements( t![ 1 ] )[ 1 ] );
else
Error("Something went wrong, inform the maintainers of the QPA-package,\n");
fi;
verticesofquiver := VerticesOfQuiver( QuiverOfPathAlgebra( A ) );
projectivesinP0 := List( projectivesinP0, v -> Position( verticesofquiver, v ) );
#
# If P_1 - d1 -> P_0 --> M --> 0 is a minimal projective presentation of M and
# P_1\otimes N = (0), then M\otimes N \simeq P_0\otimes N.
#
if DimensionVector( Source( d1 ) ) * dimvectorN = 0 then
dim := topofM * dimvectorN;
V := F^dim;
h := NaturalHomomorphismBySubspace( V, TrivialSubspace( V ) );
elementarytensor := function( m, n )
local p0, psum, nsum, v;
p0 := PreImagesRepresentative( pi, m );
psum := List( [ 1..t ], n -> ElementInIndecProjective( A, ImageElm( projectionsP0[ n ], p0 ), projectivesinP0[ n ] ) );
if IsQuotientOfPathAlgebra( A ) then
psum := List( psum, x -> ElementOfQuotientOfPathAlgebra( ElementsFamily( FamilyObj( OppositeAlgebra( A ) ) ), OppositePathAlgebraElement( x ), true ) );
elif IsPathAlgebra( A ) then
psum := List( psum, x -> OppositePathAlgebraElement( x ) );
else
Error("Something went wrong, inform the maintainers of the QPA-package,\n");
fi;
nsum := List( psum, x -> n^x );
v := Flat( List( [ 1..size_matrix[ 2 ] ], l -> nsum[ l ]![ 1 ]![ 1 ][ projectivesinP0[ l ] ] ) );
return ImageElm( h, v );
end;
return [ Range( h ), elementarytensor ];
fi;
inclusionsP1 := DirectSumInclusions( Source( d1 ) );
imagesofgensP1 := List( inclusionsP1, f -> ImageElm( f, MinimalGeneratingSetOfModule( Source( f ) )[ 1 ] ) );
imagesofgensP1 := List( imagesofgensP1, m -> ImageElm( d1, m ) );
projectivesinP1 := List( inclusionsP1, i -> SupportModuleElement( MinimalGeneratingSetOfModule( Source( i ) )[ 1 ] ) );
projectivesinP1 := List( projectivesinP1, t -> CoefficientsAndMagmaElements( t![ 1 ]![ 1 ] )[ 1 ] );
projectivesinP1 := List( projectivesinP1, v -> Position( verticesofquiver, v ) );
matrix := List( imagesofgensP1, m -> List( [ 1..t ], n ->
ElementInIndecProjective( A, ImageElm( projectionsP0[ n ], m ), projectivesinP0[ n ] ) ) );
if IsQuotientOfPathAlgebra( A ) then
matrix := List( matrix, m -> List( m, x -> ElementOfQuotientOfPathAlgebra( ElementsFamily( FamilyObj( OppositeAlgebra( A ) ) ), OppositePathAlgebraElement( x ), true ) ) );
elif IsPathAlgebra( A ) then
matrix := List( matrix, m -> List( m, x -> OppositePathAlgebraElement( x ) ) );
else
Error("Something went wrong, inform the maintainers of the QPA-package,\n");
fi;
topofP1 := DimensionVector( TopOfModule( Source( d1 ) ) );
topofP0 := DimensionVector( TopOfModule( Range( d1 ) ) );
dimvectorM := DimensionVector( M );
size_matrix := DimensionsMat( matrix );
bigmatrix := NullMat( size_matrix[ 1 ], size_matrix[ 2 ], F );
for i in [ 1..size_matrix[ 1 ] ] do
for j in [ 1..size_matrix[ 2 ] ] do
m := matrix[ i ][ j ];
s := projectivesinP0[ j ];
t := projectivesinP1[ i ];
startN := Sum( dimvectorN{ [ 1..t - 1 ] } );
if Length( Basis( N ){ [ startN + 1..startN + dimvectorN[ t ] ] } ) > 0 then
temp := List( Basis( N ){ [ startN + 1..startN + dimvectorN[ t ] ] }, b -> b^m );
tempmat := List( temp, t -> t![ 1 ]![ 1 ][ s ] );
else
tempmat := NullMat( 1, Length( Basis( N )[ 1 ]![ 1 ]![ 1 ][ s ] ), F );
fi;
bigmatrix[ i ][ j ] := tempmat;
od;
od;
d1tensoronemap := [];
for i in [ 1..size_matrix[ 1 ] ] do
rowsinblock := DimensionsMat( bigmatrix[ i ][ 1 ] )[ 1 ];
for r in [ 1..rowsinblock ] do
temp := [];
for j in [ 1..size_matrix[ 2 ] ] do
Add( temp, bigmatrix[ i ][ j ][ r ] );
od;
temp := Flat(temp);
Add( d1tensoronemap, temp );
od;
od;
dim := Length( d1tensoronemap[ 1 ] );
V := F^dim;
W := Subspace( V, d1tensoronemap );
h := NaturalHomomorphismBySubspace( V, W );
elementarytensor := function( m, n )
local p0, psum, nsum, v;
p0 := PreImagesRepresentative( pi, m );
psum := List( [ 1..t ], n -> ElementInIndecProjective( A, ImageElm( projectionsP0[ n ], p0 ), projectivesinP0[ n ] ) );
if IsQuotientOfPathAlgebra( A ) then
psum := List( psum, x -> ElementOfQuotientOfPathAlgebra( ElementsFamily( FamilyObj( OppositeAlgebra( A ) ) ), OppositePathAlgebraElement( x ), true ) );
elif IsPathAlgebra( A ) then
psum := List( psum, x -> OppositePathAlgebraElement( x ) );
else
Error("Something went wrong, inform the maintainers of the QPA-package,\n");
fi;
nsum := List( psum, x -> n^x );
v := Flat( List( [ 1..size_matrix[ 2 ] ], l -> nsum[ l ]![ 1 ]![ 1 ][ projectivesinP0[ l ] ] ) );
return ImageElm( h, v );
end;
return [ Range( h ), elementarytensor ];
end);
InstallMethod( TransposeOfModuleHomomorphism,
"for a homomorphism a path algebra module",
[ IsPathAlgebraMatModuleHomomorphism ], 0,
function( f )
local B, C, d0, d0prime, kerd0, kerd0prime, d1temp,
d1primetemp, d1, d1prime, f0, f1prime, f1, homstar,
Dhomstar, h;
B := Source( f );
C := Range( f );
d0 := ProjectiveCover( B );
d0prime := ProjectiveCover( C );
kerd0 := KernelInclusion( d0 );
kerd0prime := KernelInclusion( d0prime );
d1temp := ProjectiveCover( Source( kerd0 ) );
d1primetemp := ProjectiveCover( Source( kerd0prime ) );
d1 := d1temp * kerd0;
d1prime := d1primetemp * kerd0prime;
f0 := LiftingMorphismFromProjective( d0prime, d0 * f );
f1prime := MorphismOnKernel( d0, d0prime, f0, f );
f1 := LiftingMorphismFromProjective( d1primetemp, d1temp * f1prime );
homstar := List( [ d1, d1prime, f1, f0 ], StarOfModuleHomomorphism );
h := MorphismOnCoKernel( homstar[ 2 ], homstar[ 1 ], homstar[ 4 ], homstar[ 3 ] );
return h;
end
);
InstallMethod( TrD,
"for a homomorphism a path algebra module",
[ IsPathAlgebraMatModuleHomomorphism ], 0,
function( f )
local h, B, C;
h := TransposeOfModuleHomomorphism( DualOfModuleHomomorphism( f ) );
B := TrD( Source( f ) );
C := TrD( Range( f ) );
h := RightModuleHomOverAlgebra( B, C, h!.maps );
return h;
end
);
InstallMethod( DTr,
"for a homomorphism a path algebra module",
[ IsPathAlgebraMatModuleHomomorphism ], 0,
function( f )
local h, B, C;
h := DualOfModuleHomomorphism( TransposeOfModuleHomomorphism( f ) );
B := DTr( Source( f ) );
C := DTr( Range( f ) );
h := RightModuleHomOverAlgebra( B, C, h!.maps );
return h;
return DualOfModuleHomomorphism( TransposeOfModuleHomomorphism( f ) );
end
);
#######################################################################
##
#O DTr( <f>, <n> )
##
## This function returns returns DTr^n( <f> ) of a module homomorphism <f>.
## It will also print "Computing step i ..." when computing the ith
## DTr. <n> must be an integer.
##
InstallOtherMethod( DTr,
"for a path algebra module homomorphism",
[ IsPathAlgebraMatModuleHomomorphism, IS_INT ], 0,
function( f, n )
local g, i;
g := f;
if n < 0 then
for i in [ 1..-n ] do
Print( "Computing step ",i,"...\n" );
g := TrD( g );
od;
else
if n >= 1 then
for i in [ 1..n ] do
Print( "Computing step ",i,"...\n" );
g := DTr( g );
od;
fi;
fi;
return g;
end
);
#######################################################################
##
#O TrD( <f>, <n> )
##
## This function returns returns TrD^n( <f> ) of a module homomorphism <f>.
## It will also print "Computing step i ..." when computing the ith
## TrD. <n> must be an integer.
##
##
InstallOtherMethod( TrD,
"for a path algebra module homomorphism",
[ IsPathAlgebraMatModuleHomomorphism, IS_INT ], 0,
function( f, n )
local g, i;
g := f;
if n < 0 then
for i in [ 1..-n ] do
Print( "Computing step ",i,"...\n" );
g := DTr( g );
od;
else
if n >= 1 then
for i in [ 1..n ] do
Print( "Computing step ",i,"...\n" );
g := TrD( g );
od;
fi;
fi;
return g;
end
);
