Maintenance Issues of the &AtlasRep; Package

This is just preliminary, in particular not intended for inclusion in the manual!

This chapter describes why some data that are available in the web &ATLAS; are excluded from the &GAP; interface, by which data they have been replaced (if applicable), and which additional data are distributed together with the &AtlasRep; package.

-> section on just added material, such as cyc2ccls scripts

-> document all in datapkg!

Generators of Kernels

- change the code! - test.g -> not only for compatible std. generators & same std.!

run for 3^(1+12):2.Suz.2 Print( "hier\n" ); if entry[1] = "3^(1+12):2.Suz.2" then SetSize( N, 3^13 ); fi; #T for 3^13, calling Size exceeds the memory! #T (trans. permutation action on 3^12 = 531441 points!)

-> how to verify that the kernel is correct?

Note that the program computes elements in G, in particular we are not concerned with standardization in F, and we do not assume that the given standard generators of G are compatible with some standard generators of F. (Only relation: If G has several normal subgroups N such that G/N is isomorphic with F and if the i-th std. gens of G and F are compatible then we prefer the normal subgroup that is the kernel of the epim. given by mapping the i-th std. gen. of G to those of F.)

- provide kernel info also for incompatible generators:

AGR.STDCOMP("(A5xA12):2",[0,"A12.2",1,false]); AGR.STDCOMP("(A5xU3(8):3):2",[0,"A5.2",1,false]); AGR.STDCOMP("(L3(2)xS4(4):2).2",[0,"L3(2).2",1,false]); AGR.STDCOMP("2^2.2E6(2).S3",[0,"2E6(2).3.2",0,false]); AGR.STDCOMP("5^3.L3(5)",[2,"L3(5)",1,false]);

- a new type of slps, many new scripts

- hard case: 2.2E6(2) ->> 2E6(2) (and analog. 2^2.2E6(2) -> 2E6(2)) need to skip obviously unnecessary words; the > 5593818-th word works (which exactly?), but only 525 words must actually be tested (really?) (altogether 10 minutes runtime!)

(done 2015-04-13 on gemma)

5593773- 5593781+ 5593782+ 5593813- 5593814+ 5593818- [ [ m2^2*m1*m2*(m2*m1*m2^2*m1)^2*(m2*m1)^4, 33 ], true ]

-> is equal to (m2^2*m1)^3*m2*m1*m2^2*m1*(m2*m1)^4 with slp 3:= 2*1 4:= 2*3 5:= 4^3 (2 mult) 6:= 3^4 (2 mult) 7:= 5*3 8:= 7*4 9:= 8*6 thus 9 mult! -> add a remark about the arbitr. of the printed factoriz.!

(only those numbers are shown for which all syllables are below the el. order, and "-" means that the order in the factor group is even, which need not be checked)

- function is AGR.Test.ComputeKernelGenerators...

-> better move out from Test!

- really verify the non-cyclic kernels! (see TODO_2)

--------------------------------------------------------------------------

kernel generators:

- missing verifications in atlasrep/kerrun.out? (std. 0) - two kernels of order 3^13 --prove!

# run on 2014-04-30

# add a test: # if a repres. for G and of m.G are avail. then try to compute kernel slp, # also if no compat. is assumed; # try also compatibility ...

# add a test: are all files in the datapkg dir. of atlasrep valid?

......................................................................

# find a kernel generator:

# see AGR.Test.ComputeKernelGenerators! (atlasrep/gap/test.g)

fgens:= AtlasGenerators( "L3(7).2", 1 ).generators; gens:= AtlasGenerators( "3.L3(7).2", 1 ).generators;

kergens:= []; kerwords:= [];

f:= FreeMonoid( 2 ); mgens:= GeneratorsOfMonoid( f ); iter:= Iterator( f ); for word in iter do m:= MappedWord( word, mgens, gens ); fm:= MappedWord( word, mgens, fgens ); ord:= Order( fm ); if Order( m ) <> ord then kergen:= m^ord; if not kergen in kergens then Add( kergens, kergen ); Add( kerwords, word ); if Length( kerwords ) >= 1 then Error("!"); fi; fi; fi; od;

word; Order( m ); Order( fm );

brk> word; m1 brk> Order( m ); 4 brk> Order( fm ); 2

m2^2*m1*m2*m1

