# 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`)