G-CW quotients

Author: grahamknockillaree

lib/Congruence/GCWquotient.gi

@@ -0,0 +1,101 @@
+
+#####################################################################
+#####################################################################
+InstallGlobalFunction(GComplexToRegularCWComplex,
+function(R,N)
+local Y, dim, dim1, Cells,boundaries, StandardForm, 
+Tiles, tile, pos,NeighbourGens,TileReps,
+w,NewLeaves,Leaves,i,e,f,n,k,g,b,x,T;
+#R is a contractible G-complex
+#S is a set of elements in G=R!.group
+#N is a finite index subgroup of G=R!.group
+
+T:=RightTransversal(R!.group,N);
+
+#######################################################
+dim:=0;
+for n in [1..Length(R)] do
+if R!.dimension(n)>0 then dim:=dim+1;
+else break; fi;
+od;
+dim1:=dim-1;
+#######################################################
+
+########################################
+StandardForm:=function(n,x)
+local e,g,gc,stab;
+
+e:=AbsInt(x[1]);
+g:=x[2];
+stab:=R!.stabilizer(n,e);
+gc:=g*Elements(stab);
+gc:=List(gc, a->T[T!.poscan(a)]);
+#gc:=SSortedList(gc);
+#gc:=gc[1];
+gc:=Minimum(gc);
+return [e,gc];
+end;
+########################################
+
+
+Tiles:=[];
+for k in [1..R!.dimension(dim)] do
+   tile:=1*R!.boundary(dim,k);
+   Apply(tile,x->[x[1],R!.elts[x[2]]]);
+   Apply(tile,e->StandardForm(dim1,e));
+   Add(Tiles,tile);
+od;
+
+
+TileReps:=List([1..Length(Tiles)],i->T);
+##################################################################
+##################################################################
+
+########################################
+########################################
+
+Cells:=List([1..dim+1],i->[]);
+## Cells[k+1] is a list of the k-cells present in the complex
+
+for k in [1..R!.dimension(dim)] do
+for g in TileReps[k] do
+Add(Cells[dim+1],StandardForm(dim,[k,g]));
+od;
+od;
+Cells[dim+1]:=SSortedList(Cells[dim+1]);
+
+for n in Reversed([1..dim]) do
+for x in Cells[n+1] do
+b:=1*R!.boundary(n,x[1]);
+Apply(b,z->[z[1],R!.elts[z[2]]]);
+Apply(b,y->[y[1],x[2]*y[2]]);
+Apply(b,y->StandardForm(n-1,y));
+Append(Cells[n],b);
+od;
+Cells[n]:=SSortedList(Cells[n]);
+od;
+
+
+boundaries:=List([1..dim+2], n->[]);
+boundaries[1]:=List(Cells[1],x->[1,0]);
+
+for n in [1..dim] do
+for k in [1..Length(Cells[n+1])] do
+x:=Cells[n+1][k];
+b:=1*R!.boundary(n,x[1]);
+Apply(b,z->[z[1],R!.elts[z[2]]]);
+Apply(b,y->[y[1],x[2]*y[2]]);
+Apply(b,y->StandardForm(n-1,y));
+Apply(b,c->PositionSorted(Cells[n],c));
+b:=Concatenation([Length(b)],b);
+boundaries[n+1][k]:=b;
+od;
+od;
+
+Y:=RegularCWComplex(boundaries);
+
+return Y;
+end);
+#####################################################################
+#####################################################################
+

lib/Congruence/bianchiComplex.gi