slp:= StraightLineProgram( [[2,1,1,1],[3,2],[2,2],[5,1,4,1],[[6,19]]],2 );

-----------------------------------------------------------------------------

#I AGR.Test.KernelGenerators for 2.A10.2: missing kernels of epim. to #I [ "A10.2" ] #I AGR.Test.KernelGenerators for 2.A12.2: missing kernels of epim. to #I [ "A12.2" ] #I AGR.Test.KernelGenerators for 2.A13.2: missing kernels of epim. to #I [ "A13.2" ] #I AGR.Test.KernelGenerators for 2.A8.2: missing kernels of epim. to #I [ "A8.2" ] #I AGR.Test.KernelGenerators for 2.A9.2: missing kernels of epim. to #I [ "A9.2" ] #I AGR.Test.KernelGenerators for 2.B: missing kernels of epim. to #I [ "B" ]

#I AGR.Test.KernelGenerators for 2.L2(25): missing kernels of epim. to #I [ "L2(25)" ] #I AGR.Test.KernelGenerators for 2.O7(3).2: missing kernels of epim. to #I [ "O7(3).2" ] #I AGR.Test.KernelGenerators for 2.O8+(2): missing kernels of epim. to #I [ "O8+(2)" ] #I AGR.Test.KernelGenerators for 2.O8+(2).2: missing kernels of epim. to #I [ "O8+(2).2" ]

#I AGR.Test.KernelGenerators for 2.U6(2).2: missing kernels of epim. to #I [ "U6(2).2" ] omit 2^2.2E6(2) #I AGR.Test.KernelGenerators for 2^2.2E6(2).S3: missing kernels of epim. to #I [ "2E6(2).3.2" ] #I AGR.Test.KernelGenerators for 2^2.L3(4): missing kernels of epim. to #I [ "2.L3(4)", "L3(4)" ] #I AGR.Test.KernelGenerators for 2^2.L3(4).2_2: missing kernels of epim. to #I [ "L3(4).2_2" ]

#I AGR.Test.KernelGenerators for 6.O7(3).2: missing kernels of epim. to #I [ "2.O7(3).2", "3.O7(3).2", "O7(3).2" ]

#I AGR.Test.KernelGenerators for Isoclinic(12.M22.2): missing kernels of epim\ . to #I [ "2.M22.2", "3.M22.2", "6.M22.2", "M22.2" ] #I AGR.Test.KernelGenerators for Isoclinic(2.A8.2): missing kernels of epim. \ to #I [ "A8.2" ] #I AGR.Test.KernelGenerators for Isoclinic(2.HS.2): missing kernels of epim. \ to #I [ "HS.2" ] #I AGR.Test.KernelGenerators for Isoclinic(2.Suz.2): missing kernels of epim.\ to #I [ "Suz.2" ] #I AGR.Test.KernelGenerators for Isoclinic(4.M22.2): missing kernels of epim.\ to #I [ "2.M22.2", "M22.2" ]

#I AGR.Test.KernelGenerators for Isoclinic(6.M22.2): missing kernels of epim.\ to #I [ "3.M22.2", "M22.2" ]

-> no repres.

#I AGR.Test.KernelGenerators for Isoclinic(6.Suz.2): missing kernels of epim.\ to #I [ "3.Suz.2", "Suz.2" ]

................ #I AGR.Test.KernelGenerators for 3^(1+12):2.Suz.2: missing kernels of epim. t\ o #I [ "2.Suz.2" ] #I AGR.Test.KernelGenerators for 3^(1+12):6.Suz.2: missing kernels of epim. t\ o #I [ "3^(1+12).2.Suz.2", "6.Suz.2" ]

-> Vorsicht: Ich habe zwar gezeigt, dass die Konjugierten des 3. Erzeugers mindestens eine 3^13 erzeugen, aber ist es nicht vielleicht mehr? Und ich habe nicht gezeigt, dass die Untergruppe wirklich normal ist!

(in beiden Fällen, M3max7G0-ker6Suzd2W1 und Mmax7G0-ker2Suzd2W1)

gap> List( gens.generators, Order ); [ 4, 3, 3 ] gap> List( fgens.generators, Order ); [ 4, 3 ] gap> p:= Product( gens.generators{[1,2]} );; gap> l:= List( [0..11], x -> gens.generators[3]^(p^x) );; gap> cc:= Group(l );; gap> orb:= Orbit( cc, l[1][38] );; Length( orb ); 1 gap> orb:= Orbit( cc, l[1][78] );; Length( orb ); 1594323 gap> 3^13; 1594323

