Construction of Co3 in GAP 4

The following listing gives the same example in GAP 4. (This has been done using the development version, so it won't yet work with 4b5 but only with later versions.) Probably it is of help or interest to see how both versions differ.
gap> x:=Indeterminate(GF(2));
x_1
gap> SetName(x,"x");
gap> f:=x^23-1;
x^0+x^23
gap> Factors(f);
[ x^0+x, x^0+x+x^5+x^6+x^7+x^9+x^11, x^0+x^2+x^4+x^5+x^6+x^10+x^11 ]
gap> f:=First(Factors(f),i->Degree(i)>1);
x^0+x+x^5+x^6+x^7+x^9+x^11
gap> RequirePackage("guava");

   ____                          |
  /            \           /   --+--  Version 1.4
 /      |    | |\\        //|    |
|    _  |    | | \\      // |     Jasper Cramwinckel
|     \ |    | |--\\    //--|     Erik Roijackers
 \     ||    | |   \\  //   |     Reinald Baart
  \___/  \___/ |    \\//    |     Eric Minkes
                                  Lea Ruscio
true
gap> cod:=GeneratorPolCode(f,23,GF(2));
a cyclic [23,12,1..7]3 code defined by generator polynomial over GF(2)
gap> IsPerfectCode(cod);
true
gap> ext:=ExtendedCode(cod);
a linear [24,12,8]4 extended code
gap> WeightDistribution(ext);
[ 1, 0, 0, 0, 0, 0, 0, 0, 759, 0, 0, 0, 2576, 0, 0, 0, 759, 0, 0, 0, 0, 0, 0, 
  0, 1 ]
GAP 4 displays groups differently (the View operation, otherwise things are pretty similar.
gap> m24:=AutomorphismGroup(ext);
< permutation group of size 244823040 with 11 generators>
gap> SetName(m24,"m24");
gap> Size(m24);
244823040
gap> Transitivity(m24,[1..24]);
5
gap> m22a:=Stabilizer(m24,[23,24],OnSets);
< permutation group with 9 generators>
gap> Size(m22a);
887040
gap> m22a:=Operation(m22a,[1..22]);
< permutation group with 9 generators>
gap> SetName(m22a,"m22a");
gap> Size(m22a);
887040
gap> s:=SylowSubgroup(m22a,2);;
Conversion into other representations now is done via explicit isomorphisms. (Note that they go the other way than a.bijection in GAP 3.)
gap> pciso:=IsomorphismPcGroup(s);
Pcgs([ ( 4, 6)( 5,15)( 7,14)( 8,20)(10,16)(11,22)(13,17)(18,19), 
  ( 1, 2)( 5,16)( 7,14)( 8,11)(10,15)(13,17)(20,22), 
  ( 6,19)( 7, 8)( 9,12)(10,15)(11,14)(13,20)(17,22), 
  ( 4,18)( 5,16)( 7,22)( 8,17)( 9,12)(11,13)(14,20), 
  ( 3, 8)( 4, 7)( 6,13)( 9,20)(11,21)(12,22)(14,18)(17,19), 
  ( 3, 6)( 4,12)( 7,22)( 8,13)( 9,18)(11,17)(14,20)(19,21), 
  ( 3, 4)( 6,12)( 7, 8)( 9,19)(11,14)(13,22)(17,20)(18,21), 
  ( 3,21)( 4,18)( 6,19)( 7,14)( 8,11)( 9,12)(13,17)(20,22) ]) -> 
[ f1, f2, f3, f4, f5, f6, f7, f8 ]
gap> a:=Image(pciso);

gap> n:=Filtered(NormalSubgroups(a),i->Size(i)=16
> and IsElementaryAbelian(i));
[ Group([ f1*f2, f3*f4, f6*f7, f8 ]), Group([ f2, f3*f4, f6*f7, f8 ]), 
  Group([ f1, f3*f4, f6*f7, f8 ]), Group([ f5, f6, f7, f8 ]), 
  Group([ f2, f6, f7, f8 ]) ]
gap> n:=List(n,i->PreImage(pciso,i));;
gap> e:=Filtered(n,i->IsRegular(i,MovedPoints(i)));;Length(e);
1
gap> e:=e[1];;
gap> h:=Normalizer(m22a,e);;
Similarly operations now should be created via the operation homomorphism, the operation group is simply the image.
gap> ophom:=OperationHomomorphism(m22a,RightCosets(m22a,h),OnRight);;
gap> mop:=Image(ophom);
< permutation group with 9 generators>
gap> DegreeOperation(mop);
77
gap> dp:=DirectProduct(m22a,mop);;
For embedding into a direct product the number of the component is sufficient (it already determines the group which gets embedded).
gap> emb1:=Embedding(dp,1);;
gap> emb2:=Embedding(dp,2);;
gap> diag:=List(GeneratorsOfGroup(m22a),
> i->Image(emb1,i)*Image(emb2,Image(ophom,i)));;
gap> diag:=Group(diag,());;
gap> SetName(diag,"M22.2-99");
gap> RequirePackage("grape");

Loading  GRAPE 4.0  (GRaph Algorithms using PErmutation groups),
by L.H.Soicher@qmw.ac.uk.

true
gap> gamma:=NullGraph(diag,100);
rec( isGraph := true, order := 100, group := M22.2-99, 
  schreierVector := [ -1, 8, 2, 1, 3, 4, 6, 9, 3, 7, 8, 3, 2, 7, 4, 7, 5, 4, 
      8, 3, 7, 8, -2, 2, 5, 5, 4, 7, 6, 2, 5, 9, 1, 7, 6, 7, 9, 7, 1, 9, 2, 
      5, 9, 6, 8, 8, 7, 6, 8, 8, 8, 8, 8, 8, 8, 6, 8, 8, 8, 5, 1, 1, 8, 9, 7, 
      3, 7, 8, 7, 7, 9, 7, 5, 4, 1, 5, 1, 5, 1, 1, 7, 8, 2, 5, 7, 3, 8, 6, 5, 
      4, 9, 7, 5, 2, 3, 4, 2, 5, 5, -3 ], adjacencies := [ [  ], [  ], [  ] ],
  representatives := [ 1, 23, 100 ], isSimple := true )
gap> AddEdgeOrbit(gamma,[1,100]);AddEdgeOrbit(gamma,[100,1]);
gap> hexad:=First(Orbits(h,[1..22]),i->Length(i)=6);
[ 1, 16, 15, 5, 2, 10 ]
gap> for i in hexad do AddEdgeOrbit(gamma,[i,23]);
> AddEdgeOrbit(gamma,[23,i]); od;
gap> Adjacency(gamma,23);
[ 1, 2, 5, 10, 15, 16 ]
gap> stab:=Stabilizer(diag,23);;
gap> orbs:=Orbits(stab,[24..99]);;
gap> orbreps:=List(orbs,i->i[1]);
[ 24, 60 ]
gap> Intersection(hexad,Adjacency(gamma,24));
[ 1, 2 ]
gap> Intersection(hexad,Adjacency(gamma,60));
[  ]
gap> AddEdgeOrbit(gamma,[23,60]);AddEdgeOrbit(gamma,[60,23]);
gap> IsSimpleGraph(gamma);
true
gap> Adjacency(gamma,23);
[ 1, 2, 5, 10, 15, 16, 60, 62, 66, 67, 68, 69, 75, 77, 78, 79, 87, 90, 91, 
  93, 97, 99 ]
gap> IsDistanceRegular(gamma);
true
gap> aug:=AutGroupGraph(gamma);
< permutation group with 11 generators>
gap>  Size(aug);
88704000
gap> DisplayCompositionSeries(aug);
Group
 | Z(2)
Group
 | HS
Group
gap> hs:=DerivedSubgroup(aug);
< permutation group of size 44352000 with 3 generators>
CharTable now is called CharacterTable and the record components are accessed via attributes -- besides this we do exactly the same.
gap> ct:=CharacterTable("U3(5)");ct2:=CharacterTable("U3(5).2");
CharacterTable( "U3(5)" )
CharacterTable( "U3(5).2" )
gap> cths:=CharacterTable("hs");
CharacterTable( "HS" )
gap> OrdersClassRepresentatives(ct);OrdersClassRepresentatives(ct2);
[ 1, 2, 3, 4, 5, 5, 5, 5, 6, 7, 7, 8, 8, 10 ]
[ 1, 2, 3, 4, 5, 5, 5, 6, 7, 8, 10, 2, 4, 6, 8, 10, 12, 20, 20 ]
gap> OrdersClassRepresentatives(cths);
[ 1, 2, 2, 3, 4, 4, 4, 5, 5, 5, 6, 6, 7, 8, 8, 8, 10, 10, 11, 11, 12, 15, 20, 
  20 ]
gap> repeat e1:=Random(hs);until OrderPerm(e1)=12;
gap> e2:=e1^6;;
gap> SizesConjugacyClasses(ct2)[2];
525
gap> OrdersClassRepresentatives(cths)[21];
12
gap> PowerMap(cths,3);
[ 1, 2, 3, 1, 5, 6, 7, 8, 9, 10, 3, 2, 13, 14, 15, 16, 17, 18, 19, 20, 5, 9, 
  23, 24 ]
gap> PowerMap(cths,3)[PowerMap(cths,2)[21]];
2
gap> SizesConjugacyClasses(cths)[2];
5775
gap> cnt:=0;;repeat u:=Subgroup(aug,[e1,e2^Random(hs)]);cnt:=cnt+1;
> until Index(hs,u)=176;cnt;
2
gap> ophom:=OperationHomomorphism(hs,RightTransversal(hs,u),OnRight);;
gap> hsop:=Image(ophom);
< permutation group with 3 generators>
gap> IsPrimitive(hsop,[1..176]);
true
gap> dp:=DirectProduct(hs,hsop);;
gap> emb1:=Embedding(dp,1);;
gap> emb2:=Embedding(dp,2);;
gap> diag:=List(GeneratorsOfGroup(hs),
> i->Image(emb1,i)*Image(emb2,Image(ophom,i)));;
gap> diag:=Group(diag,());;SetName(diag,"hs-276");
gap> adj:=Adjacency(gamma,1);
[ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 
  42, 43, 100 ]
gap> t:=Stabilizer(diag,[1,adj[1]],OnSets);;
gap> cnt:=0;;repeat s:=Subgroup(diag,[Random(t),Random(t)]);cnt:=cnt+1;
> until Size(s)=Size(t);cnt;t:=s;;
1
The functions for automorphism groups have been improved a lot in GAP 4. The following commands should run quicker than the GAP 3 version did, also the user interface is nicer.
gap> aus:=AutomorphismGroup(t);;
gap> Size(aus);
241920
gap> inner:=InnerAutomorphismsAutomorphismGroup(aus);

gap> Index(aus,inner);
6
gap> rt:=RightTransversal(aus,inner);;
gap> automs:=Filtered(rt,i->i^2 in inner and not i in inner);;
gap> Length(automs);
3
gap> List(automs,Order);
[ 2, 2, 2 ]
The test whether an aotomorphism can be realized by conjugation in S_n is already included in GAP 4. (GAP uses it itself to test whether the whole automorphism group can be represented faithfully as subgroup of S_n.) So the endgame becomes much easier.

gap> List(automs,IsConjugatorAutomorphism);
[ false, false, true ]
gap> element:=ConjugatorInnerAutomorphism(automs[3]);;
gap> co3:=Group(Concatenation(GeneratorsOfGroup(diag),[element]),());;
gap> Size(co3);
495766656000
gap> DisplayCompositionSeries(co3);
Group
 | Co(3)
Group
gap> quit;

2-Mar-1999
Alexander Hulpke (hulpke@math.colostate.edu)