Quelle probgen.tst
Sprache: unbekannt
|
|
# This file was created automatically, do not edit!
#############################################################################
##
#W probgen.tst GAP 4 package CTblLib Thomas Breuer
##
## This file contains the GAP code of examples in the package
## documentation files.
##
## In order to run the tests, one starts GAP from the 'tst' subdirectory
## of the 'pkg/ctbllib' directory, and calls 'Test( "probgen.tst" );'.
##
gap> LoadPackage( "CTblLib", false );
true
gap> save:= SizeScreen();;
gap> SizeScreen( [ 72 ] );;
gap> START_TEST( "probgen.tst" );
##
gap> if IsBound( BrowseData ) then
> data:= BrowseData.defaults.dynamic.replayDefaults;
> oldinterval:= data.replayInterval;
> data.replayInterval:= 1;
> fi;
## doc2/probgen.xml (557-566)
gap> CompareVersionNumbers( GAPInfo.Version, "4.5.0" );
true
gap> LoadPackage( "ctbllib", "1.2", false );
true
gap> LoadPackage( "tomlib", "1.2", false );
true
gap> LoadPackage( "atlasrep", "1.5", false );
true
## doc2/probgen.xml (577-585)
gap> max:= GAPInfo.CommandLineOptions.o;;
gap> if not ( ( IsSubset( max, "m" ) and
> Int( Filtered( max, IsDigitChar ) ) >= 800 ) or
> ( IsSubset( max, "g" ) and
> Int( Filtered( max, IsDigitChar ) ) >= 1 ) ) then
> Print( "the maximal allowed memory might be too small\n" );
> fi;
## doc2/probgen.xml (604-611)
gap> staterandom:= [ State( GlobalRandomSource ),
> State( GlobalMersenneTwister ) ];;
gap> ResetGlobalRandomNumberGenerators:= function()
> Reset( GlobalRandomSource, staterandom[1] );
> Reset( GlobalMersenneTwister, staterandom[2] );
> end;;
## doc2/probgen.xml (948-954)
gap> if not IsBound( PositionsProperty ) then
> PositionsProperty:= function( list, prop )
> return Filtered( [ 1 .. Length( list ) ], i -> prop( list[i] ) );
> end;
> fi;
## doc2/probgen.xml (1019-1054)
gap> BindGlobal( "TripleWithProperty", function( threelists, prop )
> local i, j, k, test;
>
> for i in threelists[1] do
> for j in threelists[2] do
> for k in threelists[3] do
> test:= [ i, j, k ];
> if prop( test ) then
> return test;
> fi;
> od;
> od;
> od;
>
> return fail;
> end );
gap> BindGlobal( "QuadrupleWithProperty", function( fourlists, prop )
> local i, j, k, l, test;
>
> for i in fourlists[1] do
> for j in fourlists[2] do
> for k in fourlists[3] do
> for l in fourlists[4] do
> test:= [ i, j, k, l ];
> if prop( test ) then
> return test;
> fi;
> od;
> od;
> od;
> od;
>
> return fail;
> end );
## doc2/probgen.xml (1089-1101)
gap> BindGlobal( "PrintFormattedArray", function( array )
> local colwidths, n, row;
> array:= List( array, row -> List( row, String ) );
> colwidths:= List( TransposedMat( array ),
> col -> Maximum( List( col, Length ) ) );
> n:= Length( array[1] );
> for row in List( array, row -> List( [ 1 .. n ],
> i -> String( row[i], colwidths[i] ) ) ) do
> Print( " ", JoinStringsWithSeparator( row, " " ), "\n" );
> od;
> end );
## doc2/probgen.xml (1115-1132)
gap> BindGlobal( "NeededVariables", NamesUserGVars() );
gap> BindGlobal( "CleanWorkspace", function()
> local name, record;
>
> for name in Difference( NamesUserGVars(), NeededVariables ) do
> if not IsReadOnlyGlobal( name ) then
> UnbindGlobal( name );
> fi;
> od;
> for record in [ LIBTOMKNOWN, LIBTABLE ] do
> for name in RecNames( record.LOADSTATUS ) do
> Unbind( record.LOADSTATUS.( name ) );
> Unbind( record.( name ) );
> od;
> od;
> end );
## doc2/probgen.xml (1171-1186)
gap> if not IsBound( PossiblePermutationCharacters ) then
> BindGlobal( "PossiblePermutationCharacters", function( sub, tbl )
> local fus, triv;
>
> fus:= PossibleClassFusions( sub, tbl );
> if fus = fail then
> return fail;
> fi;
> triv:= [ TrivialCharacter( sub ) ];
>
> return Set(
> List( fus, map -> Induced( sub, tbl, triv, map )[1] ) );
> end );
> fi;
## doc2/probgen.xml (1256-1296)
gap> DeclareAttribute( "PrimitivePermutationCharacters",
> IsCharacterTable );
gap> InstallOtherMethod( PrimitivePermutationCharacters,
> [ IsCharacterTable ],
> function( tbl )
> local maxes, i, fus, poss, tom, G;
>
> if HasMaxes( tbl ) then
> maxes:= List( Maxes( tbl ), CharacterTable );
> for i in [ 1 .. Length( maxes ) ] do
> fus:= GetFusionMap( maxes[i], tbl );
> if fus = fail then
> fus:= PossibleClassFusions( maxes[i], tbl );
> poss:= Set( fus,
> map -> InducedClassFunctionsByFusionMap(
> maxes[i], tbl,
> [ TrivialCharacter( maxes[i] ) ], map )[1] );
> if Length( poss ) = 1 then
> maxes[i]:= poss[1];
> else
> return fail;
> fi;
> else
> maxes[i]:= TrivialCharacter( maxes[i] )^tbl;
> fi;
> od;
> return maxes;
> elif HasFusionToTom( tbl ) then
> tom:= TableOfMarks( tbl );
> maxes:= MaximalSubgroupsTom( tom );
> return PermCharsTom( tbl, tom ){ maxes[1] };
> elif HasUnderlyingGroup( tbl ) then
> G:= UnderlyingGroup( tbl );
> return List( MaximalSubgroupClassReps( G ),
> M -> TrivialCharacter( M )^tbl );
> fi;
>
> return fail;
> end );
## doc2/probgen.xml (1365-1375)
gap> BindGlobal( "ApproxP", function( primitives, spos )
> local sum;
>
> sum:= ShallowCopy( Sum( List( primitives,
> pi -> pi[ spos ] * pi / pi[1] ) ) );
> sum[1]:= 0;
>
> return sum;
> end );
## doc2/probgen.xml (1423-1447)
gap> BindGlobal( "ProbGenInfoSimple", function( tbl )
> local prim, max, min, bound, s;
> prim:= PrimitivePermutationCharacters( tbl );
> if prim = fail then
> return fail;
> fi;
> max:= List( [ 1 .. NrConjugacyClasses( tbl ) ],
> i -> Maximum( ApproxP( prim, i ) ) );
> min:= Minimum( max );
> bound:= Inverse( min );
> if IsInt( bound ) then
> bound:= bound - 1;
> else
> bound:= Int( bound );
> fi;
> s:= PositionsProperty( max, x -> x = min );
> s:= List( Set( s, i -> ClassOrbit( tbl, i ) ), i -> i[1] );
> return [ Identifier( tbl ),
> min,
> bound,
> AtlasClassNames( tbl ){ s },
> Sum( List( prim, pi -> pi{ s } ) ) ];
> end );
## doc2/probgen.xml (1492-1537)
gap> BindGlobal( "ProbGenInfoAlmostSimple", function( tblS, tblG, sposS )
> local p, fus, inv, prim, sposG, outer, approx, l, max, min,
> s, cards, i, names;
>
> p:= Size( tblG ) / Size( tblS );
> if not IsPrimeInt( p )
> or Length( ClassPositionsOfNormalSubgroups( tblG ) ) <> 3 then
> return fail;
> fi;
> fus:= GetFusionMap( tblS, tblG );
> if fus = fail then
> return fail;
> fi;
> inv:= InverseMap( fus );
> prim:= PrimitivePermutationCharacters( tblG );
> if prim = fail then
> return fail;
> fi;
> sposG:= Set( fus{ sposS } );
> outer:= Difference( PositionsProperty(
> OrdersClassRepresentatives( tblG ), IsPrimeInt ), fus );
> approx:= List( sposG, i -> ApproxP( prim, i ){ outer } );
> if IsEmpty( outer ) then
> max:= List( approx, x -> 0 );
> else
> max:= List( approx, Maximum );
> fi;
> min:= Minimum( max);
> s:= sposG{ PositionsProperty( max, x -> x = min ) };
> cards:= List( prim, pi -> pi{ s } );
> for i in [ 1 .. Length( prim ) ] do
> # Omit the character that is induced from the simple group.
> if ForAll( prim[i], x -> x = 0 or x = prim[i][1] ) then
> cards[i]:= 0;
> fi;
> od;
> names:= AtlasClassNames( tblG ){ s };
> Perform( names, ConvertToStringRep );
>
> return [ Identifier( tblG ),
> min,
> names,
> Sum( cards ) ];
> end );
## doc2/probgen.xml (1591-1613)
gap> BindGlobal( "SigmaFromMaxes", function( arg )
> local t, sname, maxes, numpermchars, prim, spos, outer;
>
> t:= arg[1];
> sname:= arg[2];
> maxes:= arg[3];
> numpermchars:= arg[4];
> prim:= List( maxes, s -> PossiblePermutationCharacters( s, t ) );
> spos:= Position( AtlasClassNames( t ), sname );
> if ForAny( [ 1 .. Length( maxes ) ],
> i -> Length( prim[i] ) <> numpermchars[i] ) then
> return fail;
> elif Length( arg ) = 5 and arg[5] = "outer" then
> outer:= Difference(
> PositionsProperty( OrdersClassRepresentatives( t ), IsPrimeInt ),
> ClassPositionsOfDerivedSubgroup( t ) );
> return Maximum( ApproxP( Concatenation( prim ), spos ){ outer } );
> else
> return Maximum( ApproxP( Concatenation( prim ), spos ) );
> fi;
> end );
## doc2/probgen.xml (1641-1680)
gap> BindGlobal( "DisplayProbGenMaxesInfo", function( tbl, snames )
> local mx, prim, i, spos, nonz, indent, j;
>
> if not HasMaxes( tbl ) then
> Print( Identifier( tbl ), ": fail\n" );
> return;
> fi;
>
> # Now we are sure that the order of the characters returned by
> # 'PrimitivePermutationCharacters' is compatible with 'Maxes( tbl )'.
> mx:= List( Maxes( tbl ), CharacterTable );
> prim:= List( PrimitivePermutationCharacters( tbl ), ShallowCopy );
> for i in [ 1 .. Length( prim ) ] do
> # Deal with the case that the subgroup is normal.
> if ForAll( prim[i], x -> x = 0 or x = prim[i][1] ) then
> prim[i]:= prim[i] / prim[i][1];
> fi;
> od;
>
> spos:= List( snames,
> nam -> Position( AtlasClassNames( tbl ), nam ) );
> nonz:= List( spos, x -> PositionsProperty( prim, pi -> pi[x] <> 0 ) );
> for i in [ 1 .. Length( spos ) ] do
> Print( Identifier( tbl ), ", ", snames[i], ": " );
> indent:= ListWithIdenticalEntries(
> Length( Identifier( tbl ) ) + Length( snames[i] ) + 4, ' ' );
> if not IsEmpty( nonz[i] ) then
> Print( Identifier( mx[ nonz[i][1] ] ), " (",
> prim[ nonz[i][1] ][ spos[i] ], ")\n" );
> for j in [ 2 .. Length( nonz[i] ) ] do
> Print( indent, Identifier( mx[ nonz[i][j] ] ), " (",
> prim[ nonz[i][j] ][ spos[i] ], ")\n" );
> od;
> else
> Print( "\n" );
> fi;
> od;
> end );
## doc2/probgen.xml (1717-1725)
gap> BindGlobal( "PcConjugacyClassReps", function( G )
> local iso;
>
> iso:= IsomorphismPcGroup( G );
> return List( ConjugacyClasses( Image( iso ) ),
> c -> PreImagesRepresentative( iso, Representative( c ) ) );
> end );
## doc2/probgen.xml (1788-1809)
gap> BindGlobal( "ClassesOfPrimeOrder", function( G, primes, N )
> local ccl, p, syl, Greps, reps, r, cr;
>
> ccl:= [];
> for p in primes do
> syl:= SylowSubgroup( G, p );
> Greps:= [];
> reps:= Filtered( PcConjugacyClassReps( syl ),
> r -> Order( r ) = p and not r in N );
> for r in reps do
> cr:= ConjugacyClass( G, r );
> if ForAll( Greps, c -> c <> cr ) then
> Add( Greps, cr );
> fi;
> od;
> Append( ccl, Greps );
> od;
>
> return ccl;
> end );
## doc2/probgen.xml (1839-1853)
gap> if not IsBound( IsGeneratorsOfTransPermGroup) then
> BindGlobal( "IsGeneratorsOfTransPermGroup", function( G, list )
> local S;
>
> if not IsTransitive( G ) then
> Error( "<G> must be transitive on its moved points" );
> fi;
> S:= SubgroupNC( G, list );
>
> return IsTransitive( S, MovedPoints( G ) ) and
> Size( S ) = Size( G );
> end );
> fi;
## doc2/probgen.xml (1880-1897)
gap> BindGlobal( "RatioOfNongenerationTransPermGroup", function( G, g, s )
> local nongen, pair;
>
> if not IsTransitive( G ) then
> Error( "<G> must be transitive on its moved points" );
> fi;
> nongen:= 0;
> for pair in DoubleCosetRepsAndSizes( G, Centralizer( G, g ),
> Centralizer( G, s ) ) do
> if not IsGeneratorsOfTransPermGroup( G, [ s, g^pair[1] ] ) then
> nongen:= nongen + pair[2];
> fi;
> od;
>
> return nongen / Size( G );
> end );
## doc2/probgen.xml (1931-1948)
gap> BindGlobal( "DiagonalProductOfPermGroups", function( groups )
> local prodgens, deg, i, gens, D, pi;
>
> prodgens:= GeneratorsOfGroup( groups[1] );
> deg:= NrMovedPoints( prodgens );
> for i in [ 2 .. Length( groups ) ] do
> gens:= GeneratorsOfGroup( groups[i] );
> D:= MovedPoints( gens );
> pi:= MappingPermListList( D, [ deg+1 .. deg+Length( D ) ] );
> deg:= deg + Length( D );
> prodgens:= List( [ 1 .. Length( prodgens ) ],
> i -> prodgens[i] * gens[i]^pi );
> od;
>
> return Group( prodgens );
> end );
## doc2/probgen.xml (1981-2014)
gap> BindGlobal( "RepresentativesMaximallyCyclicSubgroups", function( tbl )
> local n, result, orders, p, pmap, i, j;
>
> # Initialize.
> n:= NrConjugacyClasses( tbl );
> result:= BlistList( [ 1 .. n ], [ 1 .. n ] );
>
> # Omit powers of smaller order.
> orders:= OrdersClassRepresentatives( tbl );
> for p in PrimeDivisors( Size( tbl ) ) do
> pmap:= PowerMap( tbl, p );
> for i in [ 1 .. n ] do
> if orders[ pmap[i] ] < orders[i] then
> result[ pmap[i] ]:= false;
> fi;
> od;
> od;
>
> # Omit Galois conjugates.
> for i in [ 1 .. n ] do
> if result[i] then
> for j in ClassOrbit( tbl, i ) do
> if i <> j then
> result[j]:= false;
> fi;
> od;
> fi;
> od;
>
> # Return the result.
> return ListBlist( [ 1 .. n ], result );
> end );
## doc2/probgen.xml (2042-2054)
gap> BindGlobal( "ClassesPerhapsCorrespondingToTableColumns",
> function( G, tbl, cols )
> local orders, classes, invariants;
>
> orders:= OrdersClassRepresentatives( tbl );
> classes:= SizesConjugacyClasses( tbl );
> invariants:= List( cols, i -> [ orders[i], classes[i] ] );
>
> return Filtered( ConjugacyClasses( G ),
> c -> [ Order( Representative( c ) ), Size(c) ] in invariants );
> end );
## doc2/probgen.xml (2183-2276)
gap> BindGlobal( "UpperBoundFixedPointRatios",
> function( G, maxesclasses, truetest )
> local myIsConjugate, invs, info, c, r, o, inv, pos, sums, max, maxpos,
> maxlen, reps, split, i, found, j;
>
> myIsConjugate:= function( G, x, y )
> local movx, movy;
>
> movx:= MovedPoints( x );
> movy:= MovedPoints( y );
> if movx = movy then
> G:= Stabilizer( G, movx, OnSets );
> fi;
> return IsConjugate( G, x, y );
> end;
>
> invs:= [];
> info:= [];
>
> # First distribute the classes according to invariants.
> for c in Concatenation( maxesclasses ) do
> r:= Representative( c );
> o:= Order( r );
> # Take only prime order representatives.
> if IsPrimeInt( o ) then
> inv:= [ o, Size( Centralizer( G, r ) ) ];
> # Omit classes that are central in `G'.
> if inv[2] <> Size( G ) then
> if IsPerm( r ) then
> Add( inv, NrMovedPoints( r ) );
> fi;
> pos:= First( [ 1 .. Length( invs ) ], i -> inv = invs[i] );
> if pos = fail then
> # This class is not `G'-conjugate to any of the previous ones.
> Add( invs, inv );
> Add( info, [ [ r, Size( c ) * inv[2] ] ] );
> else
> # This class may be conjugate to an earlier one.
> Add( info[ pos ], [ r, Size( c ) * inv[2] ] );
> fi;
> fi;
> fi;
> od;
>
> if info = [] then
> return [ 0, true ];
> fi;
>
> repeat
> # Compute the contributions of the classes with the same invariants.
> sums:= List( info, x -> Sum( List( x, y -> y[2] ) ) );
> max:= Maximum( sums );
> maxpos:= Filtered( [ 1 .. Length( info ) ], i -> sums[i] = max );
> maxlen:= List( maxpos, i -> Length( info[i] ) );
>
> # Split the sets with the same invariants if necessary
> # and if we want to compute the exact value.
> if truetest and not 1 in maxlen then
> # Make one conjugacy test.
> pos:= Position( maxlen, Minimum( maxlen ) );
> reps:= info[ maxpos[ pos ] ];
> if myIsConjugate( G, reps[1][1], reps[2][1] ) then
> # Fuse the two classes.
> reps[1][2]:= reps[1][2] + reps[2][2];
> reps[2]:= reps[ Length( reps ) ];
> Unbind( reps[ Length( reps ) ] );
> else
> # Split the list. This may require additional conjugacy tests.
> Unbind( info[ maxpos[ pos ] ] );
> split:= [ reps[1], reps[2] ];
> for i in [ 3 .. Length( reps ) ] do
> found:= false;
> for j in split do
> if myIsConjugate( G, reps[i][1], j[1] ) then
> j[2]:= reps[i][2] + j[2];
> found:= true;
> break;
> fi;
> od;
> if not found then
> Add( split, reps[i] );
> fi;
> od;
>
> info:= Compacted( Concatenation( info,
> List( split, x -> [ x ] ) ) );
> fi;
> fi;
> until 1 in maxlen or not truetest;
>
> return [ max / Size( G ), 1 in maxlen ];
> end );
## doc2/probgen.xml (2354-2374)
gap> BindGlobal( "OrbitRepresentativesProductOfClasses",
> function( G, classreps )
> local cents, n, orbreps;
>
> cents:= List( classreps, x -> Centralizer( G, x ) );
> n:= Length( classreps );
>
> orbreps:= function( reps, intersect, pos )
> if pos > n then
> return [ reps ];
> fi;
> return Concatenation( List(
> DoubleCosetRepsAndSizes( G, cents[ pos ], intersect ),
> r -> orbreps( Concatenation( reps, [ classreps[ pos ]^r[1] ] ),
> Intersection( intersect, cents[ pos ]^r[1] ), pos+1 ) ) );
> end;
>
> return orbreps( [ classreps[1] ], cents[1], 2 );
> end );
## doc2/probgen.xml (2412-2439)
gap> BindGlobal( "RandomCheckUniformSpread", function( G, classreps, s, try )
> local elms, found, i, conj;
>
> if not IsTransitive( G, MovedPoints( G ) ) then
> Error( "<G> must be transitive on its moved points" );
> fi;
>
> # Compute orbit representatives of G on the direct product,
> # and try to find a good conjugate of s for each representative.
> for elms in OrbitRepresentativesProductOfClasses( G, classreps ) do
> found:= false;
> for i in [ 1 .. try ] do
> conj:= s^Random( G );
> if ForAll( elms,
> x -> IsGeneratorsOfTransPermGroup( G, [ x, conj ] ) ) then
> found:= true;
> break;
> fi;
> od;
> if not found then
> return elms;
> fi;
> od;
>
> return true;
> end );
## doc2/probgen.xml (2514-2536)
gap> BindGlobal( "CommonGeneratorWithGivenElements",
> function( G, classreps, tuple )
> local inter, rep, repcen, pair;
>
> if not IsTransitive( G, MovedPoints( G ) ) then
> Error( "<G> must be transitive on its moved points" );
> fi;
>
> inter:= Intersection( List( tuple, x -> Centralizer( G, x ) ) );
> for rep in classreps do
> repcen:= Centralizer( G, rep );
> for pair in DoubleCosetRepsAndSizes( G, repcen, inter ) do
> if ForAll( tuple,
> x -> IsGeneratorsOfTransPermGroup( G, [ x, rep^pair[1] ] ) ) then
> return rep;
> fi;
> od;
> od;
>
> return fail;
> end );
## doc2/probgen.xml (2582-2599)
gap> sporinfo:= [];;
gap> spornames:= AllCharacterTableNames( IsSporadicSimple, true,
> IsDuplicateTable, false );;
gap> for tbl in List( spornames, CharacterTable ) do
> info:= ProbGenInfoSimple( tbl );
> if info <> fail then
> # keep the table columns narrow
> if info[2] <= 10^-13 then
> info[2]:= "<= 10^-13";
> fi;
> if info[3] >= 10^13 then
> info[3]:= ">= 10^13";
> fi;
> Add( sporinfo, info );
> fi;
> od;
## doc2/probgen.xml (2607-2635)
gap> PrintFormattedArray( sporinfo );
B <= 10^-13 >= 10^13 [ "47A" ] [ 1 ]
Co1 421/1545600 3671 [ "35A" ] [ 4 ]
Co2 1/270 269 [ "23A" ] [ 1 ]
Co3 64/6325 98 [ "21A" ] [ 4 ]
F3+ 1/269631216855 269631216854 [ "29A" ] [ 1 ]
Fi22 43/585 13 [ "16A" ] [ 7 ]
Fi23 2651/2416635 911 [ "23A" ] [ 2 ]
HN 4/34375 8593 [ "19A" ] [ 1 ]
HS 64/1155 18 [ "15A" ] [ 2 ]
He 3/595 198 [ "14C" ] [ 3 ]
J1 1/77 76 [ "19A" ] [ 1 ]
J2 5/28 5 [ "10C" ] [ 3 ]
J3 2/153 76 [ "19A" ] [ 2 ]
J4 1/1647124116 1647124115 [ "29A" ] [ 1 ]
Ly 1/35049375 35049374 [ "37A" ] [ 1 ]
M <= 10^-13 >= 10^13 [ "59A" ] [ 1 ]
M11 1/3 2 [ "11A" ] [ 1 ]
M12 1/3 2 [ "10A" ] [ 3 ]
M22 1/21 20 [ "11A" ] [ 1 ]
M23 1/8064 8063 [ "23A" ] [ 1 ]
M24 108/1265 11 [ "21A" ] [ 2 ]
McL 317/22275 70 [ "15A", "30A" ] [ 3, 3 ]
ON 10/30723 3072 [ "31A" ] [ 2 ]
Ru 1/2880 2879 [ "29A" ] [ 1 ]
Suz 141/5720 40 [ "14A" ] [ 3 ]
Th 2/267995 133997 [ "27A", "27B" ] [ 2, 2 ]
## doc2/probgen.xml (2643-2651)
gap> ProbGenInfoSimple( CharacterTable( "B" ) );
[ "B", 1/174702778623598780219392000000,
174702778623598780219391999999, [ "47A" ], [ 1 ] ]
gap> ProbGenInfoSimple( CharacterTable( "M" ) );
[ "M", 1/5622007631255133978225347923531983224832000000000,
5622007631255133978225347923531983224831999999999, [ "59A" ], [ 1 ]
]
## doc2/probgen.xml (2669-2726)
gap> for entry in sporinfo do
> DisplayProbGenMaxesInfo( CharacterTable( entry[1] ), entry[4] );
> od;
B, 47A: 47:23 (1)
Co1, 35A: (A5xJ2):2 (1)
(A6xU3(3)):2 (2)
(A7xL2(7)):2 (1)
Co2, 23A: M23 (1)
Co3, 21A: U3(5).3.2 (2)
L3(4).D12 (1)
s3xpsl(2,8).3 (1)
F3+, 29A: 29:14 (1)
Fi22, 16A: 2^10:m22 (1)
(2x2^(1+8)):U4(2):2 (1)
2F4(2)' (4)
2^(5+8):(S3xA6) (1)
Fi23, 23A: 2..11.m23 (1)
L2(23) (1)
HN, 19A: U3(8).3_1 (1)
HS, 15A: A8.2 (1)
5:4xa5 (1)
He, 14C: 2^1+6.psl(3,2) (1)
7^2:2psl(2,7) (1)
7^(1+2):(S3x3) (1)
J1, 19A: 19:6 (1)
J2, 10C: 2^1+4b:a5 (1)
a5xd10 (1)
5^2:D12 (1)
J3, 19A: L2(19) (1)
J3M3 (1)
J4, 29A: frob (1)
Ly, 37A: 37:18 (1)
M, 59A: 59:29 (1)
M11, 11A: L2(11) (1)
M12, 10A: A6.2^2 (1)
M12M4 (1)
2xS5 (1)
M22, 11A: L2(11) (1)
M23, 23A: 23:11 (1)
M24, 21A: L3(4).3.2_2 (1)
2^6:(psl(3,2)xs3) (1)
McL, 15A: 3^(1+4):2S5 (1)
2.A8 (1)
5^(1+2):3:8 (1)
McL, 30A: 3^(1+4):2S5 (1)
2.A8 (1)
5^(1+2):3:8 (1)
ON, 31A: L2(31) (1)
ONM8 (1)
Ru, 29A: L2(29) (1)
Suz, 14A: J2.2 (2)
(a4xpsl(3,4)):2 (1)
Th, 27A: ThN3B (1)
ThM7 (1)
Th, 27B: ThN3B (1)
ThM7 (1)
## doc2/probgen.xml (2770-2774)
gap> SigmaFromMaxes( CharacterTable( "B" ), "47A",
> [ CharacterTable( "47:23" ) ], [ 1 ] );
1/174702778623598780219392000000
## doc2/probgen.xml (2784-2788)
gap> SigmaFromMaxes( CharacterTable( "M" ), "59A",
> [ CharacterTable( "59:29" ) ], [ 1 ] );
1/5622007631255133978225347923531983224832000000000
## doc2/probgen.xml (2802-2812)
gap> t:= CharacterTable( "M" );;
gap> s:= CharacterTable( "L2(59)" );;
gap> pi:= PossiblePermutationCharacters( s, t );;
gap> Length( pi );
5
gap> spos:= Position( OrdersClassRepresentatives( t ), 59 );
152
gap> Set( pi, x -> Maximum( ApproxP( [ x ], spos ) ) );
[ 1/3385007637938037777290625 ]
## doc2/probgen.xml (2828-2835)
gap> sporautnames:= AllCharacterTableNames( IsSporadicSimple, true,
> IsDuplicateTable, false,
> OfThose, AutomorphismGroup );;
gap> sporautnames:= Difference( sporautnames, spornames );
[ "F3+.2", "Fi22.2", "HN.2", "HS.2", "He.2", "J2.2", "J3.2", "M12.2",
"M22.2", "McL.2", "ON.2", "Suz.2" ]
## doc2/probgen.xml (2861-2889)
gap> sporautinfo:= [];;
gap> fails:= [];;
gap> for name in sporautnames do
> tbl:= CharacterTable( name{ [ 1 .. Position( name, '.' ) - 1 ] } );
> tblG:= CharacterTable( name );
> info:= ProbGenInfoSimple( tbl );
> info:= ProbGenInfoAlmostSimple( tbl, tblG,
> List( info[4], x -> Position( AtlasClassNames( tbl ), x ) ) );
> if info = fail then
> Add( fails, name );
> else
> Add( sporautinfo, info );
> fi;
> od;
gap> PrintFormattedArray( sporautinfo );
F3+.2 0 [ "29AB" ] [ 1 ]
Fi22.2 251/3861 [ "16AB" ] [ 7 ]
HN.2 1/6875 [ "19AB" ] [ 1 ]
HS.2 36/275 [ "15A" ] [ 2 ]
He.2 37/9520 [ "14CD" ] [ 3 ]
J2.2 1/15 [ "10CD" ] [ 3 ]
J3.2 1/1080 [ "19AB" ] [ 1 ]
M12.2 4/99 [ "10A" ] [ 1 ]
M22.2 1/21 [ "11AB" ] [ 1 ]
McL.2 1/63 [ "15AB", "30AB" ] [ 3, 3 ]
ON.2 1/84672 [ "31AB" ] [ 1 ]
Suz.2 661/46332 [ "14A" ] [ 3 ]
## doc2/probgen.xml (2904-2947)
gap> for entry in sporautinfo do
> DisplayProbGenMaxesInfo( CharacterTable( entry[1] ), entry[3] );
> od;
F3+.2, 29AB: F3+ (1)
frob (1)
Fi22.2, 16AB: Fi22 (1)
Fi22.2M4 (1)
(2x2^(1+8)):(U4(2):2x2) (1)
2F4(2)'.2 (4)
2^(5+8):(S3xS6) (1)
HN.2, 19AB: HN (1)
U3(8).6 (1)
HS.2, 15A: HS (1)
S8x2 (1)
5:4xS5 (1)
He.2, 14CD: He (1)
2^(1+6)_+.L3(2).2 (1)
7^2:2.L2(7).2 (1)
7^(1+2):(S3x6) (1)
J2.2, 10CD: J2 (1)
2^(1+4).S5 (1)
(A5xD10).2 (1)
5^2:(4xS3) (1)
J3.2, 19AB: J3 (1)
19:18 (1)
M12.2, 10A: M12 (1)
(2^2xA5):2 (1)
M22.2, 11AB: M22 (1)
L2(11).2 (1)
McL.2, 15AB: McL (1)
3^(1+4):4S5 (1)
Isoclinic(2.A8.2) (1)
5^(1+2):(24:2) (1)
McL.2, 30AB: McL (1)
3^(1+4):4S5 (1)
Isoclinic(2.A8.2) (1)
5^(1+2):(24:2) (1)
ON.2, 31AB: ON (1)
31:30 (1)
Suz.2, 14A: Suz (1)
J2.2x2 (2)
(A4xL3(4):2_3):2 (1)
## doc2/probgen.xml (2972-2976)
gap> SigmaFromMaxes( CharacterTable( "Fi24'.2" ), "29AB",
> [ CharacterTable( "29:28" ) ], [ 1 ], "outer" );
0
## doc2/probgen.xml (2989-2994)
gap> 16 in OrdersClassRepresentatives( CharacterTable( "U4(2).2" ) );
false
gap> 16 in OrdersClassRepresentatives( CharacterTable( "G2(3).2" ) );
false
## doc2/probgen.xml (3006-3035)
gap> t2:= CharacterTable( "Fi22.2" );;
gap> prim:= List( [ "Fi22.2M4", "(2x2^(1+8)):(U4(2):2x2)", "2F4(2)" ],
> n -> PossiblePermutationCharacters( CharacterTable( n ), t2 ) );;
gap> t:= CharacterTable( "Fi22" );;
gap> pi:= PossiblePermutationCharacters(
> CharacterTable( "2^(5+8):(S3xA6)" ), t );
[ Character( CharacterTable( "Fi22" ),
[ 3648645, 56133, 10629, 2245, 567, 729, 405, 81, 549, 165, 133,
37, 69, 20, 27, 81, 9, 39, 81, 19, 1, 13, 33, 13, 1, 0, 13, 13,
5, 1, 0, 0, 0, 8, 4, 0, 0, 9, 3, 15, 3, 1, 1, 1, 1, 3, 3, 1, 0,
0, 0, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2 ] ) ]
gap> torso:= CompositionMaps( pi[1], InverseMap( GetFusionMap( t, t2 ) ) );
[ 3648645, 56133, 10629, 2245, 567, 729, 405, 81, 549, 165, 133, 37,
69, 20, 27, 81, 9, 39, 81, 19, 1, 13, 33, 13, 1, 0, 13, 13, 5, 1,
0, 0, 0, 8, 4, 0, 9, 3, 15, 3, 1, 1, 1, 3, 3, 1, 0, 0, 2, 1, 0, 0,
0, 0, 0, 0, 1, 1, 2 ]
gap> ext:= PermChars( t2, rec( torso:= torso ) );;
gap> Add( prim, ext );
gap> prim:= Concatenation( prim );; Length( prim );
4
gap> spos:= Position( OrdersClassRepresentatives( t2 ), 16 );;
gap> List( prim, x -> x[ spos ] );
[ 1, 1, 4, 1 ]
gap> sigma:= ApproxP( prim, spos );;
gap> Maximum( sigma{ Difference( PositionsProperty(
> OrdersClassRepresentatives( t2 ), IsPrimeInt ),
> ClassPositionsOfDerivedSubgroup( t2 ) ) } );
251/3861
## doc2/probgen.xml (3045-3049)
gap> SigmaFromMaxes( CharacterTable( "HN.2" ), "19AB",
> [ CharacterTable( "U3(8).6" ) ], [ 1 ], "outer" );
1/6875
## doc2/probgen.xml (3061-3067)
gap> SigmaFromMaxes( CharacterTable( "HS.2" ), "15A",
> [ CharacterTable( "S8x2" ),
> CharacterTable( "5:4" ) * CharacterTable( "A5.2" ) ], [ 1, 1 ],
> "outer" );
36/275
## doc2/probgen.xml (3081-3114)
gap> t:= CharacterTable( "He" );;
gap> t2:= CharacterTable( "He.2" );;
gap> prim:= PrimitivePermutationCharacters( t );;
gap> spos:= Position( AtlasClassNames( t ), "14C" );;
gap> prim:= Filtered( prim, x -> x[ spos ] <> 0 );;
gap> map:= InverseMap( GetFusionMap( t, t2 ) );;
gap> torso:= List( prim, pi -> CompositionMaps( pi, map ) );
[ [ 187425, 945, 449, 0, 21, 21, 25, 25, 0, 0, 5, 0, 0, 7, 1, 0, 0,
1, 0, 1, 0, 0, 0, 0, 0, 0 ],
[ 244800, 0, 64, 0, 84, 0, 0, 16, 0, 0, 4, 24, 45, 3, 4, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0 ],
[ 652800, 0, 512, 120, 72, 0, 0, 0, 0, 0, 8, 8, 22, 1, 0, 0, 0, 0,
0, 1, 0, 0, 1, 1, 2, 0 ] ]
gap> ext:= List( torso, x -> PermChars( t2, rec( torso:= x ) ) );
[ [ Character( CharacterTable( "He.2" ),
[ 187425, 945, 449, 0, 21, 21, 25, 25, 0, 0, 5, 0, 0, 7, 1, 0,
0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 315, 15, 0, 0, 3, 7, 7, 3, 0,
0, 0, 1, 1, 0, 1, 1, 0, 0, 0 ] ) ],
[ Character( CharacterTable( "He.2" ),
[ 244800, 0, 64, 0, 84, 0, 0, 16, 0, 0, 4, 24, 45, 3, 4, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 360, 0, 0, 0, 6, 0, 0, 0, 0, 0,
3, 2, 2, 0, 0, 0, 0, 0, 0 ] ) ],
[ Character( CharacterTable( "He.2" ),
[ 652800, 0, 512, 120, 72, 0, 0, 0, 0, 0, 8, 8, 22, 1, 0, 0, 0,
0, 0, 1, 0, 0, 1, 1, 2, 0, 480, 0, 120, 0, 12, 0, 0, 0, 0,
0, 4, 0, 0, 0, 0, 0, 0, 1, 1 ] ) ] ]
gap> spos:= Position( AtlasClassNames( t2 ), "14CD" );;
gap> sigma:= ApproxP( Concatenation( ext ), spos );;
gap> Maximum( sigma{ Difference( PositionsProperty(
> OrdersClassRepresentatives( t2 ), IsPrimeInt ),
> ClassPositionsOfDerivedSubgroup( t2 ) ) } );
37/9520
## doc2/probgen.xml (3124-3128)
gap> SigmaFromMaxes( CharacterTable( "ON.2" ), "31AB",
> [ CharacterTable( "P:Q", [ 31, 30 ] ) ], [ 1 ], "outer" );
1/84672
## doc2/probgen.xml (3147-3198)
gap> sporautinfo2:= [];;
gap> for name in List( sporautinfo, x -> x[1] ) do
> Add( sporautinfo2, ProbGenInfoSimple( CharacterTable( name ) ) );
> od;
gap> PrintFormattedArray( sporautinfo2 );
F3+.2 19/5684 299 [ "42E" ] [ 10 ]
Fi22.2 1165/20592 17 [ "24G" ] [ 3 ]
HN.2 1/1425 1424 [ "24B" ] [ 4 ]
HS.2 21/550 26 [ "20C" ] [ 4 ]
He.2 33/4165 126 [ "24A" ] [ 2 ]
J2.2 1/15 14 [ "14A" ] [ 1 ]
J3.2 77/10260 133 [ "34A" ] [ 1 ]
M12.2 113/495 4 [ "12B" ] [ 3 ]
M22.2 8/33 4 [ "10A" ] [ 4 ]
McL.2 1/135 134 [ "22A" ] [ 1 ]
ON.2 61/109368 1792 [ "22A", "38A" ] [ 1, 1 ]
Suz.2 1/351 350 [ "28A" ] [ 1 ]
gap> for entry in sporautinfo2 do
> DisplayProbGenMaxesInfo( CharacterTable( entry[1] ), entry[4] );
> od;
F3+.2, 42E: 2^12.M24 (2)
2^2.U6(2):S3x2 (1)
2^(3+12).(L3(2)xS6) (2)
(S3xS3xG2(3)):2 (1)
S6xL2(8):3 (1)
7:6xS7 (1)
7^(1+2)_+:(6xS3).2 (2)
Fi22.2, 24G: Fi22.2M4 (1)
2^(5+8):(S3xS6) (1)
3^5:(2xU4(2).2) (1)
HN.2, 24B: 2^(1+8)_+.(A5xA5).2^2 (1)
5^2.5.5^2.4S5 (2)
HN.2M13 (1)
HS.2, 20C: (2xA6.2^2).2 (1)
HS.2N5 (2)
5:4xS5 (1)
He.2, 24A: 2^(1+6)_+.L3(2).2 (1)
S4xL3(2).2 (1)
J2.2, 14A: L3(2).2x2 (1)
J3.2, 34A: L2(17)x2 (1)
M12.2, 12B: L2(11).2 (1)
2^3.(S4x2) (1)
3^(1+2):D8 (1)
M22.2, 10A: M22.2M4 (1)
A6.2^2 (1)
L2(11).2 (2)
McL.2, 22A: 2xM11 (1)
ON.2, 22A: J1x2 (1)
ON.2, 38A: J1x2 (1)
Suz.2, 28A: (A4xL3(4):2_3):2 (1)
## doc2/probgen.xml (3209-3217)
gap> sporautchoices:= [
> [ "Fi22", "Fi22.2", 42 ],
> [ "Fi24'", "Fi24'.2", 46 ],
> [ "He", "He.2", 42 ],
> [ "HN", "HN.2", 44 ],
> [ "HS", "HS.2", 30 ],
> [ "ON", "ON.2", 38 ], ];;
## doc2/probgen.xml (3226-3250)
gap> for triple in sporautchoices do
> tbl:= CharacterTable( triple[1] );
> tbl2:= CharacterTable( triple[2] );
> spos2:= PowerMap( tbl2, 2,
> Position( OrdersClassRepresentatives( tbl2 ), triple[3] ) );
> spos:= Position( GetFusionMap( tbl, tbl2 ), spos2 );
> DisplayProbGenMaxesInfo( tbl, AtlasClassNames( tbl ){ [ spos ] } );
> od;
Fi22, 21A: O8+(2).3.2 (1)
S3xU4(3).2_2 (1)
A10.2 (1)
A10.2 (1)
F3+, 23A: Fi23 (1)
F3+M7 (1)
He, 21B: 3.A7.2 (1)
7^(1+2):(S3x3) (1)
7:3xpsl(3,2) (2)
HN, 22A: 2.HS.2 (1)
HS, 15A: A8.2 (1)
5:4xa5 (1)
ON, 19B: L3(7).2 (1)
ONM2 (1)
J1 (1)
## doc2/probgen.xml (3271-3276)
gap> 42 in OrdersClassRepresentatives( CharacterTable( "G2(3).2" ) );
false
gap> Size( CharacterTable( "U4(2)" ) ) mod 7 = 0;
false
## doc2/probgen.xml (3285-3315)
gap> SigmaFromMaxes( CharacterTable( "Fi22.2" ), "42A",
> [ CharacterTable( "O8+(2).3.2" ) * CharacterTable( "Cyclic", 2 ),
> CharacterTable( "S3" ) * CharacterTable( "U4(3).(2^2)_{122}" ) ],
> [ 1, 1 ] );
163/1170
gap> SigmaFromMaxes( CharacterTable( "Fi24'.2" ), "46A",
> [ CharacterTable( "Fi23" ) * CharacterTable( "Cyclic", 2 ),
> CharacterTable( "2^12.M24" ) ],
> [ 1, 1 ] );
566/5481
gap> SigmaFromMaxes( CharacterTable( "He.2" ), "42A",
> [ CharacterTable( "3.A7.2" ) * CharacterTable( "Cyclic", 2 ),
> CharacterTable( "7^(1+2):(S3x6)" ),
> CharacterTable( "7:6" ) * CharacterTable( "L3(2)" ) ],
> [ 1, 1, 1 ] );
1/119
gap> SigmaFromMaxes( CharacterTable( "HN.2" ), "44A",
> [ CharacterTable( "4.HS.2" ) ],
> [ 1 ] );
997/192375
gap> SigmaFromMaxes( CharacterTable( "HS.2" ), "30A",
> [ CharacterTable( "S8" ) * CharacterTable( "C2" ),
> CharacterTable( "5:4" ) * CharacterTable( "S5" ) ],
> [ 1, 1 ] );
36/275
gap> SigmaFromMaxes( CharacterTable( "ON.2" ), "38A",
> [ CharacterTable( "J1" ) * CharacterTable( "C2" ) ],
> [ 1 ] );
61/109368
## doc2/probgen.xml (3336-3354)
gap> names:= AllCharacterTableNames( IsSimple, true, IsAbelian, false,
> IsDuplicateTable, false );;
gap> names:= Difference( names, spornames );;
gap> fails:= [];;
gap> lessthan3:= [];;
gap> atleast3:= [];;
gap> for name in names do
> tbl:= CharacterTable( name );
> info:= ProbGenInfoSimple( tbl );
> if info = fail then
> Add( fails, name );
> elif info[3] < 3 then
> Add( lessthan3, info );
> else
> Add( atleast3, info );
> fi;
> od;
## doc2/probgen.xml (3370-3379)
gap> fails;
[ "2E6(2)", "2F4(8)", "3D4(3)", "3D4(4)", "A14", "A15", "A16", "A17",
"A18", "A19", "E6(2)", "F4(3)", "G2(7)", "L4(4)", "L4(5)", "L4(9)",
"L5(3)", "L8(2)", "O10+(2)", "O10+(3)", "O10-(2)", "O10-(3)",
"O12+(2)", "O12+(3)", "O12-(2)", "O12-(3)", "O7(5)", "O8+(7)",
"O8-(3)", "O9(3)", "R(27)", "S10(2)", "S12(2)", "S4(7)", "S4(8)",
"S4(9)", "S6(4)", "S6(5)", "S8(3)", "U4(4)", "U4(5)", "U5(3)",
"U5(4)", "U6(4)", "U7(2)" ]
## doc2/probgen.xml (3389-3401)
gap> PrintFormattedArray( lessthan3 );
A5 1/3 2 [ "5A" ] [ 1 ]
A6 2/3 1 [ "5A" ] [ 2 ]
A7 2/5 2 [ "7A" ] [ 2 ]
O7(3) 199/351 1 [ "14A" ] [ 3 ]
O8+(2) 334/315 0 [ "15A", "15B", "15C" ] [ 7, 7, 7 ]
O8+(3) 863/1820 2 [ "20A", "20B", "20C" ] [ 8, 8, 8 ]
S6(2) 4/7 1 [ "9A" ] [ 4 ]
S8(2) 8/15 1 [ "17A" ] [ 3 ]
U4(2) 21/40 1 [ "12A" ] [ 2 ]
U4(3) 53/135 2 [ "7A" ] [ 7 ]
## doc2/probgen.xml (3420-3501)
gap> oldsize:= SizeScreen();;
gap> SizeScreen( [ 80 ] );;
gap> PrintFormattedArray( Filtered( atleast3, l -> l[1] <> "L7(2)" ) );
2F4(2)' 118/1755 14 [ "16A" ] [ 2 ]
3D4(2) 1/5292 5291 [ "13A" ] [ 1 ]
A10 3/10 3 [ "21A" ] [ 1 ]
A11 2/105 52 [ "11A" ] [ 2 ]
A12 2/9 4 [ "35A" ] [ 1 ]
A13 4/1155 288 [ "13A" ] [ 5 ]
A8 3/14 4 [ "15A" ] [ 1 ]
A9 9/35 3 [ "9A", "9B" ] [ 4, 4 ]
F4(2) 9/595 66 [ "13A" ] [ 5 ]
G2(3) 1/7 6 [ "13A" ] [ 3 ]
G2(4) 1/21 20 [ "13A" ] [ 2 ]
G2(5) 1/31 30 [ "7A", "21A" ] [ 10, 1 ]
L2(101) 1/101 100 [ "51A", "17A" ] [ 1, 1 ]
L2(103) 53/5253 99 [ "52A", "26A", "13A" ] [ 1, 1, 1 ]
L2(107) 55/5671 103 [ "54A", "27A", "18A", "9A", "6A" ] [ 1, 1, 1, 1, 1 ]
L2(109) 1/109 108 [ "55A", "11A" ] [ 1, 1 ]
L2(11) 7/55 7 [ "6A" ] [ 1 ]
L2(113) 1/113 112 [ "57A", "19A" ] [ 1, 1 ]
L2(121) 1/121 120 [ "61A" ] [ 1 ]
L2(125) 1/125 124 [ "63A", "21A", "9A", "7A" ] [ 1, 1, 1, 1 ]
L2(13) 1/13 12 [ "7A" ] [ 1 ]
L2(16) 1/15 14 [ "17A" ] [ 1 ]
L2(17) 1/17 16 [ "9A" ] [ 1 ]
L2(19) 11/171 15 [ "10A" ] [ 1 ]
L2(23) 13/253 19 [ "6A", "12A" ] [ 1, 1 ]
L2(25) 1/25 24 [ "13A" ] [ 1 ]
L2(27) 5/117 23 [ "7A", "14A" ] [ 1, 1 ]
L2(29) 1/29 28 [ "15A" ] [ 1 ]
L2(31) 17/465 27 [ "8A", "16A" ] [ 1, 1 ]
L2(32) 1/31 30 [ "3A", "11A", "33A" ] [ 1, 1, 1 ]
L2(37) 1/37 36 [ "19A" ] [ 1 ]
L2(41) 1/41 40 [ "21A", "7A" ] [ 1, 1 ]
L2(43) 23/903 39 [ "22A", "11A" ] [ 1, 1 ]
L2(47) 25/1081 43 [ "24A", "12A", "8A", "6A" ] [ 1, 1, 1, 1 ]
L2(49) 1/49 48 [ "25A" ] [ 1 ]
L2(53) 1/53 52 [ "27A", "9A" ] [ 1, 1 ]
L2(59) 31/1711 55 [ "30A", "15A", "10A", "6A" ] [ 1, 1, 1, 1 ]
L2(61) 1/61 60 [ "31A" ] [ 1 ]
L2(64) 1/63 62 [ "65A", "13A" ] [ 1, 1 ]
L2(67) 35/2211 63 [ "34A", "17A" ] [ 1, 1 ]
L2(71) 37/2485 67 [ "36A", "18A", "12A", "9A", "6A" ] [ 1, 1, 1, 1, 1 ]
L2(73) 1/73 72 [ "37A" ] [ 1 ]
L2(79) 41/3081 75 [ "40A", "20A", "10A", "8A" ] [ 1, 1, 1, 1 ]
L2(8) 1/7 6 [ "3A", "9A" ] [ 1, 1 ]
L2(81) 1/81 80 [ "41A" ] [ 1 ]
L2(83) 43/3403 79 [ "42A", "21A", "14A", "7A", "6A" ] [ 1, 1, 1, 1, 1 ]
L2(89) 1/89 88 [ "45A", "15A", "9A" ] [ 1, 1, 1 ]
L2(97) 1/97 96 [ "49A", "7A" ] [ 1, 1 ]
L3(11) 1/6655 6654 [ "19A", "133A" ] [ 1, 1 ]
L3(2) 1/4 3 [ "7A" ] [ 1 ]
L3(3) 1/24 23 [ "13A" ] [ 1 ]
L3(4) 1/5 4 [ "7A" ] [ 3 ]
L3(5) 1/250 249 [ "31A" ] [ 1 ]
L3(7) 1/1372 1371 [ "19A" ] [ 1 ]
L3(8) 1/1792 1791 [ "73A" ] [ 1 ]
L3(9) 1/2880 2879 [ "91A" ] [ 1 ]
L4(3) 53/1053 19 [ "20A" ] [ 1 ]
L5(2) 1/5376 5375 [ "31A" ] [ 1 ]
L6(2) 365/55552 152 [ "21A", "63A" ] [ 2, 2 ]
O8-(2) 1/63 62 [ "17A" ] [ 1 ]
S4(4) 4/15 3 [ "17A" ] [ 2 ]
S4(5) 1/5 4 [ "13A" ] [ 1 ]
S6(3) 1/117 116 [ "14A" ] [ 2 ]
Sz(32) 1/1271 1270 [ "5A", "25A" ] [ 1, 1 ]
Sz(8) 1/91 90 [ "5A" ] [ 1 ]
U3(11) 1/6655 6654 [ "37A" ] [ 1 ]
U3(3) 16/63 3 [ "6A", "12A" ] [ 2, 2 ]
U3(4) 1/160 159 [ "13A" ] [ 1 ]
U3(5) 46/525 11 [ "10A" ] [ 2 ]
U3(7) 1/1372 1371 [ "43A" ] [ 1 ]
U3(8) 1/1792 1791 [ "19A" ] [ 1 ]
U3(9) 1/3600 3599 [ "73A" ] [ 1 ]
U5(2) 1/54 53 [ "11A" ] [ 1 ]
U6(2) 5/21 4 [ "11A" ] [ 4 ]
gap> SizeScreen( oldsize );;
gap> First( atleast3, l -> l[1] = "L7(2)" );
[ "L7(2)", 1/4388290560, 4388290559, [ "127A" ], [ 1 ] ]
## doc2/probgen.xml (3622-3677)
gap> list:= [
> [ "A5", "A5.2" ],
> [ "A6", "A6.2_1" ],
> [ "A6", "A6.2_2" ],
> [ "A6", "A6.2_3" ],
> [ "A7", "A7.2" ],
> [ "A8", "A8.2" ],
> [ "A9", "A9.2" ],
> [ "A11", "A11.2" ],
> [ "L3(2)", "L3(2).2" ],
> [ "L3(3)", "L3(3).2" ],
> [ "L3(4)", "L3(4).2_1" ],
> [ "L3(4)", "L3(4).2_2" ],
> [ "L3(4)", "L3(4).2_3" ],
> [ "L3(4)", "L3(4).3" ],
> [ "S4(4)", "S4(4).2" ],
> [ "U3(3)", "U3(3).2" ],
> [ "U3(5)", "U3(5).2" ],
> [ "U3(5)", "U3(5).3" ],
> [ "U4(2)", "U4(2).2" ],
> [ "U4(3)", "U4(3).2_1" ],
> [ "U4(3)", "U4(3).2_3" ],
> ];;
gap> autinfo:= [];;
gap> fails:= [];;
gap> for pair in list do
> tbl:= CharacterTable( pair[1] );
> tblG:= CharacterTable( pair[2] );
> info:= ProbGenInfoSimple( tbl );
> spos:= List( info[4], x -> Position( AtlasClassNames( tbl ), x ) );
> Add( autinfo, ProbGenInfoAlmostSimple( tbl, tblG, spos ) );
> od;
gap> PrintFormattedArray( autinfo );
A5.2 0 [ "5AB" ] [ 1 ]
A6.2_1 2/3 [ "5AB" ] [ 2 ]
A6.2_2 1/6 [ "5A" ] [ 1 ]
A6.2_3 0 [ "5AB" ] [ 1 ]
A7.2 1/15 [ "7AB" ] [ 1 ]
A8.2 13/28 [ "15AB" ] [ 1 ]
A9.2 1/4 [ "9AB" ] [ 1 ]
A11.2 1/945 [ "11AB" ] [ 1 ]
L3(2).2 1/4 [ "7AB" ] [ 1 ]
L3(3).2 1/18 [ "13AB" ] [ 1 ]
L3(4).2_1 3/10 [ "7AB" ] [ 3 ]
L3(4).2_2 11/60 [ "7A" ] [ 1 ]
L3(4).2_3 1/12 [ "7AB" ] [ 1 ]
L3(4).3 1/64 [ "7A" ] [ 1 ]
S4(4).2 0 [ "17AB" ] [ 2 ]
U3(3).2 2/7 [ "6A", "12AB" ] [ 2, 2 ]
U3(5).2 2/21 [ "10A" ] [ 2 ]
U3(5).3 46/525 [ "10A" ] [ 2 ]
U4(2).2 16/45 [ "12AB" ] [ 2 ]
U4(3).2_1 76/135 [ "7A" ] [ 3 ]
U4(3).2_3 31/162 [ "7AB" ] [ 3 ]
## doc2/probgen.xml (3700-3708)
gap> t:= CharacterTable( "L4(3)" );;
gap> prim:= PrimitivePermutationCharacters( t );;
gap> spos:= Position( AtlasClassNames( t ), "20A" );;
gap> prim:= Filtered( prim, x -> x[ spos ] <> 0 );
[ Character( CharacterTable( "L4(3)" ),
[ 2106, 106, 42, 0, 27, 27, 0, 46, 6, 6, 1, 7, 7, 0, 3, 3, 0, 0, 0,
1, 1, 1, 0, 0, 0, 0, 0, 1, 1 ] ) ]
## doc2/probgen.xml (3714-3744)
gap> for name in [ "L4(3).2_1", "L4(3).2_2", "L4(3).2_3" ] do
> t2:= CharacterTable( name );
> map:= InverseMap( GetFusionMap( t, t2 ) );
> torso:= List( prim, pi -> CompositionMaps( pi, map ) );
> ext:= Concatenation( List( torso,
> x -> PermChars( t2, rec( torso:= x ) ) ) );
> sigma:= ApproxP( ext, Position( OrdersClassRepresentatives( t2 ), 20 ) );
> max:= Maximum( sigma{ Difference( PositionsProperty(
> OrdersClassRepresentatives( t2 ), IsPrimeInt ),
> ClassPositionsOfDerivedSubgroup( t2 ) ) } );
> Print( name, ":\n", ext, "\n", max, "\n" );
> od;
L4(3).2_1:
[ Character( CharacterTable( "L4(3).2_1" ),
[ 2106, 106, 42, 0, 27, 0, 46, 6, 6, 1, 7, 0, 3, 0, 0, 1, 1, 0,
0, 0, 0, 0, 1, 1, 0, 4, 0, 0, 6, 6, 6, 6, 2, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1 ] ) ]
0
L4(3).2_2:
[ Character( CharacterTable( "L4(3).2_2" ),
[ 2106, 106, 42, 0, 27, 27, 0, 46, 6, 6, 1, 7, 7, 0, 3, 3, 0, 0,
0, 1, 1, 1, 0, 0, 0, 1, 306, 306, 42, 6, 10, 10, 0, 0, 15, 15,
3, 3, 3, 3, 0, 0, 1, 1, 0, 1, 1, 0, 0 ] ) ]
17/117
L4(3).2_3:
[ Character( CharacterTable( "L4(3).2_3" ),
[ 2106, 106, 42, 0, 27, 0, 46, 6, 6, 1, 7, 0, 3, 0, 0, 1, 1, 0,
0, 0, 1, 36, 0, 0, 6, 6, 2, 2, 2, 1, 1, 0, 0, 0 ] ) ]
2/117
## doc2/probgen.xml (3751-3755)
gap> SigmaFromMaxes( CharacterTable( "O8-(2).2" ), "17AB",
> [ CharacterTable( "L2(16).4" ) ], [ 1 ], "outer" );
0
## doc2/probgen.xml (3766-3793)
gap> t:= CharacterTable( "S6(3)" );;
gap> t2:= CharacterTable( "S6(3).2" );;
gap> prim:= PrimitivePermutationCharacters( t );;
gap> spos:= Position( AtlasClassNames( t ), "14A" );;
gap> prim:= Filtered( prim, x -> x[ spos ] <> 0 );;
gap> map:= InverseMap( GetFusionMap( t, t2 ) );;
gap> torso:= List( prim, pi -> CompositionMaps( pi, map ) );;
gap> ext:= List( torso, pi -> PermChars( t2, rec( torso:= pi ) ) );
[ [ Character( CharacterTable( "S6(3).2" ),
[ 155520, 0, 288, 0, 0, 0, 216, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 144, 288, 0, 0, 0,
6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0,
0 ] ) ],
[ Character( CharacterTable( "S6(3).2" ),
[ 189540, 1620, 568, 0, 486, 0, 0, 27, 540, 84, 24, 0, 0, 0, 0,
0, 54, 0, 0, 10, 0, 7, 1, 6, 6, 0, 0, 0, 0, 0, 0, 18, 0, 0,
0, 6, 12, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 234, 64,
30, 8, 0, 3, 90, 6, 0, 4, 10, 6, 0, 2, 1, 0, 0, 0, 0, 0, 0,
0, 1, 1, 0, 0 ] ) ] ]
gap> spos:= Position( AtlasClassNames( t2 ), "14A" );;
gap> sigma:= ApproxP( Concatenation( ext ), spos );;
gap> Maximum( sigma{ Difference(
> PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
> ClassPositionsOfDerivedSubgroup( t2 ) ) } );
7/3240
## doc2/probgen.xml (3804-3808)
gap> SigmaFromMaxes( CharacterTable( "U5(2).2" ), "11AB",
> [ CharacterTable( "L2(11).2" ) ], [ 1 ], "outer" );
1/288
## doc2/probgen.xml (3816-3818)
gap> CleanWorkspace();
## doc2/probgen.xml (3853-3857)
gap> SigmaFromMaxes( CharacterTable( "O8-(3)" ), "41A",
> [ CharacterTable( "L2(81).2_1" ) ], [ 1 ] );
1/567
## doc2/probgen.xml (3904-3917)
gap> ForAny( [ "S8(2)", "O8+(2)", "L5(2)", "O8-(2)", "A8" ],
> x -> 45 in OrdersClassRepresentatives( CharacterTable( x ) ) );
false
gap> t:= CharacterTable( "O10+(2)" );;
gap> t2:= CharacterTable( "O10+(2).2" );;
gap> s2:= CharacterTable( "A5.2" ) * CharacterTable( "U4(2).2" );
CharacterTable( "A5.2xU4(2).2" )
gap> pi:= PossiblePermutationCharacters( s2, t2 );;
gap> spos:= Position( OrdersClassRepresentatives( t2 ), 45 );;
gap> approx:= ApproxP( pi, spos );;
gap> Maximum( approx{ ClassPositionsOfDerivedSubgroup( t2 ) } );
43/4216
## doc2/probgen.xml (3926-3931)
gap> Maximum( approx{ Difference(
> PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
> ClassPositionsOfDerivedSubgroup( t2 ) ) } );
23/248
## doc2/probgen.xml (3939-3942)
gap> SigmaFromMaxes( t2, "45AB", [ s2 ], [ 1 ], "outer" );
23/248
## doc2/probgen.xml (3987-3991)
gap> SigmaFromMaxes( CharacterTable( "O10-(2)" ), "33A",
> [ CharacterTable( "Cyclic", 3 ) * CharacterTable( "U5(2)" ) ], [ 1 ] );
1/119
## doc2/probgen.xml (4004-4024)
gap> tblG:= CharacterTable( "U5(2)" );;
gap> tblMG:= CharacterTable( "Cyclic", 3 ) * tblG;;
gap> tblGA:= CharacterTable( "U5(2).2" );;
gap> acts:= PossibleActionsForTypeMGA( tblMG, tblG, tblGA );;
gap> poss:= Concatenation( List( acts, pi ->
> PossibleCharacterTablesOfTypeMGA( tblMG, tblG, tblGA, pi,
> "(3xU5(2)).2" ) ) );
[ rec(
MGfusMGA := [ 1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 11, 12, 12,
13, 13, 14, 14, 15, 15, 16, 17, 17, 18, 18, 19, 20, 21, 21,
22, 22, 23, 23, 24, 24, 25, 25, 26, 27, 27, 28, 28, 29, 29,
30, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
74, 75, 76, 77, 31, 32, 33, 35, 34, 37, 36, 38, 39, 40, 41,
42, 43, 45, 44, 47, 46, 49, 48, 51, 50, 52, 54, 53, 56, 55,
57, 58, 60, 59, 62, 61, 64, 63, 66, 65, 68, 67, 69, 71, 70,
73, 72, 75, 74, 77, 76 ],
table := CharacterTable( "(3xU5(2)).2" ) ) ]
## doc2/probgen.xml (4032-4036)
gap> SigmaFromMaxes( CharacterTable( "O10-(2).2" ), "33AB",
> [ poss[1].table ], [ 1 ], "outer" );
1/595
## doc2/probgen.xml (4129-4137)
gap> t:= CharacterTable( "O12+(2).2" );;
gap> h1:= CharacterTable( "L4(4).2^2" );;
gap> psi:= PossiblePermutationCharacters( h1, t );;
gap> Length( psi );
1
gap> ForAny( psi[1], IsOddInt );
true
## doc2/probgen.xml (4149-4153)
gap> SizesCentralizers( t ){ PositionsProperty(
> OrdersClassRepresentatives( t ), x -> x = 17 ) } / 25;
[ 408/5, 408/5 ]
## doc2/probgen.xml (4171-4176)
gap> h2:= CharacterTable( "S5" ) * CharacterTable( "O8-(2).2" );;
gap> phi:= PossiblePermutationCharacters( h2, t );;
gap> Length( phi );
1
## doc2/probgen.xml (4191-4197)
gap> prim:= Concatenation( psi, phi );;
gap> spos:= Position( OrdersClassRepresentatives( t ), 85 );
213
gap> List( prim, x -> x[ spos ] );
[ 2, 1 ]
## doc2/probgen.xml (4217-4221)
gap> approx:= ApproxP( prim, spos );;
gap> Maximum( approx{ ClassPositionsOfDerivedSubgroup( t ) } );
7675/1031184
## doc2/probgen.xml (4232-4237)
gap> Maximum( approx{ Difference(
> PositionsProperty( OrdersClassRepresentatives( t ), IsPrimeInt ),
> ClassPositionsOfDerivedSubgroup( t ) ) } );
73/1008
## doc2/probgen.xml (4294-4302)
gap> t:= CharacterTable( "O12-(2).2" );;
gap> s1:= CharacterTable( "U4(4).4" );;
gap> pi1:= PossiblePermutationCharacters( s1, t );;
gap> s2:= CharacterTable( "L2(64).6" );;
gap> pi2:= PossiblePermutationCharacters( s2, t );;
gap> prim:= Concatenation( pi1, pi2 );; Length( prim );
2
## doc2/probgen.xml (4311-4315)
gap> spos:= Position( OrdersClassRepresentatives( t ), 65 );;
gap> List( prim, x -> x[ spos ] );
[ 1, 1 ]
## doc2/probgen.xml (4324-4328)
gap> approx:= ApproxP( prim, spos );;
gap> Maximum( approx{ ClassPositionsOfDerivedSubgroup( t ) } );
1/1023
## doc2/probgen.xml (4336-4341)
gap> Maximum( approx{ Difference(
> PositionsProperty( OrdersClassRepresentatives( t ), IsPrimeInt ),
> ClassPositionsOfDerivedSubgroup( t ) ) } );
1/347820
## doc2/probgen.xml (4389-4395)
gap> t:= CharacterTable( "S6(4)" );;
gap> degree:= Size( t ) / ( 2 * Size( CharacterTable( "U4(4)" ) ) );;
gap> pi1:= PermChars( t, rec( torso:= [ degree ] ) );;
gap> Length( pi1 );
1
## doc2/probgen.xml (4408-4427)
gap> CharacterTable( "L2(64).3" ); CharacterTable( "U4(4).2" );
fail
fail
gap> s:= CharacterTable( "L2(64)" );;
gap> subpi:= PossiblePermutationCharacters( s, t );;
gap> Length( subpi );
1
gap> scp:= MatScalarProducts( t, Irr( t ), subpi );;
gap> nonzero:= PositionsProperty( scp[1], x -> x <> 0 );
[ 1, 11, 13, 14, 17, 18, 32, 33, 56, 58, 59, 73, 74, 77, 78, 79, 80,
93, 95, 96, 103, 116, 117, 119, 120 ]
gap> const:= RationalizedMat( Irr( t ){ nonzero } );;
gap> degree:= Size( t ) / ( 3 * Size( s ) );
5222400
gap> pi2:= PermChars( t, rec( torso:= [ degree ], chars:= const ) );;
gap> Length( pi2 );
1
gap> prim:= Concatenation( pi1, pi2 );;
## doc2/probgen.xml (4436-4440)
gap> spos:= Position( OrdersClassRepresentatives( t ), 65 );;
gap> List( prim, x -> x[ spos ] );
[ 1, 1 ]
## doc2/probgen.xml (4448-4451)
gap> Maximum( ApproxP( prim, spos ) );
16/63
## doc2/probgen.xml (4461-4486)
gap> t2:= CharacterTable( "S6(4).2" );;
gap> tfust2:= GetFusionMap( t, t2 );;
gap> cand:= List( prim, x -> CompositionMaps( x, InverseMap( tfust2 ) ) );;
gap> ext:= List( cand, pi -> PermChars( t2, rec( torso:= pi ) ) );
[ [ Character( CharacterTable( "S6(4).2" ),
[ 2016, 512, 96, 128, 32, 120, 0, 6, 16, 40, 24, 0, 8, 136, 1,
6, 6, 1, 32, 0, 8, 6, 2, 0, 2, 0, 0, 4, 0, 16, 32, 1, 8, 2,
6, 2, 1, 2, 4, 0, 0, 1, 6, 0, 1, 10, 0, 1, 1, 0, 10, 10, 4,
0, 1, 0, 2, 0, 2, 1, 2, 2, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0,
0, 0, 0, 32, 0, 0, 8, 0, 0, 0, 0, 8, 8, 0, 0, 0, 0, 8, 0,
0, 0, 2, 2, 0, 2, 2, 0, 2, 2, 2, 0, 0 ] ) ],
[ Character( CharacterTable( "S6(4).2" ),
[ 5222400, 0, 0, 0, 1280, 0, 960, 120, 0, 0, 0, 0, 0, 0, 1600,
0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 1, 0, 0, 15, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
0, 0, 960, 0, 0, 0, 16, 0, 24, 12, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 1, 0, 0, 3, 0, 0, 0, 0, 0 ] ) ] ]
gap> spos2:= Position( OrdersClassRepresentatives( t2 ), 65 );;
gap> sigma:= ApproxP( Concatenation( ext ), spos2 );;
gap> Maximum( approx{ Difference(
> PositionsProperty( OrdersClassRepresentatives( t2 ), IsPrimeInt ),
> ClassPositionsOfDerivedSubgroup( t2 ) ) } );
0
## doc2/probgen.xml (4508-4513)
gap> SigmaFromMaxes( CharacterTable( "S6(4)" ), "85A",
> [ CharacterTable( "L4(4).2_2" ),
> CharacterTable( "A5" ) * CharacterTable( "S4(4)" ) ], [ 1, 1 ] );
142/455
## doc2/probgen.xml (4522-4525)
gap> 16/63 < 142/455;
true
## doc2/probgen.xml (4579-4590)
gap> t:= CharacterTable( "S6(5)" );;
gap> s1:= CharacterTable( "2.A5" );;
gap> s2:= CharacterTable( "2.S4(5)" );;
gap> dp:= s1 * s2;
CharacterTable( "2.A5x2.S4(5)" )
gap> c:= Difference( ClassPositionsOfCentre( dp ), Union(
> GetFusionMap( s1, dp ), GetFusionMap( s2, dp ) ) );
[ 62 ]
gap> s:= dp / c;
CharacterTable( "2.A5x2.S4(5)/[ 1, 62 ]" )
## doc2/probgen.xml (4598-4601)
gap> SigmaFromMaxes( t, "78A", [ s ], [ 1 ] );
9/217
## doc2/probgen.xml (4652-4659)
gap> t:= CharacterTable( "S8(3)" );;
gap> pi:= List( [ "S4(9).2_1", "S4(9).2_2", "S4(9).2_3" ],
> name -> PossiblePermutationCharacters(
> CharacterTable( name ), t ) );;
gap> List( pi, Length );
[ 1, 0, 0 ]
## doc2/probgen.xml (4668-4672)
gap> spos:= Position( OrdersClassRepresentatives( t ), 41 );;
gap> pi[1][1][ spos ];
1
## doc2/probgen.xml (4680-4683)
gap> Maximum( ApproxP( pi[1], spos ) );
1/546
## doc2/probgen.xml (4736-4743)
gap> g:= SU(4,4);;
gap> orbs:= OrbitsDomain( g, NormedRowVectors( GF(16)^4 ), OnLines );;
gap> orblen:= List( orbs, Length );
[ 1105, 3264 ]
gap> List( orblen, x -> x mod 13 );
[ 0, 1 ]
## doc2/probgen.xml (4753-4758)
gap> t:= CharacterTable( "U4(4)" );;
gap> pi:= PermChars( t, rec( torso:= [ orblen[2] ] ) );;
gap> Length( pi );
1
## doc2/probgen.xml (4766-4770)
gap> spos:= Position( OrdersClassRepresentatives( t ), 65 );;
gap> Maximum( ApproxP( pi, spos ) );
209/3264
## doc2/probgen.xml (4828-4853)
gap> t:= CharacterTable( "U6(2)" );;
gap> s1:= CharacterTable( "U5(2)" );;
gap> pi1:= PossiblePermutationCharacters( s1, t );;
gap> Length( pi1 );
1
gap> s2:= CharacterTable( "M22" );;
gap> pi2:= PossiblePermutationCharacters( s2, t );
[ Character( CharacterTable( "U6(2)" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 0, 48, 0, 16, 6, 0, 0, 0, 0,
0, 0, 6, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0, 0,
0, 0, 6, 0, 2, 0, 0, 4, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
[ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 0, 16, 6, 0, 0, 0, 0,
0, 0, 6, 0, 2, 0, 4, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0 ] ) ]
gap> imgs:= Set( pi2, x -> Position( x, 48 ) );
[ 10, 11, 12 ]
gap> AtlasClassNames( t ){ imgs };
[ "4C", "4D", "4E" ]
gap> GetFusionMap( t, CharacterTable( "U6(2).3" ) ){ imgs };
[ 10, 10, 10 ]
gap> prim:= Concatenation( pi1, pi2 );;
## doc2/probgen.xml (4862-4866)
gap> spos:= Position( OrdersClassRepresentatives( t ), 11 );;
gap> List( prim, x -> x[ spos ] );
[ 1, 1, 1, 1 ]
## doc2/probgen.xml (4874-4877)
gap> Maximum( ApproxP( prim, spos ) );
5/21
## doc2/probgen.xml (4887-4892)
gap> PossibleClassFusions(
> CharacterTable( "Cyclic", 3 ) * CharacterTable( "M22" ),
> CharacterTable( "3.U6(2)" ) );
[ ]
## doc2/probgen.xml (4903-4912)
gap> SigmaFromMaxes( CharacterTable( "U6(2).2" ), "11AB",
> [ CharacterTable( "U5(2).2" ), CharacterTable( "M22.2" ) ],
> [ 1, 1 ], "outer" );
5/96
gap> SigmaFromMaxes( CharacterTable( "U6(2).3" ), "11A",
> [ CharacterTable( "U5(2)" ) * CharacterTable( "Cyclic", 3 ) ],
> [ 1 ], "outer" );
59/224
## doc2/probgen.xml (4926-4928)
gap> CleanWorkspace();
## doc2/probgen.xml (4953-4981)
gap> PrimitivesInfoForOddDegreeAlternatingGroup:= function( n )
> local G, max, cycle, spos, prim, nonz;
>
> G:= AlternatingGroup( n );
>
> # Compute representatives of the classes of maximal subgroups.
> max:= MaximalSubgroupClassReps( G );
>
> # Omit subgroups that cannot contain an `n'-cycle.
> max:= Filtered( max, m -> IsTransitive( m, [ 1 .. n ] ) );
>
> # Compute the permutation characters.
> cycle:= [];
> cycle[ n-1 ]:= 1;
> spos:= PositionProperty( ConjugacyClasses( CharacterTable( G ) ),
> c -> CycleStructurePerm( Representative( c ) ) = cycle );
> prim:= List( max, m -> TrivialCharacter( m )^G );
> nonz:= PositionsProperty( prim, x -> x[ spos ] <> 0 );
>
> # Compute the subgroup names and the multiplicities.
> return rec( spos := spos,
> prim := prim{ nonz },
> grps := List( max{ nonz },
> m -> TransitiveGroup( n,
> TransitiveIdentification( m ) ) ),
> mult := List( prim{ nonz }, x -> x[ spos ] ) );
> end;;
## doc2/probgen.xml (4992-5010)
gap> for n in [ 5, 7 .. 23 ] do
> prim:= PrimitivesInfoForOddDegreeAlternatingGroup( n );
> bound:= Maximum( ApproxP( prim.prim, prim.spos ) );
> Print( n, ": ", prim.grps, ", ", prim.mult, ", ", bound, "\n" );
> od;
5: [ D(5) = 5:2 ], [ 1 ], 1/3
7: [ L(7) = L(3,2), L(7) = L(3,2) ], [ 1, 1 ], 2/5
9: [ 1/2[S(3)^3]S(3), L(9):3=P|L(2,8) ], [ 1, 3 ], 9/35
11: [ M(11), M(11) ], [ 1, 1 ], 2/105
13: [ F_78(13)=13:6, L(13)=PSL(3,3), L(13)=PSL(3,3) ], [ 1, 2, 2 ], 4/
1155
15: [ 1/2[S(3)^5]S(5), 1/2[S(5)^3]S(3), L(15)=A_8(15)=PSL(4,2),
L(15)=A_8(15)=PSL(4,2) ], [ 1, 1, 1, 1 ], 29/273
17: [ L(17):4=PYL(2,16), L(17):4=PYL(2,16) ], [ 1, 1 ], 2/135135
19: [ F_171(19)=19:9 ], [ 1 ], 1/6098892800
21: [ t21n150, t21n161, t21n91 ], [ 1, 1, 2 ], 29/285
23: [ M(23), M(23) ], [ 1, 1 ], 2/130945815
## doc2/probgen.xml (5108-5112)
gap> t:= CharacterTable( "A5" );;
gap> ProbGenInfoSimple( t );
[ "A5", 1/3, 2, [ "5A" ], [ 1 ] ]
## doc2/probgen.xml (5123-5130)
gap> OrdersClassRepresentatives( t );
[ 1, 2, 3, 5, 5 ]
gap> PrimitivePermutationCharacters( t );
[ Character( CharacterTable( "A5" ), [ 5, 1, 2, 0, 0 ] ),
Character( CharacterTable( "A5" ), [ 6, 2, 0, 1, 1 ] ),
Character( CharacterTable( "A5" ), [ 10, 2, 1, 0, 0 ] ) ]
## doc2/probgen.xml (5145-5160)
gap> g:= AlternatingGroup( 5 );;
gap> inv:= g.1^2 * g.2;
(1,4)(2,5)
gap> cclreps:= List( ConjugacyClasses( g ), Representative );;
gap> SortParallel( List( cclreps, Order ), cclreps );
gap> List( cclreps, Order );
[ 1, 2, 3, 5, 5 ]
gap> Size( ConjugacyClass( g, inv ) );
15
gap> prop:= List( cclreps,
> r -> RatioOfNongenerationTransPermGroup( g, inv, r ) );
[ 1, 1, 3/5, 1/3, 1/3 ]
gap> Minimum( prop );
1/3
## doc2/probgen.xml (5168-5172)
gap> triple:= [ (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ];;
gap> CommonGeneratorWithGivenElements( g, cclreps, triple );
fail
## doc2/probgen.xml (5247-5251)
gap> t:= CharacterTable( "A6" );;
gap> ProbGenInfoSimple( t );
[ "A6", 2/3, 1, [ "5A" ], [ 2 ] ]
## doc2/probgen.xml (5262-5271)
gap> OrdersClassRepresentatives( t );
[ 1, 2, 3, 3, 4, 5, 5 ]
gap> prim:= PrimitivePermutationCharacters( t );
[ Character( CharacterTable( "A6" ), [ 6, 2, 3, 0, 0, 1, 1 ] ),
Character( CharacterTable( "A6" ), [ 6, 2, 0, 3, 0, 1, 1 ] ),
Character( CharacterTable( "A6" ), [ 10, 2, 1, 1, 2, 0, 0 ] ),
Character( CharacterTable( "A6" ), [ 15, 3, 3, 0, 1, 0, 0 ] ),
Character( CharacterTable( "A6" ), [ 15, 3, 0, 3, 1, 0, 0 ] ) ]
## doc2/probgen.xml (5286-5302)
gap> S:= AlternatingGroup( 6 );;
gap> inv:= (S.1*S.2)^2;
(1,3)(2,5)
gap> cclreps:= List( ConjugacyClasses( S ), Representative );;
gap> SortParallel( List( cclreps, Order ), cclreps );
gap> List( cclreps, Order );
[ 1, 2, 3, 3, 4, 5, 5 ]
gap> C:= ConjugacyClass( S, inv );;
gap> Size( C );
45
gap> prop:= List( cclreps,
> r -> RatioOfNongenerationTransPermGroup( S, inv, r ) );
[ 1, 1, 1, 1, 29/45, 5/9, 5/9 ]
gap> Minimum( prop );
5/9
## doc2/probgen.xml (5311-5314)
gap> ApproxP( prim, 6 );
[ 0, 2/3, 1/2, 1/2, 0, 1/3, 1/3 ]
## doc2/probgen.xml (5322-5326)
gap> triple:= [ (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ];;
gap> CommonGeneratorWithGivenElements( S, cclreps, triple );
fail
## doc2/probgen.xml (5335-5339)
gap> triple:= [ (1,3)(2,4), (1,5)(2,6), (3,6)(4,5) ];;
gap> CommonGeneratorWithGivenElements( S, cclreps, triple );
fail
## doc2/probgen.xml (5347-5352)
gap> TripleWithProperty( [ [ inv ], C, C ],
> l -> ForAll( S, elm ->
> ForAny( l, x -> not IsGeneratorsOfTransPermGroup( S, [ elm, x ] ) ) ) );
[ (1,3)(2,5), (1,3)(2,6), (1,3)(2,4) ]
## doc2/probgen.xml (5361-5370)
gap> s:= (1,2,3,4)(5,6);;
gap> reps:= Filtered( cclreps, x -> Order( x ) > 1 );;
gap> ResetGlobalRandomNumberGenerators();
gap> for pair in UnorderedTuples( reps, 2 ) do
> if RandomCheckUniformSpread( S, pair, s, 40 ) <> true then
> Print( "#E nongeneration!\n" );
> fi;
> od;
## doc2/probgen.xml (5392-5396)
gap> G:= SymmetricGroup( 6 );;
gap> RatioOfNongenerationTransPermGroup( G, s, (1,2) );
1
## doc2/probgen.xml (5411-5422)
gap> goods:= Filtered( Elements( G ),
> s -> IsGeneratorsOfTransPermGroup( G, [ s, (1,2) ] ) and
> IsGeneratorsOfTransPermGroup( G, [ s, (3,4) ] ) );;
gap> Collected( List( goods, CycleStructurePerm ) );
[ [ [ ,,,, 1 ], 24 ] ]
gap> goods:= Filtered( Elements( G ),
> s -> IsGeneratorsOfTransPermGroup( G, [ s, (1,2)(3,4)(5,6) ] ) and
> IsGeneratorsOfTransPermGroup( G, [ s, (1,3)(2,4)(5,6) ] ) );;
gap> Collected( List( goods, CycleStructurePerm ) );
[ [ [ 1, 1 ], 24 ] ]
## doc2/probgen.xml (5440-5455)
gap> Sgens:= GeneratorsOfGroup( S );;
--> --------------------
--> maximum size reached
--> --------------------
[ Dauer der Verarbeitung: 0.56 Sekunden
(vorverarbeitet)
]
|
2026-04-02
|