g:= Group( gens.generators ); kergens:= []; kerwords:= [];

f:= FreeMonoid( 2 ); mgens:= GeneratorsOfMonoid( f ); iter:= Iterator( f ); for word in iter do m:= MappedWord( word, mgens, gens.generators ); ord:= Order( m ); if ord mod 7 = 0 then kergen:= m^(ord/7); if not kergen in kergens then n:= NormalClosure( g, SubgroupNC( g, [ kergen ] ) ); if 7^5 mod Size( n ) = 0 then Add( kergens, kergen ); Add( kerwords, [ word, ord/7 ] ); if Length( kerwords ) >= 1 then Error("!"); fi; fi; fi; fi; od;

ab hier o.k.!

Excluded data files
A matrix representation of 3.L_3(7).2

The files 3L37d2G1-f7r6B0.m1 and 3L37d2G1-f7r6B0.m2 that are available in the web &ATLAS; contain generators for the group G = 3.L_3(7).2, but these generators are not standard. First we show this fact and then we compute standard generators.

The files look as follows.

1 7 6 6 000454 000103 000163 321000 016000 622000

and

1 7 6 6 000500 000416 000064 251000 212000 203000

Standard generators of G are defined as follows.

Std. gens. of L_3(7).2 are c, d, where c in 2B, d in 4B (two outer classes), |cd| = 19, |cdcdd| = 8. Std. gens. of 3.L_3(7).2 are preimages C, D where |CD| = 19.

We create the matrices in &GAP; and check the conditions.

gap> gens:= List( [ > " 1 7 6 6\n\ > 000454\n\ > 000103\n\ > 000163\n\ > 321000\n\ > 016000\n\ > 622000", > " 1 7 6 6\n\ > 000500\n\ > 000416\n\ > 000064\n\ > 251000\n\ > 212000\n\ > 203000" ], str -> ScanMeatAxeFile( str, 7, "string" ) ); [ < immutable compressed matrix 6x6 over GF(7) >, < immutable compressed matrix 6x6 over GF(7) > ] gap> List( gens, Order ); [ 2, 4 ] gap> Order( gens[1] * gens[2] ); 19 gap> Order( ( gens[1] * gens[2] )^2 * gens[2] ); 6

This shows that the given matrices are not standard generators of G. In order to convince ourselves that they generate G, we proceed as follows. First we compute a faithful permutation representation of the group H, say, that is generated by the given matrices. Then we show that the derived subgroup D of H is a perfect group with a central subgroup Z of order three such that the factor group D / Z is a simple group that is isomorphic with L_3(7), thus D is the triple cover of L_3(7). It remains to show that H / Z is not a direct product of D / Z and a group of order two; for that, it is enough to show that the centralizer of an element of order 19 in H has odd order.

gap> g:= GroupWithGenerators( gens );; gap> Size( g ); 11261376 gap> orbs:= Orbits( g, Elements( GF(7)^6 ) );; gap> Collected( List( orbs, Length ) ); [ [ 1, 1 ], [ 684, 1 ], [ 16416, 1 ], [ 16758, 6 ] ] gap> orb:= First( orbs, x -> Length( x ) = 684 );; gap> acthom:= ActionHomomorphism( g, orb, OnRight );; gap> img:= Image( acthom );; gap> Size( img ) = Size( g ); true gap> der:= DerivedSubgroup( img );; gap> IsPerfectGroup( der ); true gap> z:= Centre( der );; gap> Size( z ); 3 gap> f:= der / z;; gap> IsSimple( f ); true gap> IsomorphismTypeInfoFiniteSimpleGroup( f ); rec( name := "A(2,7) = L(3,7) ", parameter := [ 3, 7 ], series := "L" ) gap> gensimgs:= List( gens, x -> x^acthom );; gap> x:= gensimgs[1] * gensimgs[2];; gap> Order( x ); 19 gap> Size( Centralizer( img, x ) ); 57

Now let us find standard generators for G. According to , there is exactly one conjugacy class of elements of the orders 2 and 4 in G outside D, and the given generators have the right orders and lie outside D. Thus we may keep the first matrix and replace the second one by a suitable G-conjugate.

