# The Nottingham group generator
# by
# Levente Levai
# Eotvos Lorand University, September 1996
# e-mail : levai@cs.elte.hu
#
# The functions defined in this file enables you to compute
# finite factors of the Nottingham groups over fields of
# prime order.
#
# This file contains two functions:
# - NormalForm : A subroutine
# - Nott : That's what you are intereseted in
#
# Usage :
# 'gap> g := Nott (level, prime);'
# After this line 'g' will be the finite factor of the
# Nottingham group over the prime field of characteristic
# 'prime' by the 'level'-th subgroup of its natural filtration
# that is 'g' will be Nott (prime) mod t^'level'.
#
# Some technical remarks:
# To construct the factor the algorithm first constructs a
# matrix representation of the Nottingham group on the
# vectorspace spanned by 1, t, t^2, ..., t^'level' over
# GF ('prime'). After this it computes the power-commutator
# presentation of the factor using the matrix representation.
# The generators of the pcp are in one-one correspondence
# to 1 + t, 1 + t^2, ..., 1 + t^('level' - 1). In the group
# record returned by 'Nott' you find the following extra
# fields:
# - name : It is the name of the group. Just for
# convinience.
# - field : GF ('prime')
# - fpgenerators : The abstract generators (they are in
# one-one correspondence with the
# AgGenerators of the resulting group).
# - relators : The relators of the pcp in the abstract
# generators.
# - matrices : The matrix representation (a list of
# 'level' by 'level' matricies over GF ('prime')
# the first element is the image of the first
# generator, the second element is the image
# of the second generator and so on.
# The function works reasonably fast (at the first call it seems
# to be slow because GAP reads in a lot of library functions).
#
# Your your suggestions, remarks and questions are welcomed.
# This function is used to compute the right hand side
# of a power or commutator relator
NormalForm := function (F, invmats, mat, Gr, n)
local i, mmat, word;
mmat := Copy (mat);
word := IdWord;
i := 2;
while i <= n do
if mmat[1][i] <> F.zero then
mmat := invmats[i - 1] * mmat;
word := word * Gr.generators[i - 1];
else
i := i + 1;
fi;
od;
return word;
end;
# This one does the trick
# The resulting group will be Nott ('p') mod t^'n'
Nott := function (n, p)
local f, F, g, gg, i, inverses, j, k, matrices, relators, root;
F := Field (Z(p));
root := F.root;
matrices := 0 * [1 .. n - 1];
for i in [1 .. n - 1] do
matrices[i] := 0 * [1 .. n];
for j in [1 .. n] do
matrices[i][j] := F.zero * [1 .. n];
for k in [1 .. n] do
if k >= j and i * Int ((k - j) / i) = k - j then
matrices[i][j][k] := (Binomial (j, (k - j) / i) mod p) * root ^ 0;
fi;
od;
od;
od;
inverses := List (matrices, x -> x^-1);
f := FreeGroup (n - 1);
relators := [ ];
for i in [1 .. n - 1] do
for j in [i + 1 .. n - 1] do
Add (relators, f.generators[j] ^ -1 * f.generators[i] ^ -1 *
f.generators[j] * f.generators[i] * NormalForm (F, inverses,
matrices[j] ^ -1 * matrices [i] ^ -1 * matrices[j] * matrices[i],
f, n) ^ -1);
od;
Add (relators, f.generators[i] ^ p *
NormalForm (F, inverses, matrices[i] ^ p, f, n) ^ -1);
od;
g := f / relators;
gg := AgGroupFpGroup (g);
gg.name := ConcatenationString ("Nott (", String (n), ", ", String (p), ")");
gg.matrices := matrices;
gg.field := F;
gg.fpgenerators := f.generators;
gg.relators := relators;
return gg;
end;