Dear Marek,
Parker loops are so called code loops. Any doubly even binary code gives
rise to such a loop. If you start with the extended binary Golay code
then you obtain the Parker code.
However, as you noticed the construction of the loop from the code is by
far nontrivial.
Code loops are Moufang loops, which can be equivalently given by a group
theoretical data called "groups with triality". In my paper
G. P. Nagy. Direct construction of code loops. Discrete Mathematics 308
(2008), 5349-5357.
(arXiv:math/0411315v2)
I gave a rather straighforward construction of the group with triality
starting from the code. You find the GAP implementation below.
I also have a GAP program which constructs the loop itself from the
group with triality. Unfortunately, the machines I have access to have
too small memory to deal with (the multiplication tables) of loops of
order 8192.
Concerning the extraspecial group of order 2^25: As I do not know the
precise construction, I am not quite sure if this is it. However, from
loop theoretical point of view, it is quite natural to look at a certain
subgroup of the group G with triality:
gap> LoadPackage("guava");
true
gap> LoadPackage("loops");
true
gap>
gap> C:=ExtendedBinaryGolayCode();
a linear [24,12,8]4 extended binary Golay code over GF(2)
gap> tg:=DoublyEvenBinaryCodesToTrialityGroup(C);
rec( group := <pc group with 38 generators>, sigma := f1, rho := f2 )
gap>
gap> sigma_class:=Elements( ConjugacyClass( tg.group, tg.sigma ) );;
gap> eg:=Subgroup(tg.group,sigma_class/tg.sigma);
<pc group with 8192 generators>
gap>
gap> StringPP(Size(eg));
"2^25"
gap> Size(FrattiniSubgroup(eg));
2
gap> Size(Center(eg));
8
I hope this helps.
Bye,
Gabor
======================================
#############################################################
# Construction of groups with triality and Moufang loops
# input: Doubly even binary code
# output: group with triality (G,\sigma,\rho)
# (as record, G as polycyclic group)
DoublyEvenBinaryCodesToTrialityGroup := function( code )
local i, j, c,
b, n, 1form, 2form, 3form,
F, coll, gr;
# 1-, 2- and 3-forms corresponding to the code
b:=List(Elements(Basis(C)),Support);
n:=Length(b);
1form:=0*Z(2)*[1..n];;
2form:=List( [1..n], i -> 0*Z(2)*[1..n] );;
3form:=List( [1..n], i -> List( [1..n], j -> 0*Z(2)*[1..n] ) );;
for i in [1..n] do
1form[i] := (Size(b[i])/4)*Z(2);
od;
for i in Combinations( [1..n ], 2 ) do
2form[i[1]][i[2]] := (Size(Intersection(b{i}))/2)*Z(2);
2form[i[2]][i[1]] := (Size(Intersection(b{i}))/2)*Z(2);
od;
for i in Combinations( [1..n ], 3 ) do
for j in PermutationsList( i ) do
3form[j[1]][j[2]][j[3]] := Size(Intersection(b{i}))*Z(2);
od;
od;
# free group initialization
F := FreeGroup( IsSyllableWordsFamily, 3*n+4 );
coll := SingleCollector( F, Concatenation(
[2,3], List([1..3*n+2],i->2)
)
);
# power relations for the underlying group
for i in [1..n] do
SetPower( coll, i+2, F.(3*n+3)^IntFFE( 1form[i] ) );
SetPower( coll, n+i+2, F.(3*n+4)^IntFFE( 1form[i] ) );
od;
# commutators of 1st kind for the underlying group
for i in [1..n-1] do
for j in [i+1..n] do
SetCommutator( coll, j+2, i+2, F.(3*n+3)^IntFFE(
2form[j][i] ) );
SetCommutator( coll, n+j+2, n+i+2, F.(3*n+4)^IntFFE(
2form[j][i] ) );
od;
od;
# commutators of 2st kind for the underlying group
for i in [1..n] do
for j in [1..n] do
c := Product( List( [1..n], k ->
F.(2*n+k+2)^IntFFE( 3form[j][i][k] )
)
)
*
(F.(3*n+3) * F.(3*n+4))^IntFFE( 2form[i][j] );
SetCommutator( coll, n+j+2, i+2, c );
SetCommutator( coll, n+i+2, j+2, c );
od;
od;
# commutators of 3rd kind for the underlying group
for i in [1..n] do
SetCommutator( coll, 2*n+i+2, i+2, F.(3*n+3) );
SetCommutator( coll, 2*n+i+2, n+i+2, F.(3*n+4) );
od;
# relations for sigma and rho
SetConjugate( coll, 2, 1, F.2^2 );
for i in [1..n] do
# sigma
SetConjugate( coll, i+2, 1, F.(n+i+2) );
SetConjugate( coll, n+i+2, 1, F.(i+2) );
# rho
SetConjugate( coll, i+2, 2, F.(n+i+2) );
SetConjugate( coll, n+i+2, 2, (F.(i+2)*F.(n+i+2))^-1 );
od;
# action on the center
SetConjugate( coll, 3*n+3, 1, F.(3*n+4) );
SetConjugate( coll, 3*n+4, 1, F.(3*n+3) );
SetConjugate( coll, 3*n+3, 2, F.(3*n+4) );
SetConjugate( coll, 3*n+4, 2, F.(3*n+3)*F.(3*n+4) );
# constructing the group
gr := GroupByRws( coll );
# done
return rec(
group := Group( GeneratorsOfGroup( gr ){[3..3*n+4]} ),
sigma := gr.1,
rho := gr.2
);
end;
# input: Group with triality (G,\sigma,\rho) (as record, G as polycyclic
group)
# output: Code loop
TrialityGroupToLoop_verbose := function( tr )
local c1, N, ccl, ct, i, s1;
c1 := Centralizer( tr.group, tr.sigma );
N := Index( tr.group, c1 );
Print("# The order of the loop = ",N,"\n");
if N <> Index( c1, Intersection(c1,c1^tr.rho) ) then
Error( "This is no group with triality!" );
fi;
ccl := Elements( ConjugacyClass( tr.group, tr.sigma ) );
ct:=[];
i:=1;
for s1 in ccl do
Print("# pos: ",i,"/",N,"\n");
Add(ct,List( ccl, s2 -> Position( ccl, s1^tr.rho *
s2^(tr.rho^2) * s1^tr.rho ) ) );
i:=i+1;
od;
return LoopByCayleyTable( NormalizedQuasigroupTable( ct ) );
end;
2011-12-02 11:52 keltezéssel, Marek Mitros írta:
Hi All,
I am reading Conway "simple construction of monster" and I wonder whether
anybody has Parker loop defined for GAP. I would like to play around with
it to understand more how multiplication there looks like.
For example when I have two octads o1, o2 intersecting in four points then
let o3 be XOR(o1,o2). Then I assume that in Parker loop o1.o2=o3, o2.o3=o1,
etc and all these products commutes.
When I have octads o1,o2 intersecting in two points then d1=XOR(o1,o2) is
dodecad. In such case I do not know whether o1.o2=d1 or o1.o2=-d1 (minus).
In such case product o1.o2 anticommute.
The next question I have is how to generate extraspecial group of size 2^25
called Q_x1 in the paper. It is generated by elements x_d and x_delta.
Regards,
Marek
_______________________________________________
Forum mailing list
Forum@mail.gap-system.org
http://mail.gap-system.org/mailman/listinfo/forum
_______________________________________________
Forum mailing list
Forum@mail.gap-system.org
http://mail.gap-system.org/mailman/listinfo/forum