gap> c:= gensimgs[1];; gap> d:= gensimgs[2];; gap> repeat > dr:= d^Random( img ); > until Order( c * dr ) = 19 and Order( (c * dr)^2 * dr ) = 8 > and Size( img ) = Size( SubgroupNC( img, [ c, dr ] ) ); gap> gap> stdgens:= [ gens[1], PreImagesRepresentative( acthom, dr ) ]; [ < immutable compressed matrix 6x6 over GF(7) >, < immutable compressed matrix 6x6 over GF(7) > ]

The erroneous representation gets excluded from the &GAP; interface by removing it from the data list in the file gap/atlasprm.json of the &AtlasRep; package and then adding an entry to the global variable .

The standard generators computed as shown above have been added to the data that are distributed together with the &AtlasRep; package, the representation is now available with the name 3L37d2G1-f7r6aB0; note that the name 3L37d2G1-f7r6B0 must be avoided.

gap> OneAtlasGeneratingSetInfo( "3.L3(7).2", Dimension, 6, Ring, GF(7) ); rec( dim := 6, groupname := "3.L3(7).2", id := "a", identifier := [ "3.L3(7).2", [ [ "internal", "3L37d2G1-f7r6aB0.m1" ], [ "internal", "3L37d2G1-f7r6aB0.m2" ] ], 1, 7 ], repname := "3L37d2G1-f7r6aB0", repnr := 1, ring := GF(7), size := 11261376, standardization := 1, type := "matff" )
A matrix representation of 2.O_7(3).2^*

The files 2O73d2G1-f3r8B0.m1 and 2O73d2G1-f3r8B0.m2 that are available in the web &ATLAS; do not contain generators for the group 2.O_7(3).2.

The files look as follows.

1 3 8 8 01200212 10011201 20201110 02122011 01111002 00211210 20212110 00111021

and

1 3 8 8 11010011 10121000 20000221 12101200 11001011 22000112 12121220 01201002

Standard generators of 2.O_7(3).2 are defined as follows.

Standard generators of O_7(3).2 are c, d where c is in class 2D, d has order 7, cd has order 26 and cdcdd has order 14. Standard generators of 2.O_7(3).2 are preimages C, D where D has order 7.

We create the matrices in &GAP; and check the conditions.

gap> gens:= List( [ > " 1 3 8 8\n\ > 01200212\n\ > 10011201\n\ > 20201110\n\ > 02122011\n\ > 01111002\n\ > 00211210\n\ > 20212110\n\ > 00111021", > " 1 3 8 8\n\ > 11010011\n\ > 10121000\n\ > 20000221\n\ > 12101200\n\ > 11001011\n\ > 22000112\n\ > 12121220\n\ > 01201002" ], str -> ScanMeatAxeFile( str, 3, "string" ) ); [ < immutable compressed matrix 8x8 over GF(3) >, < immutable compressed matrix 8x8 over GF(3) > ] gap> List( gens, Order ); [ 2, 7 ] gap> Order( gens[1] * gens[2] ); 26 gap> Order( ( gens[1] * gens[2] )^2 * gens[2] ); 28

Since the 2D elements in O_7(3).2 lift to elements of order four in 2.O_7(3).2, and since the elements of order 26 in O_7(3).2 lift to elements of order 52 in 2.O_7(3).2, the given matrices do not fit. They would fit, however, to the isoclinic variant G = 2.O_7(3).2^*, provided that they generate this group and that the first generator is a preimage of a 2D element (that is, not a preimage of a 2E element).

In order to convince ourselves that the given matrices generate G, we proceed as follows. First we compute a faithful permutation representation of the group H, say, that is generated by the given matrices. Then we show that the derived subgroup D of H is a perfect group with a central subgroup Z of order two such that the factor group D / Z is a simple group that is isomorphic with O_7(3), thus D is the double cover of O_7(3). It remains to show that H / Z is not a direct product of D / Z and a group of order two; for that, it is enough to show that the centre of H / Z is trivial.

