# [GAP Forum] New features for the Polycyclic package ;

carcher at ulb.ac.be carcher at ulb.ac.be
Tue Apr 6 13:24:36 BST 2004

```

I have some question about the very nice Polycyclic Package of Bettina and Werner.
First of all, thank you for the package.

Here are my questions

1) how are cocycle components ordered for Pcp groups ?
For finite pc group there is a line in file

in /lib/twocohom.gi
##  The tail of  a conjugate  i^j  (i>j) or a   power i^p (i=j) is  stored at
##  posiition (i^2-i)/2+j

that gives the solution.

Unfortunately i haven't found such a line in the code of the polycyclic package.

2)
I would like to compute the second cohomology groups Z2(G,A) and B2(G,A) of an arbitrary finitely generated
abelian group A. In the gap library, this is only possible if A is elementary abelian and
G is polycyclic. Are there any plan to do it for arbitrary A and G polycyclic ?
And for G a non polycyclic permutation group ?

Derek Holt has implemented in Magma a method for A arbitrary and i think that
further developments of your Polycyclic package is the solution to implement it in GAP.
The idea is to write the module action on A by integer matrices and to add linear equations
to the linear system needed to compute the cocycle. This new equations specify that some
coefficients of the system have to be interpreted modulo an integer.

i have tried to do the job by myself first by modifyng the equations of the linear system.
In attachement you can find a modify version of the function TwoCocyclesCR.
--> see attachement TwoCocyclesCRbis:=function( A, invarlist )

3) Is there some plan to provide automorphisms group of Pcp group ?

4) Another nice posibility of the polycyclic package is to use non prime pcgs.
But, if for a given pcp group G one wants to construct G one a non prime pcgs there is no function
to do so without refining it into a prime pcgs.

A nice application of non prime pcgs is the ability to reduce the number of unknowns
in the linear system to determine cocycle

Thank you very much for your help

Claude
-------------- next part --------------

#############################################################################
##
#F TwoCocyclesCRbis( A, invarlist )

### Twococyles for a finitely generated abelian group,
## described as a product of the cyclic group invarlist[i]

##InstallGlobalFunction( TwoCocyclesCRbis, function( A , invarlist  )

TwoCocyclesCRbis:=function( A, invarlist )
local C, n, e, id, l, gn, gp, gi, eq, pairs, i, j, k, w1, w2, d, sys, h,
### new variables for the new code (arbitrary finitely generated abelian group)
m,standardvect,fullkernel,ll;

# set up system of length d
n := Length( A.mats );
e := RelativeOrdersOfPcp( A.factor );
l := Length( A.enumrels );
d := A.dim;
sys := CRSystem( d, l, A.char );

# set up for equations
id := IdentityMat(n);
gn := List( id, x -> rec( word := x, tail := [] ) );

# precompute (ij) for i > j
pairs := List( [1..n], x -> [] );
for i  in [1..n]  do
if e[i] > 0 then
h := rec( word := (e[i] - 1) * id[i], tail := [] );
pairs[i][i] := CollectedTwoCR( A, h, gn[i] );
fi;
for j  in [1..i-1]  do
pairs[i][j] := CollectedTwoCR( A, gn[i], gn[j] );
od;
od;

# consistency 1:  k(ji) = (kj)i
for i  in [ n, n-1 .. 1 ]  do
for j  in [ n, n-1 .. i+1 ]  do
for k  in [ n, n-1 .. j+1 ]  do
w1 := CollectedTwoCR( A, gn[k], pairs[j][i] );
w2 := CollectedTwoCR( A, pairs[k][j], gn[i] );
if w1.word <> w2.word  then
Error( "k(ji) <> (kj)i" );
else
AddEquationsCR( sys, w1.tail, w2.tail, true );
fi;
od;
od;
od;

# consistency 2: j^(p-1) (ji) = j^p i
for i  in [n,n-1..1]  do
for j  in [n,n-1..i+1]  do
if e[j] > 0 then
h := rec( word := (e[j] - 1) * id[j], tail := [] );
w1 := CollectedTwoCR( A, h, pairs[j][i]);
w2 := CollectedTwoCR( A, pairs[j][j], gn[i]);
if w1.word <> w2.word  then
Error( "j^(p-1) (ji) <> j^p i" );
else
AddEquationsCR( sys, w1.tail, w2.tail, true );
fi;
fi;
od;
od;

# consistency 3: k (i i^(p-1)) = (ki) i^p-1
for i  in [n,n-1..1]  do
if e[i] > 0 then
h := rec( word := (e[i] - 1) * id[i], tail := [] );
l := CollectedTwoCR( A, gn[i], h );
for k  in [n,n-1..i+1]  do
w1 := CollectedTwoCR( A, gn[k], l );
w2 := CollectedTwoCR( A, pairs[k][i], h );
if w1.word <> w2.word  then
Error( "k i^p <> (ki) i^(p-1)" );
else
AddEquationsCR( sys, w1.tail, w2.tail, true );
fi;
od;
fi;
od;

# consistency 4: (i i^(p-1)) i = i (i^(p-1) i)
for i  in [ n, n-1 .. 1 ]  do
if e[i] > 0 then
h := rec( word := (e[i] - 1) * id[i], tail := [] );
l := CollectedTwoCR( A, gn[i], h );
w1 := CollectedTwoCR( A, l, gn[i] );
w2 := CollectedTwoCR( A, gn[i], pairs[i][i] );
if w1.word <> w2.word  then
Error( "i i^p-1 <> i^p" );
else
AddEquationsCR( sys, w1.tail, w2.tail, true );
fi;
fi;
od;

# consistency 5: j = (j -i) i
gi := List( id, x -> rec( word := -x, tail := [] ) );
for i  in [n,n-1..1]  do
for j  in [n,n-1..i+1]  do
#if e[i] = 0 then
w1 := CollectedTwoCR( A, gn[j], gi[i] );
w2 := CollectedTwoCR( A, w1, gn[i] );
if w2.word <> id[j] then
Error( "j <> (j -i) i" );
else
AddEquationsCR( sys, w2.tail, [], true );
fi;
#fi;
od;
od;

# consistency 6: i = -j (j i)
for i  in [n,n-1..1]  do
for j  in [n,n-1..i+1]  do
if e[j] = 0 then
w1 := CollectedTwoCR( A, gi[j], pairs[j][i] );
if w1.word <> id[i] then
Error( "i <> -j (j i)" );
else
AddEquationsCR( sys, w1.tail, [], true );
fi;
fi;
od;
od;

# consistency 7: -i = -j (j -i)
for i  in [n,n-1..1]  do
for j  in [n,n-1..i+1]  do
if e[i] = 0 and e[j] = 0 then
w1 := CollectedTwoCR( A, gn[j], gi[i] );
w1 := CollectedTwoCR( A, gi[j], w1 );
if w1.word <> -id[i] then
Error( "-i <> -j (j -i)" );
else
AddEquationsCR( sys, w1.tail, [], true );
fi;
fi;
od;
od;

# add a check ((j ^ i) ^-i ) = j
for i in [1..n] do
for j in [1..i-1] do
w1 := CollectedTwoCR( A, gi[j], pairs[i][j] );
w1 := CollectedTwoCR( A, gn[j], w1 );
w1 := CollectedTwoCR( A, w1, gi[j] );
if w1.word <> id[i] then
Error("in rel check ");
elif not IsZeroTail( w2.tail ) then
# Error("relations bug");
AddEquationsCR( sys, w1.tail, [], true );
fi;
od;
od;
###########################################
######### new code for arbitrary abelian group

m:=Length(sys.base)/d;

# Now, we add d*m new unknowns y[k] as follows :
# since  equation k=j*d+i evaluates to 0 (mod invarlist[i]), a multiple of invarlist[i],
# we add the multiple y[k]*invarlist[i] to equation[k]

for i in [1..d] do
for j in [0..m-1] do
standardvect:=List([1..d*m],x->0);
standardvect[j*d+i]:=invarlist[i];
Append( sys.base[j*d+i],standardvect);
od;
od;

fullkernel:=KernelCR( A, sys ).basis;

### Now, we get rid off the d*m auxilliary unknowns we added
### we want the projection of the null space NS on the l*d original coordinates
## If the solutions in {B} form a basis for NS then proj({B}) generates proj(NS).
## Moreover the  component [j*d+i] of a vector in proj({B}) may be reduced mod invarlist[i]

## improvement ? : the coefficients of fullkernel can be very large  so we should have a
## way to reduce them during the calculation of KernelCR( A, sys ).basis;

## if we want to preserve the type of fullkernel

ll:=Length(A.enumrels);
# l has changed, why ? so we rename it

for k in [1..Length(fullkernel)] do
fullkernel[k]:=fullkernel[k]{[1..ll*d]};
for i in [1..d] do
for j in [0..ll-1] do
fullkernel[k][j*d+i]:=fullkernel[k][j*d+i] mod invarlist[i];
od;
od;
od;

# and return solution
return Set(fullkernel);
## after the modulo reduction, many zero vectors appear
end ;

#############################################################################
```