@@ -339,7 +339,7 @@ end;
 InstallGlobalFunction(BianchiGcomplex,
 function(d)
 local R,P,OQ,Y,Dimension,Stabilizer,action,STABS,stb,rot,rotREC,Boundary,
-rep,ELTS,adjust,xx,I,
+rep,ELTS,adjust,xx,I,H,
 G,K,S,T,i,V,n,B,BB,k,BoundaryRec,TMP, EquivSpheres, gens,omega,x,y,M,a;
 
 if not IsInt(d) then
@@ -392,7 +392,7 @@ G:=HAP_BianchiRepresentativesAction(Y,n,i,i);
    od;
    Add(GENS,-One(GENS[1]));
    ###################################
-STABS[1][i]:= Group(GENS); STABS[1][i]!.Order:=infinity; STABS[1][i]!.Size:=infinity;
+STABS[1][i]:= Group(GENS); STABS[1][i]!.Order:=infinity; STABS[1][i]!.Size:=infinity; SetIsFinite(STABS[1][i],false); IsBianchiAbelianGroup(STABS[1][i]);
 return infinity; fi;
 G:=HAP_BianchiRepresentativesAction(Y,n,i,i);
 
@@ -710,13 +710,22 @@ G!.tree:=true;
 SetGeneratorsOfGroup(G,gens);
 SetSize(G,infinity);
 SetOrder(G,infinity);
+
+H:=RingOfIntegers(QuadraticNumberField(d));;
+H:=QuadraticIdeal(H,1);;
+H:=HAP_CongruenceSubgroupGamma0(H);;
+H!.tree:=true;;
+H:=GroupHomomorphismByFunction(G,H,QuadraticNumberToCyclotomic);
+
+
 R:= Objectify(HapNonFreeResolution,
             rec(
             dimension:=Dimension,
             boundary:=Boundary,
             homotopy:=fail,
             elts:=ELTS,
             group:=G,
+            isomorphismToGroupCyclotomicMats:=H,
             stabilizer:=Stabilizer,
             action:=action,
             ring:=Y!.ring,

lib/Congruence/quadArithmetic.gi

@@ -14,6 +14,39 @@ end);
 #####################################################################
 #####################################################################
 
+#####################################################################
+#####################################################################
+InstallMethod(QuadraticNumberToCyclotomic,
+  "converts a quadratic number to a cyclotomic",
+    [IsHapQuadraticNumber],
+    function( x )
+    return x!.rational + Sqrt(x!.bianchiInteger)*x!.irrational;
+end);
+#####################################################################
+#####################################################################
+
+#####################################################################
+#####################################################################
+InstallOtherMethod(QuadraticNumberToCyclotomic,
+  "converts a List of quadratic numbers to a List of cyclotomics",
+    [IsList],
+    function( L )
+    return List(L,QuadraticNumberToCyclotomic);;
+end);
+#####################################################################
+#####################################################################
+
+#####################################################################
+#####################################################################
+InstallOtherMethod(QuadraticNumberToCyclotomic,
+  "converts a Matrix of quadratic numbers to a Matrix of cyclotomics",
+    [IsMatrix],
+    function( M )
+    return List(M,QuadraticNumberToCyclotomic);;
+end);
+#####################################################################
+#####################################################################
+
 #####################################################################
 #####################################################################
 InstallGlobalFunction (QuadraticNumberConjugate,
@@ -161,6 +194,7 @@ local M, gens, G, g, x, gx, bool, i, j;
 if IsBound(GG!.MultiplicationTable) then return GG!.MultiplicationTable; fi;
 
 gens:=GeneratorsOfGroup(GG);
+if Length(gens)=0 then gens:=[One(GG)]; fi;
 G:=[gens[1]^0];
 bool:=true;
 

lib/Congruence/quadraticIntegers.gd

@@ -17,6 +17,8 @@ DeclareGlobalFunction( "QuadraticNumber" );
 DeclareGlobalFunction( "IsHapQuadraticInteger" );
 DeclareGlobalFunction("BianchiGcomplex");
 DeclareGlobalFunction("HAP_InverseOpFunction");
+DeclareGlobalFunction("GComplexToRegularCWComplex");
+DeclareGlobalFunction("ResolutionIsomorphismGroup");
 
 #####################################################################
 #####################################################################
@@ -219,4 +221,4 @@ Display3DUnimodularPairs(Y!.ring,Y!.unimodularPairsSingletons,lst);
 #####################################################################
 
 
-
+DeclareOperation("QuadraticNumberToCyclotomic",[IsHapQuadraticNumber]);

lib/Congruence/quadraticIntegers.gi

@@ -516,6 +516,16 @@ return  [[one,zero],[zero,one]];
 end);
 #####################################################################
 
+######################################################################
+InstallOtherMethod( OneMutable,
+    "one mutable in 2x2 matrix group",
+    [ IsHap2x2matrix],
+100000000,
+function(M)
+return  1*One(M);
+end);
+#####################################################################
+
 #####################################################################
 InstallOtherMethod( InverseMutable,
     "inverse in 2x2 matrix group",

lib/Congruence/resIsomorphicGroup.gi

@@ -0,0 +1,114 @@
+
+##############################################################
+##############################################################
+InstallGlobalFunction(ResolutionIsomorphismGroup,
+function(arg)
+local K,hom,fn,G,HH, STAB, ROT, n, k, ln, x,g;
+#Inputs a (possibly non-free) resolution K for G and isomorphism hom:G->H.
+#Destructively converts K to a resolution for H.
+
+K:=arg[1]; hom:=arg[2];
+
+if Length(arg)=2 then
+   fn:=function(x) return ImageElm(hom,x); end;
+   HH:=Range(hom);
+else
+   fn:=hom;
+   HH:=arg[3];
+fi;
+
+##################################
+
+
+if IsHapResolution(K) then
+   K!.group:=Range(hom);
+   if IsMutable(K!.elts) then
+      Apply(K!.elts,fn);
+   else
+      K!.elts:=List(K!.elts,fn);
+   fi;
+   return true;
+fi;
+
+
+#################################
+
+#################################
+K!.group:=HH;
+
+ln:=0;  #The dimension of the complex
+for n in [1..100] do
+if K!.dimension(n)=0 then break; fi;
+ln:=ln+1;
+od;
+
+STAB:=[];
+ROT:=[];
+   for n in [0..ln] do
+   STAB[n+1]:=[];
+   ROT[n+1]:=[];
+      for k in [1..K!.dimension(n)] do
+if n>0 then
+      x:=Elements(K!.stabilizer(n,k));
+      for g in x do
+          if not g in K!.elts then Add(K!.elts,g); fi;
+      od;
+      x:=Filtered(x,g->K!.action(n,k,Position(K!.elts,g))=1);
+      x:=List(x,fn);
+      x:=Group(x);
+      Add(ROT[n+1],x);
+fi;
+      x:=GeneratorsOfGroup(K!.stabilizer(n,k));
+      x:=List(x,fn);
+      x:=Group(x);
+      Add(STAB[n+1],x);
+   od;
+od;
+
+##############################
+K!.stabilizer:=function(n,k);
+    return STAB[n+1][k];
+end;
+##############################
+
+   if IsMutable(K!.elts) then
+      Apply(K!.elts,fn);
+   else
+      K!.elts:=List(K!.elts,fn);
+   fi;
+
+
+##############################
+K!.action:=function ( n, k, g )
+    local id, r, u, ans, abk, H;
+    if n = 0 then
+        return 1;
+    fi;
+    abk := AbsInt( k );
+    H := K!.stabilizer( n, abk );
+    if Order( H ) = infinity then
+        return 1;
+    fi;
+    id := CanonicalRightCosetElement( H, Identity( H ) );
+    r := CanonicalRightCosetElement( H, K!.elts[g] ^ -1 );
+    r := id ^ -1 * r;
+    u := r * K!.elts[g];
+    if u in ROT[n+1][abk] then
+        ans := 1;
+    else
+        ans := -1;
+    fi;
+    return ans;
+end;
+
+##############################
+
+
+return true;
+#################################
+
+
+end);
+##############################################################
+##############################################################
+

lib/Congruence/sl2o.gi

@@ -435,7 +435,8 @@ else
    local p;
    p:=x[2]*one; 
    if IsZero(p[2]) then return zero; fi;
-   p:=p*(p[2]^-1); return Position(Psorted,[p[1]![1],p[2]![1]]);
+   p:=p*(p[2]^-1); 
+   return PositionSorted(Psorted,[p[1]![1],p[2]![1]]);
    end;
    ##########################################
 fi;

lib/Functors/various.gi

@@ -480,7 +480,7 @@ local x, h;
 
 if IsFinite(U) or IsBound(U!.gname)
 then return CanonicalRightCosetElement(U,g); fi;
-
+#IsHap2x2matrix(g); IsBianchiAbelianGroup(U);
 if g in U then return One(U); fi;
 
 if not IsBound(U!.ccelts) then U!.ccelts:=[]; fi;

read.g

@@ -233,6 +233,8 @@ ReadPackageHap( "lib/Congruence/bianchiComplex.gi");
 ReadPackageHap( "lib/Congruence/resAbelianBianchiSubgroup.gi");
 ReadPackageHap( "lib/Congruence/qnf_nc.gi");
 ReadPackageHap( "lib/Congruence/notused.gi");
+ReadPackageHap( "lib/Congruence/resIsomorphicGroup.gi");
+ReadPackageHap( "lib/Congruence/GCWquotient.gi");
 
 ##################### ORRU #####################################
 ReadPackageHap( "lib/Orru/initOrru.gi");