gap> g:= GroupWithGenerators( gens );; gap> Size( g ); 18341406720 gap> orbs:= Orbits( g, Elements( GF(3)^8 ) );; gap> Collected( List( orbs, Length ) ); [ [ 1, 1 ], [ 2240, 1 ], [ 4320, 1 ] ] gap> orb:= First( orbs, x -> Length( x ) = 2240 );; gap> acthom:= ActionHomomorphism( g, orb, OnRight );; gap> img:= Image( acthom );; gap> Size( img ) = Size( g ); true gap> der:= DerivedSubgroup( img );; gap> IsPerfectGroup( der ); true gap> z:= Centre( der );; gap> Size( z ); 2 gap> blocks:= Orbits( z, MovedPoints( img ) );; gap> act:= Action( img, blocks, OnSets );; gap> Size( act ) = Size( g ) / Size( z ); true gap> IsSimple( act ); true gap> IsomorphismTypeInfoFiniteSimpleGroup( act ); rec( name := "B(3,3) = O(7,3)", parameter := [ 3, 3 ], series := "B" ) gap> Size( Centre( act ) ); 1

Now we show that the first generator is in fact a preimage of a 2D element in O_7(3).2; note that this conjugacy class is the first class outside O_7(3), and it is uniquely determined by the centralizer order of its elements.

gap> ind:= Permutation( gens[1]^acthom, blocks, OnSets );; gap> c:= Size( Centralizer( act, ind ) ); 24261120 gap> t:= CharacterTable( "O7(3).2" );; gap> Positions( SizesCentralizers( t ), c ); [ 53 ] gap> Positions( OrdersClassRepresentatives( t ), 2 ); [ 2, 3, 4, 53, 54, 55 ]

Thus we have shown that the given matrices are standard generators of the group G.

The erroneous representation gets excluded from the &GAP; interface by removing it from the data list in the file gap/atlasprm.json of the &AtlasRep; package and then adding an entry to the global variable .

