|
#(C) Graham Ellis, 2005-2006
#####################################################################
InstallGlobalFunction(ResolutionAbelianGroup_alt,
function(arg)
local
ResolutionFreeAbelianGroup,
ResolutionAbelianInvariants,
ResolutionAbGroup;
#####################################################################
#####################################################################
ResolutionFreeAbelianGroup:=function(d,n)
local
gens,
F, FrAb, G,
FhomFrAb, GhomFrAb,
FirstProj,SecondProj,
R,T,k;
if d=0 then return ResolutionFiniteGroup(Group([()]),n); fi;
F:=FreeGroup(1);
R:=ResolutionAsphericalPresentation(F,[],n);
FrAb:=CoxeterDiagramFpArtinGroup(List([1..d],i->[i]));
FrAb:=FrAb[1]/FrAb[2];
gens:=GeneratorsOfGroup(FrAb);
FhomFrAb:=[];
FirstProj:=[];
SecondProj:=[];
for k in [1..d] do
FhomFrAb[k]:=GroupHomomorphismByImagesNC(F,FrAb,[F.1],[gens[k]]);
od;
T:=R;
for k in [2..d] do
if HAPconstant>49 then
T:=ResolutionDirectProduct(R,T);
else
T:=ResolutionFiniteDirectProduct(R,T);
fi;
FirstProj[k]:=T!.firstProjection;
SecondProj[k]:=T!.secondProjection;
od;
#############################################################
GhomFrAb:=function(k,g)
local g1, g2;
if k=1 then return Image(FhomFrAb[d],g); fi;
g1:=Image(FhomFrAb[d-k+1],Image(FirstProj[k],g));
g2:=Image(SecondProj[k],g);
g2:=GhomFrAb(k-1,g2);
return g1*g2;
end;
#############################################################
T!.elts:=List(T!.elts,x->GhomFrAb(d,x));
T!.group:=FrAb;
return T;
end;
#####################################################################
#####################################################################
#####################################################################
#####################################################################
ResolutionAbelianInvariants:=function(coeffs,n)
local head,tail,R;
if Length(coeffs)=0 then return
ResolutionFiniteGroup(CyclicGroup(1),n); fi;
if Length(coeffs)=1 then
if coeffs[1]=0 then
return ResolutionAsphericalPresentation(FreeGroup(1),[],n);
else
return ResolutionFiniteGroup(CyclicGroup(coeffs[1]),n);
fi;
fi;
head:=[coeffs[1]];
tail:=List([2..Length(coeffs)],i->coeffs[i]);
#if Minimum(coeffs)=0 then
if HAPconstant>49 then
return ResolutionDirectProduct(ResolutionAbelianInvariants(head,n),
ResolutionAbelianInvariants(tail,n));
else
return ResolutionFiniteDirectProduct(ResolutionAbelianInvariants(head,n),
ResolutionAbelianInvariants(tail,n));
fi;
end;
#####################################################################
#####################################################################
#####################################################################
#####################################################################
ResolutionAbGroup:=function(G,n)
local gens, C, head, tail, R, hom, OriginalElts,OriginalGroup ;
if Order(G)=1 then
if not IsPcpGroup(G) then
R:=ResolutionFiniteGroup(Group(Identity(G)),n);
return R;
fi;
#The following code gets around the bug that Elements(G) does not
#work for a pcp group G
R:=ResolutionFiniteGroup(Group(()),n);
R!.group:=G;
R!.elts:=[Identity(G)];
return R;
fi;
gens:=TorsionGeneratorsAbelianGroup(G);
if Length(gens)=0 then return
ResolutionFiniteGroup([Identity(G)],n); fi;
if Length(gens)=1 then
C:=Group(gens[1]);
return ResolutionFiniteGroup(C,n);
#R:=ResolutionFiniteCyclicGroup(C,n);
#R!.elts:=List([1..Order(C)],i->gens[1]^(i-1));
#return R;
fi;
head:=Group([gens[1]]);
tail:=Group(List([2..Length(gens)],i->gens[i]));
#if Minimum(AbelianInvariants(G))=0 then
if HAPconstant>49 then
R:=ResolutionDirectProduct(ResolutionAbGroup(head,n),
ResolutionAbGroup(tail,n));
else
R:=ResolutionFiniteDirectProduct(ResolutionAbGroup(head,n),
ResolutionAbGroup(tail,n));
fi;
OriginalElts:=R!.elts;
if IsMutable(R!.elts) then
Append(R!.elts,Elements(R!.group));
fi;
OriginalGroup:=R!.group;
hom:=GroupHomomorphismByFunction(OriginalGroup,G,x->
Image(Projection(OriginalGroup,1),x)*
Image(Projection(OriginalGroup,2),x));
R!.elts:=List(R!.elts,x->Image(hom,x));
R!.group:=G;
return R;
end;
#####################################################################
#####################################################################
if IsList(arg[1]) and IsInt(arg[2]) then
if Sum(arg[1])=0 and Length(arg[1])>1 then return
ResolutionFreeAbelianGroup(Length(arg[1]),arg[2]);
else
return ResolutionAbelianInvariants(arg[1],arg[2]);
fi;
fi;
if IsGroup(arg[1]) and IsInt(arg[2]) then
if IsFinite(arg[1]) then
return ResolutionAbGroup(arg[1],arg[2]); fi; fi;
Print("The first argument must be a list of nonnegative integers or a finite abelian group. The second argument must be a positive integer. \n");
return fail;
end);
[ Dauer der Verarbeitung: 0.34 Sekunden
(vorverarbeitet)
]
|
