Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place. Commercial Alternative to JupyterHub.
Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place. Commercial Alternative to JupyterHub.
| Download
GAP 4.8.9 installation with standard packages -- copy to your CoCalc project to get it
Project: cocalc-sagemath-dev-slelievre
Views: 521813###############################################################################
#0
#F NerveOfCatOneGroup
## Input: A cat-1-group or a morphism of cat-1-group or a sequence of
## morphisms of cat-1-groups
## Output: The image of the input under the functor
## Nerve: (cat-1-groups)->(simplicial groups)
##
InstallGlobalFunction(NerveOfCatOneGroup,
function(X,n)
local
NerveOfCatOneGroup_Morpre,
C,NerveOfCatOneGroup_Obj,
NerveOfCatOneGroup_Mor,
NerveOfCatOneGroup_Seq;
######################################################################
#1
#F NerveOfCatOneGroup_Obj
## Input: Cat-1-group C and an integer number
## Output: The nerve of C
##
NerveOfCatOneGroup_Obj:=function(C,number)
local
LGs,LBs, LDs,
s,t,e,
N,M,AutM,phi,
g,pg,m,ConjTmp,Tmp,TmpBs,TmpDs,
Gens,GensToLists,ImgGens,
LTmpB,LTmpD,
i,j,k,n,len,
EmbOnes,EmbTwos,Pros,
ListToOne,BoundariesOfToList,DegeneraciesOfToList,
GroupsList,BoundariesList,DegeneraciesList;
if not IsHapCatOneGroup(C) then
Print("This function must be applied to a cat-1-group.\n");
return fail;
fi;
s:=C!.sourceMap;
t:=C!.targetMap;
N:=Image(s);
M:=Kernel(s);
AutM:=AutomorphismGroup(M);
e:=One(M);
LGs:=[];
LBs:=[];
LDs:=[];
EmbOnes:=[];
EmbTwos:=[];
Pros:=[];
Gens:=[];
GensToLists:=[];
########## Compute the list of group G_i for i=1..n ##############
LGs[1]:=s!.Source;
Gens[1]:=GeneratorsOfGroup(LGs[1]);
GensToLists[1]:=List(Gens[1],g->[g]);
for n in [2..number] do
ConjTmp:=[];
len:=Length(Gens[n-1]);
for i in [1..len] do
m:=GensToLists[n-1][i][1];
for j in [2..n-1] do
m:=m*GensToLists[n-1][i][j];
od;
Add(ConjTmp,ConjugatorAutomorphismNC(M,Image(t,m)));
od;
phi:=GroupHomomorphismByImagesNC(LGs[n-1],AutM,Gens[n-1],ConjTmp);
LGs[n]:=SemidirectProduct(LGs[n-1],phi,M);
EmbOnes[n]:=Embedding(LGs[n],1);
EmbTwos[n]:=Embedding(LGs[n],2);
Pros[n]:=Projection(LGs[n]);
Gens[n]:=GeneratorsOfGroup(LGs[n]);
len:=Length(Gens[n]);
GensToLists[n]:=List([1..len],x->[]);
for i in [1..len] do
g:=Gens[n][i];
Tmp:=[];
for j in [1..n-1] do
pg:=Image(Pros[n-j+1],g);
m:=PreImagesRepresentative(EmbTwos[n-j+1],
(Image(EmbOnes[n-j+1],pg))^(-1)*g);
Tmp[n-j+1]:=m;
g:=pg;
od;
Tmp[1]:=g;
GensToLists[n][i]:=Tmp;
od;
od;
#############################################################
#2
#F BoundariesOfToList
## Input: List m:=[g_1,m_2,...,m_n]
## Output: List of the image of d_i(m) with i:=0..n
##
BoundariesOfToList:=function(Lm,n)
local i,j,TmpB,LB;
if n=2 then
LB:=[[Image(t,Lm[1])*Lm[2]],[Lm[1]*Lm[2]],[Lm[1]]];
fi;
if n>2 then
LB:=[];
########## Compute d_0 #########################
TmpB:=[Image(t,Lm[1])*Lm[2]];
for i in [2..n-1] do
TmpB[i]:=Lm[i+1];
od;
Add(LB,TmpB);
########## Compute d_1-->d_{n-1} ###############
for i in [2..n] do
TmpB:=[];
for j in [1..i-2] do
TmpB[j]:=Lm[j];
od;
TmpB[i-1]:= Lm[i-1]*Lm[i];
for j in [i..n-1] do
TmpB[j]:=Lm[j+1];
od;
Add(LB,TmpB);
od;
######### Compute d_n ##########################
TmpB:=[];
for i in [1..n-1] do
TmpB[i]:=Lm[i];
od;
Add(LB,TmpB);
fi;
return LB;
end;
##
########## end of BoundariesOfToList ########################
#############################################################
#2
#F DegeneraciesOfToList
## Input: List m:=[g_1,m_2,...,m_n]
## Output: List of the image of s_i(m) with i:=0..n
##
DegeneraciesOfToList:=function(Lm,n)
local i,j,TmpD,LD,g;
g:=Lm[1];
if n=1 then
LD:=[[Image(s,g),Image(s,g^(-1))*g],[g,e]];
fi;
if n>1 then
LD:=[];
########## Compute s_0 #########################
TmpD:=[Image(s,g),Image(s,g^(-1))*g];
for i in [3..n+1] do
TmpD[i]:=Lm[i-1];
od;
Add(LD,TmpD);
########## Compute s_1 -> s_n ##################
for i in [2..n+1] do
TmpD:=[];
for j in [1..i-1] do
TmpD[j]:=Lm[j];
od;
TmpD[i]:=e;
for j in [i+1..n+1] do
TmpD[j]:=Lm[j-1];
od;
Add(LD,TmpD);
od;
fi;
return LD;
end;
##
########## end of DegeneraciesOfToList ######################
#############################################################
#2
#F ListToOne
## Input: List [g_1,m_2,m_3,...,m_n]
## Output: The semi-product g_1 x| m_2 x| m_3 x| ... x| m_n
##
ListToOne:=function(Lm,n)
local i,m;
if n=1 then
m:=Lm[1];
fi;
if n>1 then
m:=Lm[1];
for i in [2..n] do
m:=Image(EmbOnes[i],m)*Image(EmbTwos[i],Lm[i]);
od;
fi;
return m;
end;
##
########## end of ListToOne #################################
############### Compute boundary maps #######################
LBs:=[[t,s]];
for n in [2..number] do
len:=Length(Gens[n]);
Tmp:=[];
TmpBs:=[];
for i in [1..len] do
Tmp[i]:=BoundariesOfToList(GensToLists[n][i],n);
TmpBs[i]:=List(Tmp[i],Lm->ListToOne(Lm,n-1));
od;
ImgGens:=[];
for k in [1..n+1] do
ImgGens[k]:=List([1..len],i->TmpBs[i][k]);
od;
LTmpB:=[];
for k in [1..n+1] do
LTmpB[k]:=GroupHomomorphismByImagesNC(LGs[n],LGs[n-1],
Gens[n],ImgGens[k]);
od;
LBs[n]:=LTmpB;
od;
############### Compute degeneracy maps #####################
for n in [1..number-1] do
len:=Length(Gens[n]);
Tmp:=[];
TmpDs:=[];
for i in [1..len] do
Tmp[i]:=DegeneraciesOfToList(GensToLists[n][i],n);
TmpDs[i]:=List(Tmp[i],Lm->ListToOne(Lm,n+1));
od;
ImgGens:=[];
for k in [1..n+1] do
ImgGens[k]:=List([1..len],i->TmpDs[i][k]);
od;
LTmpD:=[];
for k in [1..n+1] do
LTmpD[k]:=GroupHomomorphismByImagesNC(LGs[n],LGs[n+1],
Gens[n],ImgGens[k]);
od;
LDs[n]:=LTmpD;
od;
#############################################################
#2
GroupsList:=function(n)
if n=0 then
return N;
fi;
return LGs[n];
end;
##
#############################################################
#############################################################
#2
BoundariesList:=function(n,k)
return LBs[n][k+1];
end;
##
#############################################################
#############################################################
#2
DegeneraciesList:=function(n,k)
if n=0 and k = 0 then
return GroupHomomorphismByFunction(N,LGs[1],
function(x) return x; end);
fi;
return LDs[n][k+1];
end;
##
#############################################################
return Objectify(HapSimplicialGroup,
rec(
groupsList:=GroupsList,
boundariesList:=BoundariesList,
degeneraciesList:=DegeneraciesList,
properties:=[["length",number]]
));
end;
##
############### end of NerveOfCatOneGroup_Obj ########################
######################################################################
#1
#F NerveOfCatOneGroup_Morpre
## Input: Nerve of G, nerve of H, map f:G-->H
## Output: simplicial map between nerve of G and nerve of H
##
NerveOfCatOneGroup_Morpre:=function(NG,NH,f,number)
local
GLs,GEmbOnes,GEmbTwos,GPros,HLs,HEmbOnes,HEmbTwos,HPros,
Gens,GensToLists,
i,j,n,m,g,pg,len,
Tmp,ImgGens,Maps,
HListToOne,Mapping;
GLs:=[];
GEmbOnes:=[];
GEmbTwos:=[];
GPros:=[];
HLs:=[];
HEmbOnes:=[];
HEmbTwos:=[];
HPros:=[];
Gens:=[];
GensToLists:=[];
for n in [2..number] do
GLs[n]:=NG!.groupsList(n);
GEmbOnes[n]:=Embedding(GLs[n],1);
GEmbTwos[n]:=Embedding(GLs[n],2);
GPros[n]:=Projection(GLs[n]);
HLs[n]:=NH!.groupsList(n);
HEmbOnes[n]:=Embedding(HLs[n],1);
HEmbTwos[n]:=Embedding(HLs[n],2);
HPros[n]:=Projection(HLs[n]);
Gens[n]:=GeneratorsOfGroup(GLs[n]);
len:=Length(Gens[n]);
GensToLists[n]:=List([1..len],x->[]);
for i in [1..len] do
g:=Gens[n][i];
Tmp:=[];
for j in [1..n-1] do
pg:=Image(GPros[n-j+1],g);
m:=PreImagesRepresentative(GEmbTwos[n-j+1],(Image(
GEmbOnes[n-j+1],pg))^(-1)*g);
Tmp[n-j+1]:=m;
g:=pg;
od;
Tmp[1]:=g;
GensToLists[n][i]:=Tmp;
od;
od;
#############################################################
#2
#F HListToOne
## Input: List [h_1,m_2,m_3,...,m_n]
## Output: The semi-product h_1 x| m_2 x| m_3 x| ... x| m_n
##
HListToOne:=function(Lm,n)
local i,m;
m:=Lm[1];
for i in [2..n] do
m:=Image(HEmbOnes[i],m)*Image(HEmbTwos[i],Lm[i]);
od;
return m;
end;
##
########## end of HListToOne ################################
Maps:=[];
for n in [2..number] do
len:=Length(Gens[n]);
ImgGens:=[];
for i in [1..len] do
ImgGens[i]:=HListToOne(List(GensToLists[n][i],m->Image(f,m)),n);
od;
Maps[n]:=GroupHomomorphismByImages(GLs[n],HLs[n],Gens[n],ImgGens);
od;
#############################################################
#2
Mapping:=function(n)
if n=0 then
return GroupHomomorphismByFunction(NG!.groupsList(0),
NH!.groupsList(0),function(x) return Image(f,x); end);
fi;
if n=1 then
return f;
fi;
return Maps[n];
end;
##
#############################################################
return Objectify(HapSimplicialGroupMorphism,
rec(
source:=NG,
target:=NH,
mapping:=Mapping,
properties:=[["length",number]]
));
end;
##
############### end of NerveOfCatOneGroup_Morpre #####################
######################################################################
#1
#F NerveOfCatOneGroup_Mor
## Input: Morphism of cat-1-groups
## Output: Simplicial map of their nerves
##
NerveOfCatOneGroup_Mor:=function(Cf,n)
local NG,NH,f;
NG:=NerveOfCatOneGroup_Obj(Cf!.source,n);
NH:=NerveOfCatOneGroup_Obj(Cf!.target,n);
f:=Cf!.mapping;
return NerveOfCatOneGroup_Morpre(NG,NH,f,n);
end;
##
############### end of NerveOfCatOneGroup_Mor ########################
######################################################################
#1
#F NerveOfCatOneGroup_Seq
## Input: Sequence of morphisms of cat1groups
## Output: Sequence of simplicial maps
NerveOfCatOneGroup_Seq:=function(Lf,n)
local len,i,NC,Res;
len:=Length(Lf);
NC:=[];
for i in [1..len] do
NC[i]:=NerveOfCatOneGroup_Obj(Lf[i]!.source,n);
od;
NC[len+1]:=NerveOfCatOneGroup_Obj(Lf[len]!.target,n);
Res:=[];
for i in [1..len] do
Res[i]:=NerveOfCatOneGroup_Morpre(NC[i],NC[i+1],Lf[i]!.mapping,n);
od;
return Res;
end;
##
############### end of NerveOfCatOneGroup_Seq ########################
if IsHapCatOneGroup(X) then
return NerveOfCatOneGroup_Obj(X,n);
fi;
if IsHapCatOneGroupMorphism(X) then
return NerveOfCatOneGroup_Mor(X,n);
fi;
if IsList(X) then
if IsEmpty(X) then
return [];
fi;
return NerveOfCatOneGroup_Seq(X,n);
fi;
end);
##
#################### end of NerveOfCatOneGroup ##############################