The given matrices have been added to the data that are distributed together with the &AtlasRep; package, the representation is now available with the name 2O73d2iG1-f3r8B0. (In order to make this work, also the &ATLAS; name "2O73d2i" for the group with &GAP; name "Isoclinic(2.O7(3).2)" had to be notified via a call to AGR.GNAN.

gap> OneAtlasGeneratingSetInfo( "Isoclinic(2.O7(3).2)", Dimension, 8, > Ring, GF(3) ); rec( dim := 8, groupname := "Isoclinic(2.O7(3).2)", id := "", identifier := [ "Isoclinic(2.O7(3).2)", [ [ "internal", "2O73d2iG1-f3r8B0.m1" ], [ "internal", "2O73d2iG1-f3r8B0.m2" ] ], 1, 3 ], repname := "2O73d2iG1-f3r8B0", repnr := 1, ring := GF(3), standardization := 1, type := "matff" )

Of course we can create a representation of 2.O_7(3).2 from this representation, by multiplying the first generator with a fourth root of unity, for example with Z(9)^2. (see ). Note that this representation is defined over the field with 9 elements, and that 2.O_7(3).2 does not have a faithful matrix representation of degree 8 over the field with 3 elements. The data that are distributed together with the &AtlasRep; package contain also this representation, with the name 2O73d2G1-f9r8B0.

gap> OneAtlasGeneratingSetInfo( "2.O7(3).2", Dimension, 8, Ring, GF(9) ); rec( dim := 8, groupname := "2.O7(3).2", id := "", identifier := [ "2.O7(3).2", [ [ "internal", "2O73d2G1-f9r8B0.m1" ], [ "internal", "2O73d2G1-f9r8B0.m2" ] ], 1, 9 ], repname := "2O73d2G1-f9r8B0", repnr := 1, ring := GF(3^2), size := 18341406720, standardization := 1, type := "matff" )

Some of the straight line programs that are available in the web &ATLAS; for computing generators of maximal subgroups of the group G = Fi_{22}.2 are not correct. In fact, all of these programs compute generators for maximal subgroups but for some of them, the maximal subgroup is in a class different from the one that is claimed.

Thus the programs in question have been excluded from the &GAP; interface by removing them from the data list in the file gap/atlasprm.json of the &AtlasRep; package and then adding entries to the global variable .

Then the same programs have been added to the data that are distributed together with the &AtlasRep; package, but with different names; the mapping of names is as follows.

<HorLine>
Order
Excluded name
Supported name
2090188800
F22d2G1-max12W1
F22d2G1-max3W2
908328960
F22d2G1-max10W1
F22d2G1-max4W2
185794560
F22d2G1-max3W1
F22d2G1-max5W2
106168320
F22d2G1-max4W1
F22d2G1-max6W2
78382080
F22d2G1-max5W1
F22d2G1-max7W2
35942400
F22d2G1-max6W1
F22d2G1-max8W2
35389440
F22d2G1-max7W1
F22d2G1-max9W2
25194240
F22d2G1-max8W1
F22d2G1-max10W2
10077696
F22d2G1-max9W1
F22d2G1-max11W2
8491392
F22d2G1-max11W1
F22d2G1-max12W2
<HorLine>

(A possible reason for the different numbering could be that the classes of maximal subgroups can be listed either according to non-increasing index or according to the ordering in ; note that in the latter ordering, the relatively small novelties G_2(3):2 and 3^5:(2 \times U_4(2).2) appear in the positions 3 and 4, respectively, whereas the positions of these groups according to increasing index must be 12 and 10, respectively. Reordering the classes from the latter ordering to the former one would result in the mapping that appears in the above table; unfortunately, the straight line programs had not been ordered according to the latter ordering.).

Class representatives of L_3(8).2

1. the script is WRONG: Take the available 6-dim. repres. over GF(8), its Brauer character value at 63AB does not fit to the char. table!

2. thus CHOOSE the available repres. as the FIRST one in the table, find out in which classes the inner elements lie

3. next, determine the outer classes: - 18A-C by their squares, which are 7th powers of the order 63 elements - 14G-I by their squares which are connected to the 9th powers of the order 63 elements - 8A-B by a representation

4. thus get a unique script; add it!

-> not unique program L38d2G1-cycW1 --can this be improved? outputs := [ "7GH", "14AB", "63AB", "73AB", "8A-B", "14G-I", "18A-C" ] -> on 8A-B: 2r2 on 14G-I: y7 on 18A-C: y9 -> mod 3: 8AB disting. by dim. 72, 14G-I by 657 -> mod 7: 8AB disting. by dim. 72, 14G-I by 511 -> mod 73: 8AB disting. by dim. 71, 14G-I by 657, 18A-C by 511

-> available: 9: G ≤ GL(72,7) -> does not help! 23: G ≤ GL(71,73) -> two irreducibles, decidable! 25: G ≤ GL(511a,73) 26: G ≤ GL(511b,73)

1a 2a 3a 4a 7a 7b 7c 7d 7e 7f 7g 9a 9b 9c 14a 14b 14c 21a 21b 21c 2P 1a 1a 3a 2a 7b 7c 7a 7d 7f 7g 7e 9b 9c 9a 7b 7c 7a 21b 21c 21a 3P 1a 2a 1a 4a 7c 7a 7b 7d 7g 7e 7f 3a 3a 3a 14c 14a 14b 7c 7a 7b 7P 1a 2a 3a 4a 1a 1a 1a 1a 1a 1a 1a 9b 9c 9a 2a 2a 2a 3a 3a 3a 73P 1a 2a 3a 4a 7c 7a 7b 7d 7g 7e 7f 9a 9b 9c 14c 14a 14b 21c 21a 21b

X.1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 X.2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 X.3 71 7 -1 -1 8 8 8 1 1 1 1 -1 -1 -1 . . . -1 -1 -1 X.4 71 7 -1 -1 8 8 8 1 1 1 1 -1 -1 -1 . . . -1 -1 -1

2 . . . . . . . . . 4 1 5 5 1 1 1 1 1 3 2 2 2 2 2 2 2 2 2 2 2 . . . . . 2 2 7 1 1 1 1 1 1 1 1 1 1 . . . 1 1 1 . . 73 . . . . . . . . . . . . . . . . . .

63a 63b 63c 63d 63e 63f 63g 63h 63i 2b 6a 8a 8b 14d 14e 14f 18a 18b 2P 63b 63c 63a 63e 63f 63d 63h 63i 63g 1a 3a 4a 4a 7f 7g 7e 9b 9c 3P 21c 21a 21b 21a 21b 21c 21b 21c 21a 2b 2b 8b 8a 14f 14d 14e 6a 6a 7P 9b 9c 9a 9a 9b 9c 9c 9a 9b 2b 6a 8a 8b 2b 2b 2b 18b 18c 73P 63e 63f 63d 63h 63i 63g 63b 63c 63a 2b 6a 8a 8b 14f 14d 14e 18a 18b

X.1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 X.2 1 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1 -1 X.3 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 AQ *AQ -1 -1 -1 -1 -1 X.4 -1 -1 -1 -1 -1 -1 -1 -1 -1 1 1 -AQ -*AQ 1 1 1 1 1

2 1 3 2 7 . 73 .

18c 2P 9a 3P 6a 7P 18a 73P 18c

X.1 1 X.2 -1 X.3 -1 X.4 1

AQ = -1+2*E(8)-2*E(8)^3 = -1+2*Sqrt(2) = -1+2r2

gap> prg:= AtlasProgram( "L3(8).2", "cyclic" ); rec( groupname := "L3(8).2", identifier := [ "L3(8).2", "L38d2G1-cycW1", 1 ], outputs := [ "7GH", "14AB", "63AB", "73AB", "8A-B", "14G-I", "18A-C" ], program := <straight line program>, standardization := 1, version := "1" ) gap> gens:= OneAtlasGeneratingSetInfo( "L3(8).2", Dimension, 71, Characteristic, 73 ); rec( dim := 71, groupname := "L3(8).2", id := "", identifier := [ "L3(8).2", [ "L38d2G1-f73r71B0.m1", "L38d2G1-f73r71B0.m2" ], 1, 73 ], repname := "L38d2G1-f73r71B0", repnr := 23, ring := GF(73), size := 32965632, standardization := 1, type := "matff" ) gap> gens:= AtlasGenerators( gens ); rec( dim := 71, generators := [ < immutable compressed matrix 71x71 over GF(73) >, < immutable compressed matrix 71x71 over GF(73) > ], groupname := "L3(8).2", id := "", identifier := [ "L3(8).2", [ "L38d2G1-f73r71B0.m1", "L38d2G1-f73r71B0.m2" ], 1, 73 ], repname := "L38d2G1-f73r71B0", repnr := 23, ring := GF(73), size := 32965632, standardization := 1, type := "matff" ) gap> res:= ResultOfStraightLineProgram( prg.program, gens.generators );; gap> Length( res ); 7 gap> 2b:= res[7]^9; < immutable compressed matrix 71x71 over GF(73) > gap> Order( last ); 2 gap> BrauerCharacterValue( 2b ); -1 gap> # thus we have 71a! gap> 8ab:= res[5]; < immutable compressed matrix 71x71 over GF(73) > gap> Order( last ); 8 gap> BrauerCharacterValue( 8ab ); -1-2*E(8)+2*E(8)^3 gap> Quadratic( last ); rec( ATLAS := "-1-2r2", a := -1, b := -2, d := 1, display := "-1-2*Sqrt(2)", root := 2 ) gap> # thus we have class 8B!

concerning 18A-C: squares are in 9B, 9C, 9A and 9A is the 7th power of 63c, 63d, 63h and 9B is the 7th power of 63a, 63e, 63i and 9C is the 7th power of 63b, 63f, 63g

-> so we could solve this without a repres.! (and the answer defines some repres.)

-> what about 14G-I?

squares: 14G -> 7f 14H -> 7g 14I -> 7e

and 9th powers of 63 are 63a -> 21c -> 7b 63b -> 21a -> 7c 63c -> 21b -> 7a 63d -> 21a -> 7c 63e -> 21b -> 7a 63f -> 21c -> 7b 63g -> 21b -> 7a 63h -> 21c -> 7b 63i -> 21a -> 7c

and there are representations of degree 146 or 1168 or 657 which couple 7a-c to 7d-f

23: G ≤ GL(71,73) 24: G ≤ GL(441,73) 25: G ≤ GL(511a,73) 26: G ≤ GL(511b,73)

-> but we do not have it!

-> in char. 3, also candidates: degrees 146, 657

-> use the nat. repres. in char. 2!

Maximal Subgroups of L_3(4)

Two straight line programs that are available in the web &ATLAS; for computing generators of maximal subgroups of the group G = L_3(4) are not correct.

The contents of the file L34G1-max4W1 is as follows.

mu 1 2 3 mu 2 1 4 iv 3 5 mu 4 4 2 mu 2 5 4 mu 4 3 2

However, if we apply this program to standard generators of G then the outputs generate the whole group.

gap> slp:= ScanStraightLineProgram( "\ > mu 1 2 3\n\ > mu 2 1 4\n\ > iv 3 5\n\ > mu 4 4 2\n\ > mu 2 5 4\n\ > mu 4 3 2", "string" ); rec( program := <straight line program> ) gap> g:= AtlasGroup( "L3(4)" ); Group([ (1,2)(4,6)(5,7)(8,12)(9,14)(10,15)(11,17)(13,19), (2,3,5,4)(6,8,13,9)(7,10,16,11)(12,18)(14,20,21,15)(17,19) ]) gap> res:= ResultOfStraightLineProgram( slp.program, > GeneratorsOfGroup( g ) );; gap> Size( SubgroupNC( g, res ) ); 20160

Similarly, the file L34G1-max5W1 has the following contents.

mu 1 2 3 mu 2 1 4 iv 3 5 mu 4 5 2 mu 2 3 4 mu 4 3 2

The subgroup generated by the outputs of this program has order 10 and is hence too small.

gap> slp:= ScanStraightLineProgram( "\ > mu 1 2 3\n\ > mu 2 1 4\n\ > iv 3 5\n\ > mu 4 5 2\n\ > mu 2 3 4\n\ > mu 4 3 2", "string" ); rec( program := <straight line program> ) gap> res:= ResultOfStraightLineProgram( slp.program, > GeneratorsOfGroup( g ) );; gap> Size( SubgroupNC( g, res ) ); 10

Now we want to replace the wrong programs by correct ones. According to , the subgroups in the 3rd, 4th, and 5th class of maximal subgroups of G are all isomorphic with the alternating group A_6. Thus our task is to find two subgroups of type A_6 in G that are not conjugate to each other and also not conjugate to the representative of the 3rd class of maximal subgroups.

Our approach is to keep the first generator of G (an involution), and to iterate over short words in a free monoid until the corresponding word in the standard generators of G together with the involution generate a suitable subgroup. (Note that all subgroups of order 360 in G are maximal in G and have the type A_6.)

gap> g:= AtlasGroup( "L3(4)" );; gap> s3:= AtlasSubgroup( "L3(4)", 3 );; gap> Size( s3 ); IsSimple( s3 ); 360 true gap> gens:= ShallowCopy( GeneratorsOfGroup( g ) );; gap> f:= FreeMonoid( 2 );; gap> fgens:= GeneratorsOfMonoid( f );; [ m1, m2 ] gap> iter:= Iterator( f );; gap> repeat > w4:= NextIterator( iter ); > s4:= Group( gens[1], MappedWord( w4, fgens, gens ) ); > until Size( s4 ) = 360 and not IsConjugate( g, s3, s4 ); gap> w4; m2*m1*m2^3*m1*m2*m1*m2 gap> repeat > w5:= NextIterator( iter ); > s5:= Group( gens[1], MappedWord( w5, fgens, gens ) ); > until Size( s5 ) = 360 > and not IsConjugate( g, s3, s5 ) > and not IsConjugate( g, s4, s5 ); gap> w5; m2*m1*m2*m1*m2^3*m1*m2

The erroneous programs get excluded from the &GAP; interface by removing them from the data list in the file gap/atlasprm.json of the &AtlasRep; package and then adding entries to the global variable .

The above words have been turned into straight line programs and then added to the data that are distributed together with the &AtlasRep; package, the programs are now available with the names L34G1-max4W2; and L34G1-max5W2, respectively; note that the names L34G1-max4W1 and L34G1-max5W1 must be avoided.

gap> subs:= List( [3..5], i -> AtlasSubgroup( g, i ) );; gap> List( subs, Size ); [ 360, 360, 360 ] gap> IsConjugate( g, subs[1], subs[2] ); false gap> IsConjugate( g, subs[1], subs[3] ); false gap> IsConjugate( g, subs[2], subs[3] ); false

It turns out that the generators of the subgroups are in fact standard generators of A_6.

gap> prg:= AtlasProgram( "A6", 1, "check" ); rec( groupname := "A6", identifier := [ "A6", "A6G1-check1", 1, 1 ], program := <straight line decision>, standardization := 1, version := "1" ) gap> ForAll( subs, s -> ResultOfStraightLineDecision( prg.program, > GeneratorsOfGroup( s ) ) ); true

Thus we can provide also the (empty) straight line programs L34G1max3W1-A6G1W1, L34G1max4W2-A6G1W1, and L34G1max5W2-A6G1W1, which express that the &GAP; interface provides standard generators for the maximal subgroups in question.