Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/GAP/pkg/ctbllib/tst/   (GAP Algebra Version 4.15.1©)  Datei vom 19.4.2025 mit Größe 87 kB image not shown  

Quelle  ctblpope.tst   Sprache: unbekannt

 
Spracherkennung für: .tst vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]

# This file was created automatically, do not edit!
#############################################################################
##
#W  ctblpope.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( "ctblpope.tst" );'.
##  
gap> LoadPackage( "CTblLib", false );
true
gap> save:= SizeScreen();;
gap> SizeScreen( [ 72 ] );;
gap> START_TEST( "ctblpope.tst" );

##
gap> if IsBound( BrowseData ) then
>      data:= BrowseData.defaults.dynamic.replayDefaults;
>      oldinterval:= data.replayInterval;
>      data.replayInterval:= 1;
>    fi;

##  doc2/ctblpope.xml (76-79)
gap> LoadPackage( "ctbllib", "1.2", false );
true

##  doc2/ctblpope.xml (91-98)
gap> g:= MathieuGroup( 24 );;
gap> SetName( g, "m24" );
gap> Size( g );  IsSimple( g );  NrMovedPoints( g );
244823040
true
24

##  doc2/ctblpope.xml (109-117)
gap> ccl:= AttributeValueNotSet( ConjugacyClasses, g );;
gap> HasConjugacyClasses( g );
false
gap> invariants:= List( ccl, c -> [ Order( Representative( c ) ),
>        Size( c ), Size( ConjugacyClass( g, Representative( c )^2 ) ) ] );;
gap> SortParallel( invariants, ccl );
gap> SetConjugacyClasses( g, ccl );

##  doc2/ctblpope.xml (127-162)
gap> NrConjugacyClasses( g );
26
gap> pi:= NaturalCharacter( g );
Character( CharacterTable( m24 ),
 [ 24806004042033202001111
  0011 ] )
gap> IsTransitive( pi );  Transitivity( pi );
true
5
gap> SetIdentifier( CharacterTable( g ), "M24table" );
gap> Display( pi );
M24table

     2 10 10  9  3  3  7  7  5  2  3  3  1  1  4   2   .   2   2   1
     3  3  1  1  3  2  1  .  1  1  1  1  1  1  .   .   .   1   1   .
     5  1  .  1  1  .  .  .  .  1  .  .  .  .  .   1   .   .   .   .
     7  1  1  .  .  1  .  .  .  .  .  .  1  1  .   .   .   .   .   1
    11  1  .  .  .  .  .  .  .  .  .  .  .  .  .   .   1   .   .   .
    23  1  .  .  .  .  .  .  .  .  .  .  .  .  .   .   .   .   .   .

       122334445667781011121214a

Y.1    24  8  .  6  .  .  4  .  4  2  .  3  3  2   .   2   .   .   1

     2   1   .   .   .   .   .   .
     3   .   1   1   1   1   .   .
     5   .   1   1   .   .   .   .
     7   1   .   .   1   1   .   .
    11   .   .   .   .   .   .   .
    23   .   .   .   .   .   1   1

       14151521212323b

Y.1      1   1   1   .   .   1   1

##  doc2/ctblpope.xml (179-192)
gap> piop:= pi * pi;
Character( CharacterTable( m24 ),
 [ 57664036001601640994040011
  110011 ] )
gap> IsTransitive( piop );
false
gap> piup:= SymmetricParts( UnderlyingCharacterTable(pi), [ pi ], 2 )[1];
Character( CharacterTable( m24 ),
 [ 300441221041201050664230122
  110011 ] )
gap> IsTransitive( piup );
false

##  doc2/ctblpope.xml (203-214)
gap> ScalarProduct( piup, TrivialCharacter( g ) );
2
gap> comb:= Combinations( [ 1 .. 24 ], 2 );;
gap> hom:= ActionHomomorphism( g, comb, OnSets );;
gap> pihom:= NaturalCharacter( hom );
Character( CharacterTable( m24 ),
 [ 2763612150480630332210111
  000000 ] )
gap> Transitivity( pihom );
1

##  doc2/ctblpope.xml (227-237)
gap> pi2s:= piup - pi;
VirtualCharacter( CharacterTable( m24 ),
 [ 2763612150480630332210111
  000000 ] )
gap> pi2s = pihom;
true
gap> HasIrr( g );  HasIrr( CharacterTable( g ) );
false
false

##  doc2/ctblpope.xml (253-256)
gap> IsPrimitive( g, comb, OnSets );
true

##  doc2/ctblpope.xml (274-286)
gap> tbl:= CharacterTable( "M24" );
CharacterTable( "M24" )
gap> maxes:= Maxes( tbl );
[ "M23", "M22.2", "2^4:a8", "M12.2", "2^6:3.s6", "L3(4).3.2_2", 
  "2^6:(psl(3,2)xs3)", "L2(23)", "L3(2)" ]
gap> s:= CharacterTable( maxes[2] );
CharacterTable( "M22.2" )
gap> TrivialCharacter( s )^tbl;
Character( CharacterTable( "M24" ),
 [ 2763612150480630332211011
  000000 ] )

##  doc2/ctblpope.xml (312-357)
gap> m11:= CharacterTable( "M11" );;
gap> SetName( m11, "m11" );
gap> perms:= PermChars( m11 );
[ Character( m11, [ 1111111111 ] ), Character( m11,
  [ 11323101100 ] ), Character( m11,
  [ 12430210011 ] ), Character( m11,
  [ 22642200000 ] ), Character( m11,
  [ 55713011100 ] ), Character( m11,
  [ 661032110000 ] ), Character( m11,
  [ 110622002200 ] ), Character( m11,
  [ 110626000000 ] ), Character( m11,
  [ 1101422020000 ] ), Character( m11,
  [ 1321260200000 ] ), Character( m11,
  [ 144000400011 ] ), Character( m11,
  [ 1651331011100 ] ), Character( m11,
  [ 220440040000 ] ), Character( m11,
  [ 2201244000000 ] ), Character( m11,
  [ 2202040020000 ] ), Character( m11,
  [ 330262020000 ] ), Character( m11,
  [ 3301862000000 ] ), Character( m11,
  [ 3961204100000 ] ), Character( m11,
  [ 440880020000 ] ), Character( m11,
  [ 4402480000000 ] ), Character( m11,
  [ 4951503001100 ] ), Character( m11,
  [ 660434010000 ] ), Character( m11,
  [ 6601230030000 ] ), Character( m11,
  [ 66012120000000 ] ), Character( m11,
  [ 6602830010000 ] ), Character( m11,
  [ 720000000055 ] ), Character( m11,
  [ 7922400200000 ] ), Character( m11,
  [ 8800160000000 ] ), Character( m11,
  [ 990602002200 ] ), Character( m11,
  [ 990606000000 ] ), Character( m11,
  [ 9903002000000 ] ), Character( m11,
  [ 1320860020000 ] ), Character( m11,
  [ 13202460000000 ] ), Character( m11,
  [ 1584000400000 ] ), Character( m11,
  [ 19801204000000 ] ), Character( m11,
  [ 19803600000000 ] ), Character( m11,
  [ 26400120000000 ] ), Character( m11,
  [ 39602400000000 ] ), Character( m11,
  [ 7920000000000 ] ) ]
gap> Length( perms );
39

##  doc2/ctblpope.xml (374-382)
gap> degrees:= DivisorsInt( Size( m11 ) );;
gap> perms2:= [];;
gap> for d in degrees do
>      Append( perms2, PermChars( m11, d ) );
>    od;
gap> Set( perms ) = Set( perms2 );
true

##  doc2/ctblpope.xml (391-398)
gap> perms3:= [];;
gap> for d in degrees do
>      Append( perms3, PermChars( m11, rec( torso:= [ d ] ) ) );
>    od;
gap> Set( perms ) = Set( perms3 );
true

##  doc2/ctblpope.xml (412-421)
gap> newperms:= TestPerm4( m11, perms );;
gap> newperms = perms;
true
gap> newperms:= TestPerm5( m11, perms, m11 mod 11 );;
gap> newperms = perms;
false
gap> Difference( perms, newperms );
[ Character( m11, [ 220440040000 ] ) ]

##  doc2/ctblpope.xml (433-444)
gap> tom:= TableOfMarks( "M11" );
TableOfMarks( "M11" )
gap> trueperms:= PermCharsTom( m11, tom );;
gap> Length( trueperms );  Length( Set( trueperms ) );
39
36
gap> Difference( perms, trueperms );
[ Character( m11, [ 220440040000 ] ), 
  Character( m11, [ 660434010000 ] ), 
  Character( m11, [ 6601230030000 ] ) ]

##  doc2/ctblpope.xml (466-478)
gap> u62:= CharacterTable( "U6(2)" );;
gap> m22:= CharacterTable( "M22" );;
gap> fus:= PossibleClassFusions( m22, u62 );
[ [ 137101415222424263334 ], 
  [ 137101415222424263433 ], 
  [ 137111415222424273334 ], 
  [ 137111415222424273433 ], 
  [ 137121415222424283334 ], 
  [ 137121415222424283433 ] ]
gap> RepresentativesFusions( m22, fus, u62 );
[ [ 137101415222424263334 ] ]

##  doc2/ctblpope.xml (487-512)
gap> cand:= Set( fus,
>  x -> Induced( m22, u62, [ TrivialCharacter( m22 ) ], x )[1] );
[ Character( CharacterTable( "U6(2)" ),
  [ 2073603840005400004801660000
      006020004000011000000
      000000 ] ), Character( CharacterTable( "U6(2)" ),
  [ 2073603840005400048001660000
      006020040000011000000
      000000 ] ), Character( CharacterTable( "U6(2)" ),
  [ 2073603840005400480001660000
      006020400000011000000
      000000 ] ) ]
gap> PermCharInfo( u62, cand ).ATLAS;
[ "1a+22a+252a+616a+1155c+1386a+8064a+9240c", 
  "1a+22a+252a+616a+1155b+1386a+8064a+9240b", 
  "1a+22a+252a+616a+1155a+1386a+8064a+9240a" ]
gap> aut:= AutomorphismsOfTable( u62 );;  Size( aut );
24
gap> elms:= Filtered( Elements( aut ), x -> Order( x ) = 3 );
[ (10,11,12)(26,27,28)(40,41,42), (10,12,11)(26,28,27)(40,42,41) ]
gap> Position( cand, Permuted( cand[1], elms[1] ) );
3
gap> Position( cand, Permuted( cand[3], elms[1] ) );
2

##  doc2/ctblpope.xml (534-548)
gap> u622:= CharacterTable( "U6(2).2" );;
gap> m222:= CharacterTable( "M22.2" );;
gap> fus:= PossibleClassFusions( m222, u622 );
[ [ 1371013142022222429383942414650
      53585959 ] ]
gap> cand:= Induced( m222, u622, [ TrivialCharacter( m222 ) ], fus[1] );
[ Character( CharacterTable( "U6(2).2" ),
  [ 2073603840005400480016600000
      602040000100000000108072
      0488000180008002000022
      000000 ] ) ]
gap> PermCharInfo( u622, cand ).ATLAS;
[ "1a+22a+252a+616a+1155a+1386a+8064a+9240a" ]

##  doc2/ctblpope.xml (673-747)
gap> o8p3:= CharacterTable("O8+(3)");;
gap> Size( o8p3 ) / (2^9*168);
57572775
gap> o8p2:= CharacterTable( "O8+(2)" );;
gap> fus:= PossibleClassFusions( o8p2, o8p3 );;
gap> Length( fus );
24
gap> rep:= RepresentativesFusions( o8p2, fus, o8p3 );
[ [ 1523457812161719232021222324
      25263738423132364952515043444553
      55565771717172737478798388899094
      100101105 ] ]
gap> fus:= rep[1];;
gap> Size( o8p2 ) / (2^9*168);
2025
gap> sub:= CharacterTable( "2^6:A8" );;
gap> subfus:= GetFusionMap( sub, o8p2 );
1322456133612131472124113029
  3113171516141736371841244448283332
  3435355151 ]
gap> fus:= CompositionMaps( fus, subfus );
1255345232519232073731175051
  4323232122202356572472317889524544
  535555100100 ]
gap> Size( sub ) / (2^9*168);
15
gap> List( Irr( sub ), Degree );
17142021212128354545566470282835
  35353570707070140140140140140210210252
  252280280315315315315420448 ]
gap> cand:= PermChars( sub, 15 );
[ Character( CharacterTable( "2^6:A8" ),
  [ 151515777773333300033333
      33311110000011111100 ] ) ]
gap> ind:= Induced( sub, o8p3, cand, fus );
[ Character( CharacterTable( "O8+(3)" ),
  [ 575727755953559535595353591000000000
      00218702713513513524300000000
      00000000000272727000027
      27272708110000000000000
      000000000000000000000
      000000000000000000000
      00 ] ) ]
gap> o8p33:= CharacterTable( "O8+(3).3" );;
gap> inv:= InverseMap( GetFusionMap( o8p3, o8p33 ) );
1, [ 234 ], 56, [ 789 ], [ 101112 ], 13
  [ 141516 ], 171819, [ 202122 ], 23, [ 242526 ], 
  [ 272829 ], 30, [ 313233 ], [ 343536 ], [ 373839 ], 
  [ 404142 ], [ 434445 ], 46, [ 474849 ], 50
  [ 515253 ], 54555657, [ 585960 ], [ 616263 ], 64
  [ 656667 ], 68, [ 697071 ], [ 727374 ], [ 757677 ], 
  [ 787980 ], [ 818283 ], 8485, [ 868788 ], 
  [ 899091 ], [ 929394 ], 9596, [ 979899 ], 
  [ 100101102 ], [ 103104105 ], [ 106107108 ], 
  [ 109110111 ], [ 112113114 ] ]
gap> ext:= CompositionMaps( ind[1], inv );
5757277559535359100000218702713524300
  000002700272708110000000
  0000000000000000 ]
gap> perms:= PermChars( o8p33, rec( torso:= ext ) );
[ Character( CharacterTable( "O8+(3).3" ),
  [ 575727755953535910000021870271352430
      00000027002727081100000
      0000000000000000003159
      315924324339393300000000333
      333000000221111000000
      00 ] ) ]
gap> PermCharInfo( o8p33, perms ).ATLAS;
[ "1a+780aabb+2457a+2808abc+9450aaabbcc+18200abcdddef+24192a+54600a^{5\
}b+70200aabb+87360ab+139776a^{5}+147420a^{4}b^{4}+163800ab+184275aabc+\
199017aa+218700a+245700a+291200aef+332800a^{4}b^{5}c^{5}+491400aaabcd+\
531441a^{5}b^{4}c^{4}+552825a^{4}+568620aabb+698880a^{4}b^{4}+716800aa\
abbccdddeeff+786240aabb+873600aa+998400aa+1257984a^{6}+1397760aa" ]

##  doc2/ctblpope.xml (777-783)
gap> o73:= CharacterTable( "O7(3)" );;
gap> a7:= CharacterTable( "A7" );;
gap> fus:= PossibleClassFusions( a7, o73 );
[ [ 136101516243333 ], 
  [ 137101516223333 ] ]

##  doc2/ctblpope.xml (794-810)
gap> ind:= List( fus,
>       x -> Induced( a7, o73, [ TrivialCharacter( a7 ) ], x )[1] );;
gap> mat:= MatScalarProducts( o73, Irr( o73 ), ind );;
gap> sum:= Sum( mat );
26208624483044935009010
  561511211572414160121278814
  121214662016121212101012128126 ]
gap> const:= Filtered( [ 1 .. Length( sum ) ], x -> sum[x] <> 0 );
123567891011131415161720222324
  2526272829303132333436373839404142
  43444546474849505152535455565758 ]
gap> Length( const );
52
gap> const:= Irr( o73 ){ const };;
gap> rat:= RationalizedMat( const );;

##  doc2/ctblpope.xml (819-837)
gap> names:= ClassNames( o73 );
[ "1a", "2a", "2b", "2c", "3a", "3b", "3c", "3d", "3e", "3f", "3g", 
  "4a", "4b", "4c", "4d", "5a", "6a", "6b", "6c", "6d", "6e", "6f", 
  "6g", "6h", "6i", "6j", "6k", "6l", "6m", "6n", "6o", "6p", "7a", 
  "8a", "8b", "9a", "9b", "9c", "9d", "10a", "10b", "12a", "12b", 
  "12c", "12d", "12e", "12f", "12g", "12h", "13a", "13b", "14a", 
  "15a", "18a", "18b", "18c", "18d", "20a" ]
gap> List( fus, x -> names{ x } );
[ [ "1a", "2b", "3b", "3f", "4d", "5a", "6h", "7a", "7a" ], 
  [ "1a", "2b", "3c", "3f", "4d", "5a", "6f", "7a", "7a" ] ]
gap> torso:= [ 28431 ];;
gap> zeros:= [ 58911172023282932363738,
>              43464748535455565758 ];;
gap> names{ zeros };
[ "3a", "3d", "3e", "3g", "6a", "6d", "6g", "6l", "6m", "6p", "9a", 
  "9b", "9c", "12b", "12e", "12f", "12g", "15a", "18a", "18b", "18c", 
  "18d", "20a" ]

##  doc2/ctblpope.xml (854-869)
gap> for i in zeros do
>      torso[i]:= 0;
>    od;
gap> torso;
28431,,,, 0,,, 00,, 0,,,,,, 0,,, 0,,, 0,,,,, 00,,, 0,,,, 00
  0,,,,, 0,,, 000,,,,, 000000 ]
gap> perms:= PermChars( o73, rec( torso:= torso, chars:= rat ) );
[ Character( CharacterTable( "O7(3)" ),
  [ 28431567567111002430081015327156
      0027032700039003304110
      000223030000000000000
      0 ] ) ]
gap> PermCharInfo( o73, perms ).ATLAS;
[ "1a+78a+168a+182a+260ab+1092a+2457a+2730a+4095b+5460a+11648a" ]

##  doc2/ctblpope.xml (895-917)
gap> o8p3:= CharacterTable( "O8+(3)" );;
gap> o8p2:= CharacterTable( "O8+(2)" );;
gap> fus:= PossibleClassFusions( o8p2, o8p3 );;
gap> NamesOfFusionSources( o8p2 );
[ "A9", "2^8:O8+(2)", "(D10xD10).2^2", "(3x3^3:S3):2", 
  "(3x3^(1+2)+:2A4).2", "2^(3+3+3).L3(2)", "NRS(O8+(2),2^(3+3+3)_a)", 
  "NRS(O8+(2),2^(3+3+3)_b)", "O8+(2)N2", "O8+(2)M2", "O8+(2)M3", 
  "O8+(2)M5", "O8+(2)M6", "O8+(2)M8", "O8+(2)M9", "(3xU4(2)):2", 
  "O8+(2)M11", "O8+(2)M12", "2^(1+8)_+:(S3xS3xS3)", "3^4:2^3.S4(a)", 
  "(A5xA5):2^2", "O8+(2)M16", "O8+(2)M17", "2^(1+8)+.O8+(2)", "7:6", 
  "(A5xD10).2", "(D10xA5).2", "O8+(2)N5C", "2^6:A8", "2.O8+(2)", 
  "2^2.O8+(2)", "S6(2)" ]
gap> sub:= CharacterTable( "2^6:A8" );;
gap> subfus:= GetFusionMap( sub, o8p2 );
1322456133612131472124113029
  3113171516141736371841244448283332
  3435355151 ]
gap> fus:= List( fus, x -> CompositionMaps( x, subfus ) );;
gap> fus:= Set( fus );;
gap> Length( fus );
24

##  doc2/ctblpope.xml (926-932)
gap> ind:= List( fus, x -> Induced( sub, o8p3,
>                              [ TrivialCharacter( sub ) ], x )[1] );;
gap> ind:= Set( ind );;
gap> Length( ind );
6

##  doc2/ctblpope.xml (942-957)
gap> o8p32:= CharacterTable( "O8+(3).2_1" );;
gap> fus:= GetFusionMap( o8p3, o8p32 );;
gap> ext:= List( ind, x -> CompositionMaps( x, InverseMap( fus ) ) );;
gap> ext:= Filtered( ext, x -> ForAll( x, IsInt ) );
[ [ 3838185175778505850587300006561007290
      910545451053000000000018900
      09927270027908110000000
      020000000090000003000
      0000060000000 ], 
  [ 3838185175778505850587306561000007290
      910545451053000000018900090
      00927270092708110000000
      020000090000003000000
      0060000000000 ] ]

##  doc2/ctblpope.xml (970-985)
gap> perms:= PermChars( o8p32, rec( torso:= ext[1] ) );
[ Character( CharacterTable( "O8+(3).2_1" ),
  [ 3838185175778505850587300006561007290
      910545451053000000000018900
      09927270027908110000000
      020000000090000003000
      0000060000000315915755676387
      150045081927003333550004
      0027090015030020000030
      0000000000000 ] ) ]
gap> PermCharInfo( o8p32, perms ).ATLAS;
[ "1a+260abc+520ab+819a+2808b+9450aab+18200a+23400ac+29120b+36400aab+4\
6592abce+49140d+66339a+98280ab+163800a+189540d+232960d+332800ab+368550\
a+419328a+531441ab" ]

##  doc2/ctblpope.xml (994-1013)
gap> o8p32:= CharacterTable( "O8+(3).2_2" );;
gap> fus:= GetFusionMap( o8p3, o8p32 );;
gap> ext:= List( ind, x -> CompositionMaps( x, InverseMap( fus ) ) );;
gap> ext:= Filtered( ext, x -> ForAll( x, IsInt ) );;
gap> perms:= PermChars( o8p32, rec( torso:= ext[1] ) );
[ Character( CharacterTable( "O8+(3).2_2" ),
  [ 38381851757785058730006561000072909
      105451053000000018900090927
      0002727908110000000000
      200000900000003000000
      06000000019901720252974417390
      12150000081000027270191200
      4500100310000000000210
      00000 ] ) ]
gap> PermCharInfo( o8p32, perms ).ATLAS;
[ "1a+260aac+520ab+819a+2808a+9450aaa+18200accee+23400ac+29120a+36400a\
+46592aa+49140c+66339a+93184a+98280ab+163800a+184275ac+189540c+232960c\
+332800aa+419328a+531441aa" ]

##  doc2/ctblpope.xml (1026-1049)
gap> o8p322:= CharacterTable( "O8+(3).(2^2)_{122}" );;
gap> fus:= GetFusionMap( o8p32, o8p322 );;
gap> ext:= List( perms, x -> CompositionMaps( x, InverseMap( fus ) ) );;
gap> ext:= Filtered( ext, x -> ForAll( x, IsInt ) );;
gap> perms:= PermChars( o8p322, rec( torso:= ext[1] ) );
[ Character( CharacterTable( "O8+(3).(2^2)_{122}" ),
  [ 383818517577850587300065610072909105
      45105300000001890099270027
      908110000000200000900
      000300000060000031591575
      56763871500450819270033350
      0400270900150300200030
      000000000019901720252974417390
      12150000810002727019120045
      001003100000002100000
      02843116471356387390024327008163
      000903362000900333040
      000000000020 ] ) ]
gap> PermCharInfo( o8p322, perms ).ATLAS;
[ "1a+260ace+819a+1040a+2808c+9450aac+18200a+23400ae+29120c+36400aac+4\
6592ac+49140g+66339a+93184a+163800b+189540g+196560a+232960g+332800ac+3\
68550a+419328a+531441ac" ]

##  doc2/ctblpope.xml (1079-1083)
gap> s444:= CharacterTable( "S4(4).4" );;
gap> NamesOfFusionSources( s444 );
[ "(L3(2)xS4(4):2).2", "S4(4)", "S4(4).2" ]

##  doc2/ctblpope.xml (1093-1105)
gap> perms:= PermChars( s444,
>                rec( torso:= [ Size( s444 ) / ( 5^2*2^5 ) ] ) );
[ Character( CharacterTable( "S4(4).4" ),
  [ 4896384960163236160400000000
      000000000000 ] ), 
  Character( CharacterTable( "S4(4).4" ),
  [ 489619232008610200360120001
      06622000011 ] ), 
  Character( CharacterTable( "S4(4).4" ),
  [ 4896240640883616000001280440
      00000000000 ] ) ]

##  doc2/ctblpope.xml (1116-1121)
gap> PermCharInfo( s444, perms ).ATLAS;
[ "1abcd+50abcd+153abcd+170a^{4}b^{4}+680aabb", 
  "1a+50ac+153a+170aab+256a+680abb+816a+1020a", 
  "1ac+50ac+68a+153abcd+170aabbb+204a+680abb+1020a" ]

##  doc2/ctblpope.xml (1147-1150)
gap> t:= CharacterTable( "Co1" );
CharacterTable( "Co1" )

##  doc2/ctblpope.xml (1162-1169)
gap> s:= CharacterTable( Maxes( t )[5] );
CharacterTable( "2^(1+8)+.O8+(2)" )
gap> ind:= Induced( s, t, [ TrivialCharacter( s ) ] );;
gap> PermCharInfo( t, ind ).ATLAS;
[ "1a+299a+17250a+27300a+80730a+313950a+644644a+2816856a+5494125a+1243\
2420a+24794000a" ]

##  doc2/ctblpope.xml (1181-1189)
gap> centorder:= SizesCentralizers( t )[3];;
gap> maxes:= List( Maxes( t ), CharacterTable );;
gap> cand:= Filtered( maxes, x -> Size( x ) mod centorder = 0 );
[ CharacterTable( "(A4xG2(4)):2" ) ]
gap> u:= cand[1];;
gap> index:= Size( u ) / centorder;
3

##  doc2/ctblpope.xml (1210-1236)
gap> subperm:= PermChars( u, rec( degree := index, bounds := false ) );
[ Character( CharacterTable( "(A4xG2(4)):2" ),
  [ 3333333333333333333333
      331111111111111111333
      333333333333333333333
      000000000000000000000
      000000000001111111111
      111111 ] ) ]
gap> subperm = PermChars( u, rec( torso := [ 3 ] ) );
true
gap> ind:= Induced( u, t, subperm );
[ Character( CharacterTable( "Co1" ),
  [ 20656944001814401194083801627799200037830240
      86407203168025203006480150800000
      3818105060012056240120001204818
      00603601441080010000004239
      001530044000000300000
      1280600301033000000003
      0 ] ) ]
gap> PermCharInfo( t, ind ).ATLAS;
[ "1a+1771a+8855a+27300aa+313950a+345345a+644644aa+871884aaa+1771000a+\
2055625a+4100096a+7628985a+9669660a+12432420aa+21528000aa+23244375a+24\
174150aa+24794000a+31574400aa+40370176a+60435375a+85250880aa+100725625\
a+106142400a+150732800a+184184000a+185912496a+207491625a+299710125a+30\
2176875a" ]

##  doc2/ctblpope.xml (1244-1248)
gap> centorder:= SizesCentralizers( t )[4];;
gap> cand:= Filtered( maxes, x -> Size( x ) mod centorder = 0 );
[ CharacterTable( "Co2" ), CharacterTable( "2^11:M24" ) ]

##  doc2/ctblpope.xml (1258-1269)
gap> u:= cand[1];;
gap> GetFusionMap( u, t );
12247691111101112141716212320
  2222242830333132333337424143444852
  4953555352546060606465656766707372
  7879848587929393 ]
gap> centorder;
389283840
gap> SizesCentralizers( u )[4];
1474560

##  doc2/ctblpope.xml (1277-1307)
gap> u:= cand[2];
CharacterTable( "2^11:M24" )
gap> index:= Size( u ) / centorder;
1288
gap> subperm:= PermChars( u, rec( torso := [ index ] ) );
[ Character( CharacterTable( "2^11:M24" ),
  [ 128812881288565656565656484848484810
      10101077888888444444444
      443332222223330000222
      233311222211000000000
      000 ] ) ]
gap> subperm = PermChars( u, rec( degree:= index, bounds := false ) );
true
gap> ind:= Induced( u, t, subperm );
[ Character( CharacterTable( "Co1" ),
  [ 1068057900019882801965609474401701009457560
      343222801728252308022500027003060
      4645250012032125236360000045
      150930000180300618035000
      000002200003000010000
      60200000000000000000 ] ) ]
gap> PermCharInfo( t, ind ).ATLAS;
[ "1a+17250aa+27300a+80730aa+644644aaa+871884a+1821600a+2055625aaa+281\
6856a+5494125a^{4}+12432420aa+16347825aa+23244375a+24174150aa+24667500\
aa+24794000aaa+31574400a+40370176a+55255200a+66602250a^{4}+83720000aa+\
85250880aaa+91547820aa+106142400a+150732800a+184184000aaa+185912496aaa\
+185955000aaa+207491625aaa+215547904aa+241741500aaa+247235625a+2578576\
00aa+259008750a+280280000a+302176875a+326956500a+387317700a+402902500a\
+464257024a+469945476b+502078500a+503513010a+504627200a+522161640a" ]

##  doc2/ctblpope.xml (1330-1351)
gap> t:= CharacterTable( "G2(3)" );
CharacterTable( "G2(3)" )
gap> t:= CharacterTable( "G2(3)" );;
gap> n:= Length( RationalizedMat( Irr( t ) ) );;
gap> maxmult:= List( [ 1 .. n ], i -> 1 );;
gap> perms:= [];;
gap> divs:= DivisorsInt( Size( t ) );;
gap> for d in divs do
>      Append( perms,
>              PermChars( t, rec( bounds  := false,
>                                 degree  := d,
>                                 maxmult := maxmult ) ) );
>    od;
gap> Length( perms );
42
gap> List( perms, Degree );
1351351364364378378546546546546546702702
  728728109210921092109210921092109210921456
  14561638163821842184245724572457245731593276
  327632763276436865526552 ]

##  doc2/ctblpope.xml (1370-1384)
gap> tom:= TableOfMarks( "G2(3)" );
TableOfMarks( "G2(3)" )
gap> tbl:= CharacterTable( "G2(3)" );
CharacterTable( "G2(3)" )
gap> permstom:= PermCharsTom( tbl, tom );;
gap> Length( permstom );
433
gap> multfree:= Intersection( perms, permstom );;
gap> Length( multfree );
15
gap> List( multfree, Degree );
135135136436437837870270272872810921092
  21842184 ]

##  doc2/ctblpope.xml (1404-1409)
gap> tbl2:= CharacterTable("O8+(2).2");;
gap> s3:= CharacterTable( "Symmetric", 3 );;
gap> s:= CharacterTableWreathSymmetric( s3, 4 );
CharacterTable( "Sym(3)wrS4" )

##  doc2/ctblpope.xml (1419-1442)
gap> fus:= PossibleClassFusions( s, tbl2 );
[ [ 1416348942195185502449724422
      421253175821547265037522360184
      462514612095330512664852311356
      38 ] ]
gap> pi:= Induced( s, tbl2, [ TrivialCharacter( s ) ], fus[1] )[1];
Character( CharacterTable( "O8+(2).2" ),
 [ 112002561601608040407613008840016
  16444111150001100000220
  0112096016016810467123002040
  11001000 ] )
gap> PermCharInfo( tbl2, pi ).ATLAS;
[ "1a+84a+168a+175a+300a+700c+972a+1400a+3200a+4200b" ]
gap> tbl:= CharacterTable( "O8+(2)" );
CharacterTable( "O8+(2)" )
gap> rest:= RestrictedClassFunction( pi, tbl );
Character( CharacterTable( "O8+(2)" ),
 [ 1120025616016016080404040761300888
  400016161644441111115000
  1110000000222000 ] )
gap> PermCharInfo( tbl, rest ).ATLAS;
[ "1a+84abc+175a+300a+700bcd+972a+3200a+4200a" ]

##  doc2/ctblpope.xml (1463-1489)
gap> tbl:= CharacterTable( "M22" );
CharacterTable( "M22" )
gap> perms:= PermChars( tbl, rec( torso:= [ 56 ] ) );
[ Character( CharacterTable( "M22" ),
  [ 5682401200211 ] ) ]
gap> pi:= perms[1];;
gap> Norm( pi );
2
gap> Display( tbl, rec( chars:= perms ) );
M22

     2  7  7  2  5  4  .  2  .  .  3   .   .
     3  2  1  2  .  .  .  1  .  .  .   .   .
     5  1  .  .  .  .  1  .  .  .  .   .   .
     7  1  .  .  .  .  .  .  1  1  .   .   .
    11  1  .  .  .  .  .  .  .  .  .   1   1

       12344567781111b
    211322537741111a
    312144527781111b
    512344167781111b
    712344561181111a
   111234456778a  1a  1a

Y.1    56  8  2  4  .  1  2  .  .  2   1   1

##  doc2/ctblpope.xml (1501-1505)
gap> perms:= PermChars( tbl, rec( torso:= [ 56 * 55 ] ) );;
gap> Length( perms );
16

##  doc2/ctblpope.xml (1517-1529)
gap> OrdersClassRepresentatives( tbl );
12344567781111 ]
gap> perms:= Filtered( perms, x -> x[5] = 0 and x[10] <> 0 );
[ Character( CharacterTable( "M22" ),
  [ 30805621200200200 ] ), 
  Character( CharacterTable( "M22" ),
  [ 308082800200400 ] ), 
  Character( CharacterTable( "M22" ),
  [ 30802411400300200 ] ), 
  Character( CharacterTable( "M22" ),
  [ 30802420400000200 ] ) ]

##  doc2/ctblpope.xml (1539-1569)
gap> infoperms:= PermCharInfo( tbl, perms );;
gap> Display( tbl, infoperms.display );
M22

      2    7  7  2  5  2  3
      3    2  1  2  .  1  .
      5    1  .  .  .  .  .
      7    1  .  .  .  .  .
     11    1  .  .  .  .  .

          123468a
     2P   113234a
     3P   121428a
     5P   123468a
     7P   123468a
    11P   123468a

I.1     3080 56  2 12  2  2
I.2        1 21  8 54 24 36
I.3        1  3  4  9 12 18
I.4     3080  8  2  8  2  4
I.5        1  3  8 36 24 72
I.6        1  3  4  9 12 18
I.7     3080 24 11  4  3  2
I.8        1  9 44 18 36 36
I.9        1  3  4  9 12 18
I.10    3080 24 20  4  .  2
I.11       1  9 80 18  . 36
I.12       1  3  4  9 12 18

##  doc2/ctblpope.xml (1659-1670)
gap> ly:= CharacterTable( "Ly" );;
gap> mcl:= CharacterTable( "McL" );;
gap> mcl2:= CharacterTable( "McL.2" );;
gap> 3mcl2:= CharacterTable( "3.McL.2" );;
gap> perms:= PermChars( mcl, rec( degree:= 15400 ) );
[ Character( CharacterTable( "McL" ),
  [ 1540056911012250112002111003
      001111 ] ), Character( CharacterTable( "McL" ),
  [ 1540028010372005101002110002
      000000 ] ) ]

##  doc2/ctblpope.xml (1682-1692)
gap> ord10:= Filtered( [ 1 .. NrConjugacyClasses( mcl ) ],
>                      i -> OrdersClassRepresentatives( mcl )[i] = 10 );
15 ]
gap> List( perms, pi -> pi[ ord10[1] ] );
10 ]
gap> pi:= perms[1];
Character( CharacterTable( "McL" ),
 [ 15400569110122501120021110030
  01111 ] )

##  doc2/ctblpope.xml (1707-1722)
gap> map:= InverseMap( GetFusionMap( mcl, mcl2 ) );
123456789, [ 1011 ], 12, [ 1314 ], 151617
  18, [ 1920 ], [ 2122 ], [ 2324 ] ]
gap> torso:= CompositionMaps( pi, map );
15400569110122501120211003011 ]
gap> perms:= PermChars( mcl2, rec( torso:= torso ) );
[ Character( CharacterTable( "McL.2" ),
  [ 1540056911012250112021100301
      111026240052110011 ] ) ]
gap> pi:= Inflated( perms[1], 3mcl2 );
Character( CharacterTable( "3.McL.2" ),
 [ 15400154005656919110121225250011112
  2000221110000330001111
  1111026240052110011 ] )

##  doc2/ctblpope.xml (1732-1738)
gap> fus:= PossibleClassFusions( 3mcl2, ly );;  Length( fus );
4
gap> g:= AutomorphismsOfTable( ly );;
gap> OrbitLengths( g, fus, OnTuples );    
4 ]

##  doc2/ctblpope.xml (1744-1750)
gap> pi:= Induced( 3mcl2, ly, [ pi ], fus[1] )[1];
Character( CharacterTable( "Ly" ),
 [ 147934325000286440141680010827841250006724224
  04002200006410050200400004
  0000220000000000000000 ] )

##  doc2/ctblpope.xml (1773-1787)
gap> orders:= OrdersClassRepresentatives( ly );
12334556667889101011111212
  1415151518202121222224242425283030
  31313131313333373740404242676767 ]
gap> torso:= [];;                                   
gap> for i in [ 1 .. Length( orders ) ] do
>      if orders[i] mod 2 = 1 then
>        torso[i]:= pi[i]/2;
>      fi;
>    od;
gap> torso;
73967162500,, 708400541,, 62500,,,, 0,,, 1,,, 00,,,, 2510,
  ,, 00,,,,,, 0,,,, 000000000,,,,, 000 ]

##  doc2/ctblpope.xml (1796-1807)
gap> perms:= PermChars( ly, rec( torso:= torso ) );;
gap> Length( perms );
43
gap> perms:= Filtered( perms, cand -> ForAll( [ 1 .. Length( orders ) ],
>        i -> cand[i] >= pi[i] / 2 ) );
[ Character( CharacterTable( "Ly" ),
  [ 7396716250020482070840054139262500145661250
      221011000032502510120000
      411001100000000022000
      00 ] ) ]

##  doc2/ctblpope.xml (1831-1843)
gap> tbl:= CharacterTable( "U3(5).3.2" );
CharacterTable( "U3(5).3.2" )
gap> deg:= Size( tbl ) / ( 2^4*3^3 );
1750
gap> pi:= PermChars( tbl, rec( torso:= [ deg ] ) );
[ Character( CharacterTable( "U3(5).3.2" ),
  [ 17507013200100010710420000
      003010300100 ] ), 
  Character( CharacterTable( "U3(5).3.2" ),
  [ 1750304600000040706000000
      0200220000 ] ) ]

##  doc2/ctblpope.xml (1854-1860)
gap> ord8:= Filtered( [ 1 .. NrConjugacyClasses( tbl ) ],
>               i -> OrdersClassRepresentatives( tbl )[i] = 8 );
925 ]
gap> List( pi, x -> x{ ord8 } );
[ [ 00 ], [ 02 ] ]

##  doc2/ctblpope.xml (1874-1882)
gap> subtbl:= CharacterTable( "U3(5)" );
CharacterTable( "U3(5)" )
gap> rest:= RestrictedClassFunctions( pi, subtbl );
[ Character( CharacterTable( "U3(5)" ),
  [ 1750701320000100000 ] ), 
  Character( CharacterTable( "U3(5)" ),
  [ 175030460000000000 ] ) ]

##  doc2/ctblpope.xml (1893-1899)
gap> ord6:= Filtered( [ 1 .. NrConjugacyClasses( subtbl ) ],
>               i -> OrdersClassRepresentatives( subtbl )[i] = 6 );
9 ]
gap> List( rest, x -> x{ ord6 } );
[ [ 1 ], [ 0 ] ]

##  doc2/ctblpope.xml (1910-1916)
gap> tom:= TableOfMarks( "U3(5)" );
TableOfMarks( "U3(5)" )
gap> perms:= PermCharsTom( subtbl, tom );;
gap> Set( Filtered( perms, x -> x[1] = deg ) ) = Set( rest );
true

##  doc2/ctblpope.xml (1928-1932)
gap> PermCharInfo( tbl, pi ).ATLAS;
[ "1a+21a+42a+84aac+105a+125a+126a+250a+252a+288bc", 
  "1a+42a+84ac+105ab+125a+126a+250a+252b+288bc" ]

##  doc2/ctblpope.xml (1942-1953)
gap> subtbl2:= CharacterTable( "U3(5).2" );;
gap> rest2:= RestrictedClassFunctions( pi, subtbl2 );;
gap> PermCharInfo( subtbl2, rest2 ).ATLAS;
[ "1a+21aab+28aa+56aa+84a+105a+125aab+126aab+288aa", 
  "1a+21ab+28a+56a+84a+105ab+125aab+126a+252a+288aa" ]
gap> subtbl3:= CharacterTable( "U3(5).3" );;
gap> rest3:= RestrictedClassFunctions( pi, subtbl3 );;
gap> PermCharInfo( subtbl3, rest3 ).ATLAS;
[ "1a+21abc+84aab+105a+125abc+126abc+144bcef", 
  "1a+21bc+84ab+105aa+125abc+126adg+144bcef" ]

##  doc2/ctblpope.xml (1985-1997)
gap> t:= CharacterTable( "O8+(2).3.2" );;
gap> s:= CharacterTable( "O8+(2)" );;
gap> tom:= TableOfMarks( s );;
gap> perms:= PermCharsTom( s, tom );;
gap> deg:= 3^4*5^2*7;
14175
gap> perms:= Filtered( perms, x -> x[1] = deg );;
gap> Length( perms );
4
gap> Length( Set( perms ) );
1

##  doc2/ctblpope.xml (2010-2029)
gap> fus:= PossibleClassFusions( s, t );
[ [ 1233345556789101010111212
      12131313141414151616161717171819
      20212222222323232424242526262627
      2727 ] ]
gap> fus:= fus[1];;
gap> inv:= InverseMap( fus );;
gap> comp:= CompositionMaps( perms[1], inv );
14175121537579002727991570000931
  011000000 ]
gap> ext:= PermChars( t, rec( torso:= comp ) );
[ Character( CharacterTable( "O8+(2).3.2" ),
  [ 1417512153757900272799157000093
      1011000000639157103331
      001194512945692125130009033
      7100031000000 ] ) ]
gap> PermCharInfo( t, ext[1] ).ATLAS;
[ "1a+50b+100a+252bb+300b+700b+972bb+1400a+1944a+3200b+4032b" ]

##  doc2/ctblpope.xml (2220-2230)
gap> co1:= CharacterTable( "Co1" );;
gap> order:= 2^(2+11+22-25) * 2 * Size( CharacterTable( "M24" ) );
501397585920
gap> maxes:= List( Maxes( co1 ), CharacterTable );;
gap> filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );
[ CharacterTable( "2^11:M24" ) ]
gap> List( filt, t -> Size( t ) / order );
1 ]
gap> k:= filt[1];;

##  doc2/ctblpope.xml (2251-2262)
gap> f:= CharacterTable( "Symmetric", 3 );
CharacterTable( "Sym(3)" )
gap> OrdersClassRepresentatives( f );
123 ]
gap> deg3:= PermChars( f, 3 );
[ Character( CharacterTable( "Sym(3)" ), [ 310 ] ) ]
gap> deg6:= PermChars( f, 6 );
[ Character( CharacterTable( "Sym(3)" ), [ 600 ] ) ]
gap> deg3[1] - 1/3 * deg6[1];
ClassFunction( CharacterTable( "Sym(3)" ), [ 110 ] )

##  doc2/ctblpope.xml (2274-2280)
gap> m:= CharacterTable( "M" );
CharacterTable( "M" )
gap> g:= CharacterTable( "MC2B" );
CharacterTable( "2^1+24.Co1" )
gap> pi:= RestrictedClassFunction( TrivialCharacter( k )^co1, g );;

##  doc2/ctblpope.xml (2296-2302)
gap> zclasses:= ClassPositionsOfCentre( g );;
gap> gmodz:= g / zclasses;
CharacterTable( "2^1+24.Co1/[ 12 ]" )
gap> invmap:= InverseMap( GetFusionMap( g, gmodz ) );;
gap> pibar:= CompositionMaps( pi, invmap );;

##  doc2/ctblpope.xml (2319-2332)
gap> factorders:= OrdersClassRepresentatives( gmodz );;
gap> phibar:= [];;
gap> for i in [ 1 .. NrConjugacyClasses( gmodz ) ] do
>      if factorders[i] mod 2 = 1 then
>        phibar[i]:= 2 * pibar[i];
>      elif pibar[i] = 0 then
>        phibar[i]:= 0;
>      fi;
>    od;
gap> cand:= PermChars( gmodz, rec( torso:= phibar ) );;
gap> Length( cand );
1

##  doc2/ctblpope.xml (2341-2351)
gap> phi:= RestrictedClassFunction( cand[1], g )^m;;
gap> pi:= pi^m;;
gap> cand:= ShallowCopy( pi - 1/3 * phi );;
gap> morders:= OrdersClassRepresentatives( m );;
gap> for i in [ 1 .. Length( morders ) ] do
>      if morders[i] mod 3 = 0 and phi[ PowerMap( m, 3 )[i] ] <> 0 then
>        Unbind( cand[i] );
>      fi;
>    od;

##  doc2/ctblpope.xml (2422-2425)
gap> constit:= Filtered( RationalizedMat( Irr( m ) ),
>                        chi -> ScalarProduct( m, chi, pi ) <> 0 );;

##  doc2/ctblpope.xml (2436-2458)
gap> cand:= PermChars( m,
>      rec( torso:= cand, chars:= constit,
>           lower:= ShallowCopy( pi - 1/3 * phi ),
>           normalsubgroup:= [ 1 .. NrConjugacyClasses( m ) ],
>           nonfaithful:= TrivialCharacter( m ) ) );
[ Character( CharacterTable( "M" ),
  [ 160091156298756840063435509449218757774182899642733721875
      1201685444133378754436049512692980215448838605
      131873639625760550656275110042727795943894035568854195
      1851609375046803112204054057862475614467005178605
      248265874650076995591163224055349552953920727
      00375375157750004951165323645623161017
      11268357170145117705004410149803780810
      0083135310000000255195021500
      210042035151116048992259951
      21000009874420001207610000
      001106000000000000530
      0018010033011110020000
      0020000061200200020011
      000000020200111100000
      0000000 ] ) ]

##  doc2/ctblpope.xml (2473-2479)
gap> h:= CharacterTable( "2^(2+11+22).(M24xS3)" );;
gap> fus:= PossibleClassFusions( h, m );;
gap> cand = Set( fus, map -> InducedClassFunctionsByFusionMap( h, m,
>                              [ TrivialCharacter( h ) ], map )[1] );
true

##  doc2/ctblpope.xml (2518-2532)
gap> co1:= CharacterTable( "Co1" );;
gap> order:= 2^(3+6+12+18-25) * 168 * 3 * Factorial( 6 ) / 7;
849346560
gap> maxes:= List( Maxes( co1 ), CharacterTable );;
gap> filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );
[ CharacterTable( "2^(1+8)+.O8+(2)" ), 
  CharacterTable( "2^(4+12).(S3x3S6)" ) ]
gap> List( filt, t -> Size( t ) / order );
1051 ]
gap> o8p2:= CharacterTable( "O8+(2)" );;
gap> PermChars( o8p2, rec( torso:= [ 105 ] ) );
[  ]
gap> k:= filt[2];;

##  doc2/ctblpope.xml (2584-2598)
gap> f:= CharacterTable( "L3(2)" );
CharacterTable( "L3(2)" )
gap> OrdersClassRepresentatives( f );
123477 ]
gap> deg7:= PermChars( f, 7 );
[ Character( CharacterTable( "L3(2)" ), [ 731100 ] ) ]
gap> deg42:= PermChars( f, 42 );
[ Character( CharacterTable( "L3(2)" ), [ 4220200 ] ), 
  Character( CharacterTable( "L3(2)" ), [ 4260000 ] ) ]
gap> deg168:= PermChars( f, 168 );
[ Character( CharacterTable( "L3(2)" ), [ 16800000 ] ) ]
gap> deg7[1] - 1/3 * deg42[2] + 1/21 * deg168[1];
ClassFunction( CharacterTable( "L3(2)" ), [ 111100 ] )

##  doc2/ctblpope.xml (2616-2622)
gap> m:= CharacterTable( "M" );
CharacterTable( "M" )
gap> g:= CharacterTable( "MC2B" );
CharacterTable( "2^1+24.Co1" )
gap> pi:= RestrictedClassFunction( TrivialCharacter( k )^co1, g );;

##  doc2/ctblpope.xml (2633-2643)
gap> nsg:= ClassPositionsOfNormalSubgroups( k );;
gap> nsgsizes:= List( nsg, x -> Sum( SizesConjugacyClasses( k ){ x } ) );;
gap> nn:= nsg[ Position( nsgsizes, Size( k ) / 6 ) ];;
gap> psi:= 0 * [ 1 .. NrConjugacyClasses( k ) ];;
gap> for i in nn do
>      psi[i]:= 6;
>    od;
gap> psi:= InducedClassFunction( k, psi, co1 );;
gap> psi:= RestrictedClassFunction( psi, g );;

##  doc2/ctblpope.xml (2658-2664)
gap> zclasses:= ClassPositionsOfCentre( g );;
gap> gmodz:= g / zclasses;
CharacterTable( "2^1+24.Co1/[ 12 ]" )
gap> invmap:= InverseMap( GetFusionMap( g, gmodz ) );;
gap> psibar:= CompositionMaps( psi, invmap );;

##  doc2/ctblpope.xml (2682-2700)
gap> factorders:= OrdersClassRepresentatives( gmodz );;
gap> phibar:= [];;
gap> upperphibar:= [];;
gap> for i in [ 1 .. NrConjugacyClasses( gmodz ) ] do
>      if factorders[i] mod 2 = 1 then
>        phibar[i]:= 2 * psibar[i];
>      elif psibar[i] = 0 then
>        phibar[i]:= 0;
>      fi;
>      upperphibar[i]:= 2 * psibar[i];
>    od;
gap> cand:= PermChars( gmodz, rec( torso:= phibar,
>             upper:= upperphibar,
>             normalsubgroup:= [ 1 .. NrConjugacyClasses( gmodz ) ],
>             nonfaithful:= TrivialCharacter( gmodz ) ) );;
gap> Length( cand );
3

##  doc2/ctblpope.xml (2711-2720)
gap> nn:= First( ClassPositionsOfNormalSubgroups( gmodz ),
>                x -> Sum( SizesConjugacyClasses( gmodz ){x} ) = 2^24 );
1 .. 4 ]
gap> cont:= PermCharInfo( gmodz, cand ).contained;;
gap> cand:= cand{ Filtered( [ 1 .. Length( cand ) ],
>                           i -> Sum( cont[i]{ nn } ) < 2^24 ) };;
gap> Length( cand );
2

##  doc2/ctblpope.xml (2731-2757)
gap> poss:= [];;
gap> for v in cand do
>      phibar:= [];
>      upperphibar:= [];
>      for i in [ 1 .. NrConjugacyClasses( gmodz ) ] do
>        if factorders[i] mod 2 = 1 then
>          phibar[i]:= 2 * v[i];
>        elif v[i] = 0 then
>          phibar[i]:= 0;
>        fi;
>        upperphibar[i]:= 2 * v[i];
>      od;
>      Append( poss, PermChars( gmodz, rec( torso:= phibar,
>                      upper:= upperphibar,
>                      normalsubgroup:= [ 1 .. NrConjugacyClasses( gmodz ) ],
>                      nonfaithful:= TrivialCharacter( gmodz ) ) ) );
>    od;
gap> Length( poss );
6
gap> cont:= PermCharInfo( gmodz, poss ).contained;;
gap> poss:= poss{ Filtered( [ 1 .. Length( poss ) ],
>                           i -> Sum( cont[i]{ nn } ) < 2^23 ) };;
gap> Length( poss );
4
gap> phicand:= RestrictedClassFunctions( poss, g );;

##  doc2/ctblpope.xml (2768-2783)
gap> phicand:= RestrictedClassFunctions( poss, g );;
gap> phicand:= InducedClassFunctions( phicand, m );;
gap> psi:= psi^m;;
gap> pi:= pi^m;;
gap> cand:= List( phicand,
>             phi -> ShallowCopy( pi - 1/3 * psi + 1/21 * phi ) );;
gap> morders:= OrdersClassRepresentatives( m );;
gap> for x in cand do
>      for i in [ 1 .. Length( morders ) ] do
>        if morders[i] mod 7 = 0 then
>          Unbind( x[i] );
>        fi;
>      od;
>    od;

##  doc2/ctblpope.xml (2791-2807)
gap> cand:= Filtered( cand, x -> ForAll( x, IsInt ) );
[ [ 4050306254358548053604918389065234375148844831270071996434375
      2815847622206994375145673657530250853447181417680
      65936819812535201538231755484643532555706077895
      30565666952645156250195728954856486480186109245
      61410960758160688365,,, 1725031264351376155137935
      9912752731001196253625000040281329160
      18530127812106919324212360576112500,,,, 2160
      81000111179430000000185105065
      00,,,,, 00003371053615737181816421
      00000,,,,, 00604010000001100
      0,,, 00000000051000,,,,, 0000
      000003000000,,,, 00068002
      00000000,,, 00000,,,, 000000
      00000000,, 0 ] ]

##  doc2/ctblpope.xml (2816-2819)
gap> constit:= Filtered( RationalizedMat( Irr( m ) ),
>                        chi -> ScalarProduct( m, chi, pi ) <> 0 );;

##  doc2/ctblpope.xml (2829-2847)
gap> cand:= PermChars( m, rec( torso:= cand[1], chars:= constit ) );
[ Character( CharacterTable( "M" ),
  [ 4050306254358548053604918389065234375148844831270071996434375
      2815847622206994375145673657530250853447181417680
      65936819812535201538231755484643532555706077895
      30565666952645156250195728954856486480186109245
      614109607581606883655831001725031264351376155
      13793599127527310011962536250000402813
      2916018530127812106919324212360576112500
      1302294021608100011117943000000
      01851050650022401400000337105
      3615737181816421000007038140
      006040100000011000100000
      0000005100024060000000
      000300000020000068002
      000000002000000402000
      000000000004000 ] ) ]

##  doc2/ctblpope.xml (2865-2869)
gap> h:= CharacterTable( "2^[39].(L3(2)x3.S6)" );;
gap> cand[1] = TrivialCharacter( h )^m;
true

##  doc2/ctblpope.xml (2905-2925)
gap> co1:= CharacterTable( "Co1" );;
gap> order:= 2^35*Size( CharacterTable( "L5(2)" ) )*6 / 2^25 / 31;
1981808640
gap> maxes:= List( Maxes( co1 ), CharacterTable );;
gap> filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );
[ CharacterTable( "2^11:M24" ), CharacterTable( "2^(1+8)+.O8+(2)" ), 
  CharacterTable( "2^(2+12):(A8xS3)" ) ]
gap> List( filt, t -> Size( t ) / order );
253451 ]
gap> m24:= CharacterTable( "M24" );;
gap> cand:= PermChars( m24, rec( torso:=[ 253 ] ) );
[ Character( CharacterTable( "M24" ),
  [ 2532913101551321111302111
      001100 ] ) ]
gap> TestPerm5( m24, cand, m24 mod 11 );
[  ]
gap> PermChars( CharacterTable( "O8+(2)" ), rec( torso:=[ 45 ] ) );
[  ]
gap> k:= filt[3];;

##  doc2/ctblpope.xml (2963-2972)
gap> subtbl:= CharacterTable( "2^4:A8" );;
gap> subtom:= TableOfMarks( subtbl );;
gap> perms:= PermCharsTom( subtbl, subtom );;
gap> nsg:= ClassPositionsOfNormalSubgroups( subtbl );
[ [ 1 ], [ 12 ], [ 1 .. 25 ] ]
gap> above:= Filtered( perms, x -> x[1] = x[2] );;
gap> tbl:= CharacterTable( "L5(2)" );;
gap> above:= Set( Induced( subtbl, tbl, above ) );;

##  doc2/ctblpope.xml (2985-2990)
gap> index2:= Filtered( perms,
>      x -> Sum( PermCharInfo( subtbl, [x] ).contained[1]{ [1,2] } ) = 8 );;
gap> index2:= Filtered( index2, x -> not x[1] in [ 63084012601680 ] );;
gap> index2:= Set( Induced( subtbl, tbl, index2 ) );;

##  doc2/ctblpope.xml (2999-3023)
gap> orders:= OrdersClassRepresentatives( tbl );;
gap> goodclasses:= Filtered( [ 1 .. NrConjugacyClasses( tbl ) ],
>                            i -> not orders[i] in [ 2131 ] );
12345678910111213141516171819 ]
gap> matrix:= List( Concatenation( above, index2 ), x -> x{ goodclasses } );;
gap> sol:= SolutionMat( matrix,
>              ListWithIdenticalEntries( Length( goodclasses ), 1 ) );
692/65157/217, -78/217, -26/217074/65111/21703/217
  151/651022/651000, -11/21700000000
  -115/6510, -3/310000000000000000
  0000000000000000000000
  0000000000000000000000
  000000000000000000, -34/93
  -11/65102/2100000000001/310000
  0000000000000000000000
  0000000000000000000000
  0000000000000000000000
  0000000000000000000000
  0000000000000000000000
  000000000000000000000 ]
gap> nonzero:= Filtered( [ 1 .. Length( sol ) ], i -> sol[i] <> 0 );
12346791012162527106107109120 ]
gap> sol:= sol{ nonzero };;

##  doc2/ctblpope.xml (3041-3065)
gap> a8degrees:= List( above{ Filtered( nonzero,
>                                 x -> x <= Length( above ) ) },
>                      x -> x[1] ) / 31;
181528565670105120168336336 ]
gap> a8tbl:= subtbl / [ 12 ];;
gap> invtoa8:= InverseMap( GetFusionMap( subtbl, a8tbl ) );;
gap> nsg:= ClassPositionsOfNormalSubgroups( k );;
gap> nn:= First( nsg, x -> Sum( SizesConjugacyClasses( k ){ x } ) = 6*2^14 );;
gap> a8tbl_other:= k / nn;;
gap> g:= CharacterTable( "MC2B" );
CharacterTable( "2^1+24.Co1" )
gap> constit:= [];;
gap> for i in [ 1 .. Length( a8degrees ) ] do
>      cand:= PermChars( a8tbl_other, rec( torso:= [ a8degrees[i] ] ) );
>      filt:= Filtered( perms, x -> x^tbl = above[ nonzero[i] ] );
>      filt:= List( filt, x -> CompositionMaps( x, invtoa8 ) );
>      cand:= Filtered( cand,
>               x -> ForAny( filt, y -> Collected( x ) = Collected(y) ) );
>      Add( constit, List( Induced( Restricted( Induced(
>        Restricted( cand, k ), co1 ), g ), m ), ValuesOfClassFunction ) );
>    od;
gap> List( constit, Length );
111111111111 ]

##  doc2/ctblpope.xml (3082-3123)
gap> downdegrees:= List( index2{ Filtered( nonzero,
>                                    x -> x > Length( above ) )
>                                - Length( above ) },
>                        x -> x[1] ) / 31;
302102101920 ]
gap> f:= g / ClassPositionsOfCentre( g );;
gap> forders:= OrdersClassRepresentatives( f );;
gap> inv:= InverseMap( GetFusionMap( g, f ) );;
gap> for j in [ 1 .. Length( downdegrees ) ] do
>      chars:= [];
>      cand:= PermChars( a8tbl_other, rec( torso:= [ downdegrees[j]/2 ] ) );
>      filt:= Filtered( perms, x -> x^tbl = index2[ nonzero[
>                   j + Length( a8degrees ) ] - Length( above ) ] );
>      filt:= Induced( subtbl, a8tbl, filt,
>                      GetFusionMap( subtbl, a8tbl ));
>      cand:= Filtered( cand, x -> ForAny( filt,
>                 y -> Collected( x ) = Collected( y ) ) );
>      cand:= Restricted( Induced( Restricted( cand, k ), co1 ), g );
>      for chi in cand do
>        cchi:= CompositionMaps( chi, inv );
>        upper:= [];
>        pphi:= [];
>        for i in [ 1 .. NrConjugacyClasses( f ) ] do
>          if forders[i] mod 2 = 1 then
>            pphi[i]:= 2 * cchi[i];
>          elif cchi[i] = 0 then
>            pphi[i]:= 0;
>          fi;
>          upper[i]:= 2* cchi[i];
>        od;
>        Append( chars, PermChars( f, rec( torso:= ShallowCopy( pphi ),
>            upper:= upper,
>            normalsubgroup:= [ 1 .. 4 ],
>            nonfaithful:= cchi ) ) );
>      od;
>      Add( constit, List( Induced( Restricted( chars, g ), m ),
>                          ValuesOfClassFunction ) );
>    od;
gap> List( constit, Length );
111111111111310102 ]

##  doc2/ctblpope.xml (3131-3143)
gap> cand:= List( Cartesian( constit ), l -> sol * l );;
gap> m:= CharacterTable( "M" );
CharacterTable( "M" )
gap> morders:= OrdersClassRepresentatives( m );;
gap> for x in cand do
>      for i in [ 1 .. Length( morders ) ] do
>        if morders[i] mod 31 = 0 or morders[i] mod 21 = 0 then
>          Unbind( x[i] );
>        fi;
>      od;
>    od;

##  doc2/ctblpope.xml (3151-3167)
gap> cand:= Filtered( cand, x -> ForAll( x, IsInt ) );
[ [ 39196512138953690841337919894179687523914487292951376996875
      4741631380424688759500455925885925646346515815
      3343634862759541617648751473391032751481392395
      13132815150820312598278859251216215915563259388791
      115911587331874650079515581955336375104371
      62331368550000281255251125018832516767
      889652403947711558912073516270044101498
      000301509115131000000000125
      055,,,,, 000014145276127997315
      000009874420030000666,,, 11
      0000000000000000110,,,,, 0
      000000001000000200000
      002202,,, 000000000000,,,, 0
      00000,,, 000000,, 000 ] ]

##  doc2/ctblpope.xml (3176-3194)
gap> cand:= PermChars( m, rec( torso:= cand[1] ) );
[ Character( CharacterTable( "M" ),
  [ 39196512138953690841337919894179687523914487292951376996875
      4741631380424688759500455925885925646346515815
      3343634862759541617648751473391032751481392395
      13132815150820312598278859251216215915563259388791
      115911587331874650079515581955336375104371
      62331368550000281255251125018832516767
      889652403947711558912073516270044101498
      000301509115131000000000125
      055210042000001414527612799
      731500000987442003000066
      633110000000000000000
      1101801000000000001000
      000200000002202330000
      000000002020000003300
      00000000 ] ) ]

##  doc2/ctblpope.xml (3211-3217)
gap> h:= CharacterTable( "2^(5+10+20).(S3xL5(2))" );;
gap> fus:= PossibleClassFusions( h, m );;
gap> cand = Set( fus, map -> InducedClassFunctionsByFusionMap( h, m,
>                              [ TrivialCharacter( h ) ], map )[1] );
true

##  doc2/ctblpope.xml (3248-3258)
gap> Hbar:= CharacterTable( "O10+(2)" );;
gap> U_Abar:= CharacterTable( "O10+(2)M1" );
CharacterTable( "S8(2)" )
gap> Index( Hbar, U_Abar );
496
gap> U_Bbar:= CharacterTable( "O10+(2)M2" );
CharacterTable( "2^8:O8+(2)" )
gap> Index( Hbar, U_Bbar );
527

##  doc2/ctblpope.xml (3276-3290)
gap> b:= CharacterTable( "B" );
CharacterTable( "B" )
gap> Horder:= 2^26 * Size( Hbar );
1577011055923770163200
gap> order:= Horder / ( 2 * 496 );
1589728887019929600
gap> maxes:= List( Maxes( b ), CharacterTable );;
gap> filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );
[ CharacterTable( "2^(9+16).S8(2)" ) ]
gap> List( filt, t -> Size( t ) / order );
1 ]
gap> u1:= filt[1];
CharacterTable( "2^(9+16).S8(2)" )

##  doc2/ctblpope.xml (3307-3318)
gap> co1:= CharacterTable( "Co1" );;
gap> order:= Horder / ( 2^25 * 527 );
89181388800
gap> maxes:= List( Maxes( co1 ), CharacterTable );;
gap> filt:= Filtered( maxes, t -> Size( t ) mod order = 0 );
[ CharacterTable( "2^(1+8)+.O8+(2)" ) ]
gap> List( filt, t -> Size( t ) / order );
1 ]
gap> u2:= filt[1];
CharacterTable( "2^(1+8)+.O8+(2)" )

##  doc2/ctblpope.xml (3327-3336)
gap> m:= CharacterTable( "M" );
CharacterTable( "M" )
gap> 2b:= CharacterTable( "MC2A" );
CharacterTable( "2.B" )
gap> mm:= CharacterTable( "MC2B" );
CharacterTable( "2^1+24.Co1" )
gap> pi_A:= RestrictedClassFunction( TrivialCharacter( u1 )^b, 2b )^m;;
gap> pi_B:= RestrictedClassFunction( TrivialCharacter( u2 )^co1, mm )^m;;

##  doc2/ctblpope.xml (3344-3347)
gap> torso:= [ Size( m ) / Horder ];
512372707698741056749515292734375 ]

##  doc2/ctblpope.xml (3389-3429)
gap> morders:= OrdersClassRepresentatives( m );;
gap> 2parts:= Union( [ 1 ], Filtered( Set( morders ),
>                          x -> IsPrimePowerInt( x ) and IsEvenInt( x ) ) );
12481632 ]
gap> factorders:= Set( OrdersClassRepresentatives( Hbar ) );;
gap> primes_A:= Filtered( PrimeDivisors( Horder ), p -> 496 mod p <> 0 );
35717 ]
gap> primes_B:= Filtered( PrimeDivisors( Horder ), p -> 527 mod p <> 0 );
2357 ]
gap> primes:= Union( primes_A, primes_B );;
gap> n:= NrConjugacyClasses( m );;
gap> for i in [ 1 .. n ] do
>   if Horder mod morders[i] <> 0 then
>     torso[i]:= 0;
>   elif ForAll( factorders, x -> not morders[i] / x in 2parts ) then
>     torso[i]:= 0;
>   else
>     for p in primes do
>       if morders[i] mod p = 0 then
>         pprime:= morders[i];
>         while pprime mod p = 0 do pprime:= pprime / p; od;
>         pos:= PowerMap( m, pprime )[i];
>         if p in primes_A and pi_A[ pos ] = 0 then
>           torso[i]:= 0;
>         elif p in primes_B and pi_B[ pos ] = 0 then
>           torso[i]:= 0;
>         fi;
>       fi;
>     od;
>   fi;
> od;
gap> torso;
512372707698741056749515292734375,,,,, 0,,,,,,,,,,,, 0,, 0,,,,,,,,,,
  ,,,, 0,,,, 0,,,,,, 000,,, 0,,,, 0,,,,,,,,,, 0,,,,,,,, 000
  0000,,,,, 0,,,,, 000000,,,, 00,,,,, 0,,,,,,, 00,
  , 00,,,,, 00000,,,,, 0,, 00000,, 000000,
  , 0,, 0000,, 00000,,,,,, 0,,, 00,, 00000
  0000,, 000000000000000000
  00 ]

##  doc2/ctblpope.xml (3480-3504)
gap> cand:= [ [ pi_A ], [ pi_B ] ];;
gap> candbar:= [ TrivialCharacter( U_Abar )^Hbar,
>                TrivialCharacter( U_Bbar )^Hbar ];;
gap> AddSubgroupOfS82:= function( subname )
>   local psis82;

>   psis82:= TrivialCharacter( CharacterTable( subname ) )^U_Abar;
>   Add( cand, [ Restricted( Restricted( psis82, u1 )^b, 2b )^m ] );
>   Add( candbar, psis82 ^ Hbar );
> end;;
gap> tt1:= CharacterTable( "O8+(2)" );
CharacterTable( "O8+(2)" )
gap> AddSubgroupOfO8p2:= function( subname )
>   local psi, list, char;

>   psi:= TrivialCharacter( CharacterTable( subname ) )^tt1;
>   list:= [];
>   for char in Orbit( AutomorphismsOfTable( tt1 ), psi, Permuted ) do
>     AddSet( list, Restricted( Restricted( char, u2 ) ^ co1, mm ) ^ m );
>   od;
>   Add( cand, list );
>   Add( candbar, Restricted( psi, U_Bbar ) ^ Hbar );
> end;;

##  doc2/ctblpope.xml (3513-3525)
gap> AddSubgroupOfS82( "O8+(2).2" );
gap> AddSubgroupOfO8p2( "S6(2)" );
gap> AddSubgroupOfS82( "O8-(2).2" );
gap> AddSubgroupOfS82( "A10.2" );
gap> AddSubgroupOfS82( "S4(4).2" );
gap> AddSubgroupOfS82( "L2(17)" );
gap> AddSubgroupOfO8p2( "A9" );
gap> AddSubgroupOfO8p2( "2^6:A8" );
gap> AddSubgroupOfO8p2( "(3xU4(2)):2" );
gap> AddSubgroupOfO8p2( "(A5xA5):2^2" );
gap> AddSubgroupOfS82( "S8(2)M4" );

##  doc2/ctblpope.xml (3538-3548)
gap> a5:= CharacterTable( "A5" );;
gap> fus:= PossibleClassFusions( a5, U_Abar )[1];;
gap> NrPolyhedralSubgroups( U_Abar, fus[2], fus[3], fus[4] );
rec( number := 548352, type := "A5" )
gap> psis82:= Induced( a5, U_Abar, [ TrivialCharacter( a5 ) ], fus )[1];;
gap> Add( cand, [ Restricted( Restricted( psis82, u1 )^b, 2b )^m ] );
gap> Add( candbar, psis82 ^ Hbar );
gap> List( cand, Length );
11121111222211 ]

##  doc2/ctblpope.xml (3563-3598)
gap> Hbarorders:= OrdersClassRepresentatives( Hbar );;
gap> TryCondition:= function( cond )
>   local pos, sol, lincomb, oldknown, i;

>   pos:= Filtered( [ 1 .. Length( Hbarorders ) ],
>             i -> cond( Hbarorders[i] ) );
>   sol:= SolutionMat( candbar{[1..Length(candbar)]}{ pos },
>             ListWithIdenticalEntries( Length( pos ), 1 ) );
>   if sol = fail then
>     return "no solution";
>   fi;

>   pos:= Filtered( [ 1 .. Length( morders) ], i -> cond( morders[i] ) );
>   lincomb:= Filtered( Set( Cartesian( cand ), x -> sol * x ),
>                 x -> ForAll( pos, i -> IsPosInt( x[i] ) or x[i] = 0 ) );
>   if Length( lincomb ) <> 1 then
>     return "solution is not unique";
>   fi;

>   lincomb:= lincomb[1];;
>   oldknown:= Number( torso );
>   for i in pos do
>     if IsBound( torso[i] ) then
>       if torso[i] <> lincomb[i] then
>         Error( "contradiction of new and known value at position ", i );
>       fi;
>     elif not IsInt( lincomb[i] ) or lincomb[i] < 0 then
>       Error( "new value at position ", i, " is not a nonneg. integer" );
>     fi;
>     torso[i]:= lincomb[i];
>   od;
>   return Concatenation( "now ", String( Number( torso ) ), " values (",
>              String( Number( torso ) - oldknown ), " new)" );
> end;;

##  doc2/ctblpope.xml (3618-3631)
gap> TryCondition( x -> x mod 7 = 0 and x mod 3 <> 0 );
"now 99 values (7 new)"
gap> TryCondition( x -> x mod 17 = 0 and x mod 3 <> 0 );
"now 102 values (3 new)"
gap> TryCondition( x -> x mod 5 = 0 and x mod 3 <> 0 );
"now 119 values (17 new)"
gap> TryCondition( x -> 4 mod x = 0 );
"now 125 values (6 new)"
gap> TryCondition( x -> 9 mod x = 0 );
"now 129 values (4 new)"
gap> TryCondition( x -> x in [ 91836 ] );
"now 138 values (9 new)"

##  doc2/ctblpope.xml (3640-3644)
gap> constit:= Filtered( RationalizedMat( Irr( m ) ),
>               x -> ScalarProduct( m, x, pi_A ) <> 0
>                    and ScalarProduct( m, x, pi_B ) <> 0 );;

##  doc2/ctblpope.xml (3657-3668)
gap> lower:= [];;
gap> Hindex:= Size( m ) / Horder;
512372707698741056749515292734375
gap> for i in [ 1 .. NrConjugacyClasses( m ) ] do
>   lower[i]:= Maximum( pi_A[i] / ( pi_A[1] / Hindex ),
>                       pi_B[i] / ( pi_B[1] / Hindex ) );
>   if not IsInt( lower[i] ) then
>     lower[i]:= Int( lower[i] + 1 );
>   fi;
> od;

##  doc2/ctblpope.xml (3679-3699)
gap> cand:= PermChars( m, rec( torso:= torso, chars:= constit,
>      lower:= lower, normalsubgroup:= [ 1 .. NrConjugacyClasses( m ) ],
>      nonfaithful:= TrivialCharacter( m ) ) );
[ Character( CharacterTable( "M" ),
  [ 512372707698741056749515292734375405589064025344574375
      296287867421295756582015216626852154488386050
      12197177437528098354375335229607108472455164587500
      4921875248750716525675652615778965938053989250
      437325044983234399906752139141111129156561
      656117710076606875315275011337317901572130
      495711979093013970003885525028359045
      01036743288118999905403001752015
      74200000000165613737099135
      00000077451300451151910055
      991100400993100000041
      1024000006000000104000
      010000033112033000000
      000000200000000000000
      000000 ] ) ]

##  doc2/ctblpope.xml (3714-3720)
gap> h:= CharacterTable( "2^(10+16).O10+(2)" );;
gap> fus:= PossibleClassFusions( h, m );;
gap> cand = Set( fus, map -> InducedClassFunctionsByFusionMap( h, m,
>                              [ TrivialCharacter( h ) ], map )[1] );
true

##  doc2/ctblpope.xml (3745-3750)
gap> t:= CharacterTable( "S5" );
CharacterTable( "A5.2" )
gap> pi:= PermChars( t, rec( torso:= [ 15 ] ) );
[ Character( CharacterTable( "A5.2" ), [ 15300310 ] ) ]

##  doc2/ctblpope.xml (3759-3768)
gap> m222:= CharacterTable( "M22.2" );
CharacterTable( "M22.2" )
gap> mx:= List( Maxes( m222 ), CharacterTable );;
gap> mx:= Filtered( mx, x -> Size( m222 ) / Size( x ) = 231 );
[ CharacterTable( "M22.2M4" ) ]
gap> pi:= pi[1]{ GetFusionMap( mx[1], t ) };
1515333003311015153330033
  110 ]

##  doc2/ctblpope.xml (3778-3783)
gap> pi:= InducedClassFunction( mx[1], pi, m222 );
ClassFunction( CharacterTable( "M22.2" ),
 [ 3465105095000010189459130100
  00 ] )

##  doc2/ctblpope.xml (3793-3805)
gap> co2:= CharacterTable( "Co2" );
CharacterTable( "Co2" )
gap> mx:= List( Maxes( co2 ), CharacterTable );;
gap> mx:= Filtered( mx, x -> Size( co2 ) / Size( x ) = 46575 );
[ CharacterTable( "2^10:m22:2" ) ]
gap> pi:= pi{ GetFusionMap( mx[1], m222 ) };
34653465346534651051051051051051051051050
  0000999999555550000000
  000111018918918918918918945454545
  99991313131313130000001110
  0000000 ]

##  doc2/ctblpope.xml (3813-3820)
gap> pi:= InducedClassFunction( mx[1], pi, co2 );
ClassFunction( CharacterTable( "Co2" ),
 [ 1613823756265351628552749500661539752727855
  567975115000000000635119273570
  0000000000000000001100
  000000000 ] )

##  doc2/ctblpope.xml (3831-3840)
gap> b:= CharacterTable( "B" );
CharacterTable( "B" )
gap> mx:= List( Maxes( b ), CharacterTable );;
gap> mx:= Filtered( mx, x -> Size( b ) / Size( x ) = 11707448673375 );
[ CharacterTable( "2^(1+22).Co2" ) ]
gap> pi:= pi{ GetFusionMap( mx[1], co2 ) };;
gap> pi[1];
161382375

##  doc2/ctblpope.xml (3848-3863)
gap> pi:= InducedClassFunction( mx[1], pi, b );
ClassFunction( CharacterTable( "B" ),
 [ 1889375872099856765625260938540885522562316674429625
  20781852682526878849042500130527416257537207545
  1282986812705809054636642574315385356333853937689
  201825123322500000000000000713097
  2414253206258852127526557705193052008994416489
  257718255345753000000000000000
  0000000000000000000000
  27341710597185339900000000000
  0000000000000000000000
  0000000000000000000000
  0111100000000000000000
  00000000000000000 ] )

##  doc2/ctblpope.xml (3922-3932)
gap> mcl:= CharacterTable( "McL" );
CharacterTable( "McL" )
gap> co2:= CharacterTable( "Co2" );
CharacterTable( "Co2" )
gap> ind:= Induced( mcl, co2, [ TrivialCharacter( mcl ) ] )[1];
Character( CharacterTable( "Co2" ),
 [ 4710401024016160000064004241600
  01608000008440020000004
  00220110000000000011 ] )

##  doc2/ctblpope.xml (3941-3968)
gap> m:= CharacterTable( "BM2" );
CharacterTable( "2^(1+22).Co2" )
gap> infl:= ind{ GetFusionMap( m, co2 ) };
47104471044710447104471044710447104000000
  00000010241024102410241024102410241024
  102410241024102400000000000000
  000016161616160160160160160160160160
  1601600000000000000000000
  0000000000000000000000
  06464646464646464646464646464000
  0000000000000000000000
  00004442424242424242424161616
  16000000000000000000000
  000000161616161616161616161616
  16000000000000000008888
  8888000000000000000000
  0000000000000000000000
  0000000888888888444444
  4400000000000000000002
  2222000000000000000000
  0000000000000000000444
  4000000000000000000022
  2222222200000111100000
  0000000000000000000000
  0000000000000000000000
  1111 ]

##  doc2/ctblpope.xml (3976-3993)
gap> b:= CharacterTable( "B" );
CharacterTable( "B" )
gap> ind:= Induced( m, b, [ infl ] )[1];
ClassFunction( CharacterTable( "B" ),
 [ 5514676623106560001869112627202729936343040634521600
  194594400699848495104174653441290242764802073600
  1638479872046080051201386001000110880252000
  112480432129600131283528644320252002880
  28803072288000256641152576640192960108
  25207440104120403016016112010240096288
  6414409601081648032120001680104
  48040000321688024124000024
  424240000400660000000000
  00004000008016840000042
  2000000000004000000000
  0002000000000000000 ] )

##  doc2/ctblpope.xml (4001-4021)
gap> 2b:= CharacterTable( "2.B" );
CharacterTable( "2.B" )
gap> infl:= ind{ GetFusionMap( 2b, b ) };
551467662310656000551467662310656000186911262720272993634304
  27299363430406345216001945944001945944006998469984
  8495104174653441290242764802073600207360016384798720
  460800512013860013860010001000110880252000112480
  11248043212960013121312835286486443202520
  25200288028803072288000256641152576576
  64019296001081082520744744010410412040
  403030160161120102400096288641441440
  9601081081648032121200001680104
  104480044000032168880024124
  400000024424240000040006
  6660000000000000000040
  00000080168440000004422
  2200000000000000040000
  0000000000002200000000
  0000000000000000 ]

##  doc2/ctblpope.xml (4042-4078)
gap> centre:= ClassPositionsOfCentre( 2b );
12 ]
gap> pi:= PermChars( 2b, rec( torso:= [ 2 * infl[1], 0 ],
>                             normalsubgroup:= centre,
>                             nonfaithful:= infl ) );
[ Character( CharacterTable( "2.B" ),
  [ 110293532462131200001869112627205417902080004197060608
      063452160038918880001399680849510417465344
      1290242764804026240120960163847987204608005120
      2772000200001108802520001900803488043212960
      0259232835217280432050400028802880
      307228800025664115210081446401929600
      216025209605280200812080060016016
      1120102400096288642167209602160
      1648032240000016801604848008
      000003216812400241208000
      00024424240000040006684
      000000000000000004000
      0000801688000000080222
      200000000000000040000
      000000000000220000000
      00000000000000000 ] ) ]
gap> MatScalarProducts( 2b, Irr( 2b ), pi );
[ [ 1121202320014120320200
      220023150432003206401
      100003010050520020041
      020424430242403032501
      031011253114511030032
      112114032313013022133
      002000030333103040100
      200200211000012111011
      111102113300011112320
      022435240000520001100
      000070017700016450030
      000041138322501 ] ]

##  doc2/ctblpope.xml (4180-4201)
gap> names:= AllCharacterTableNames( IsSporadicSimple, true,
>            IsDuplicateTable, false : OrderedBy:= Size );
[ "M11", "M12", "J1", "M22", "J2", "M23", "HS", "J3", "M24", "McL", 
  "He", "Ru", "Suz", "ON", "Co3", "Co2", "Fi22", "HN", "Ly", "Th", 
  "Fi23", "Co1", "J4", "F3+", "B", "M" ]
gap> normindices:= rec( Co1:= 1, J4:= 1, F3\+:= 1, B:= 1, M:= 1 );;
gap> for name in names do
>      n:= CharacterTable( Concatenation( name, "N2" ) );
>      if n = fail then
>        Print( name, "\n" );
>      else
>        2part:= 2^Length( Positions( Factors( Size( n ) ), 2 ) );
>        normindices.( name ):= Size( n ) / 2part;
>      fi;
>    od;
Co1
J4
F3+
B
M

##  doc2/ctblpope.xml (4212-4226)
gap> maxbound:= [];;
gap> for name in names do
>      t:= CharacterTable( name );
>      mx:= List( Maxes( t ), CharacterTable );
>      odd:= Filtered( mx, s -> ( Size( t ) / Size( s ) ) mod 2 <> 0 );
>      primperm:= List( odd, s -> TrivialCharacter( s )^t );
>      sum:= normindices.( name ) * Sum( primperm, pi -> pi / pi[1] );
>      Add( maxbound,
>           [ name, Maximum( sum{ [ 2 .. Length( sum ) ] } ) ] );
>    od;
gap> SortBy( maxbound, x -> - x[2] );
gap> maxbound[1];
[ "J2", 3/5 ]

##  doc2/ctblpope.xml (4279-4336)
gap> upper_bound:= function( tblS, tblM, p )
>    local ppart, ppartposS, ppartposM, n, N_S, f, subname, u;

>    ppart:= Product( Filtered( Factors( Size( tblS ) ), x -> x = p ), 1 );
>    ppartposS:= Positions( OrdersClassRepresentatives( tblS ), ppart );
>    if 0 < Length( ppartposS ) then
>      # P is cyclic.
>      if tblM = fail then
>        return ( SizesCentralizers( tblS )[ ppartposS[1] ] * Phi( ppart )
>                 / Length( ppartposS ) ) / ppart;
>      else
>        ppartposM:= Positions( OrdersClassRepresentatives( tblM ), ppart );
>        return ( SizesCentralizers( tblS )[ ppartposS[1] ] * Phi( ppart )
>                 / Length( ppartposS ) ) /
>               ( SizesCentralizers( tblM )[ ppartposM[1] ] * Phi( ppart )
>                 / Length( ppartposM ) );
>      fi;
>    fi;
>  
>    # Compute |N_S(P)|.
>    n:= CharacterTable( Concatenation( Identifier( tblS ), "N",
>                            String( p ) ) );
>    if n <> fail then
>      N_S:= Size( n );
>    elif p = 2 then
>      N_S:= ppart * normindices.( Identifier( tblS ) );
>    elif Identifier( tblS ) = "M" and p = 3 then
>      # The Sylow 3-normalizer is contained in 3^(3+2+6+6):(L3(3)xSD16)
>      N_S:= ppart * 2^6;
>    elif Identifier( tblS ) = "F3+" and p = 3 then
>      N_S:= ppart * 8;
>    else
>      Error( "cannot compute |N_S(P)|" );
>    fi;
>  
>    if tblM = fail then
>      return N_S / ppart;
>    elif Sum( SizesConjugacyClasses( tblM ){
>                  ClassPositionsOfPCore( tblM, p ) } ) = ppart then
>      # P is normal in M.
>      return N_S / Size( tblM );
>    fi;

>    # Inspect known character tables of subgroups of M.
>    f:= N_S / ppart;
>    for subname in NamesOfFusionSources( tblM ) do
>      u:= CharacterTable( subname );
>      if ClassPositionsOfKernel( GetFusionMap( u, tblM ) ) = [ 1 ] and
>         Sum( SizesConjugacyClasses( u ){
>                  ClassPositionsOfPCore( u, p ) } ) = ppart then
>        f:= Minimum( f, N_S / Size( u ) );
>      fi;
>    od;

>    return f;
>  end;;

##  doc2/ctblpope.xml (4380-4438)
gap> badcases_thm:= [];;
gap> badcases_strong:= [];;
gap> good:= "dummy";;   #  Avoid a message about an unbound variable ...
gap> for name in Filtered( names, x -> x <> "M" ) do
>      t:= CharacterTable( name );
>      orders:= OrdersClassRepresentatives( t );
>      n:= NrConjugacyClasses( t );
>      mx:= List( Maxes( t ), CharacterTable );
>      for p in PrimeDivisors( Size( t ) ) do
>        good:= Filtered( mx, s -> ( Size( t ) / Size( s ) ) mod p <> 0 );
>        primperm:= [];
>        for s in good do
>          if GetFusionMap( s, t ) <> fail then
>            Add( primperm, TrivialCharacter( s )^t );
>          else
>            ind:= Set( PossibleClassFusions( s, t ),
>                       map -> InducedClassFunctionsByFusionMap( s, t,
>                                  [ TrivialCharacter( s ) ], map )[1] );
>            if Length( ind ) <> 1 then
>              Error( "permutation character not uniquely determined" );
>            fi;
>            Add( primperm, ind[1] );
>          fi;
>        od;
>        sum:= Sum( [ 1 .. Length( good ) ],
>                   i -> upper_bound( t, good[i], p )
>                        * primperm[i] / primperm[i][1] );
>        badpos:= Filtered( [ 2 .. Length( sum ) ], i -> sum[i] >= 1 );
>        if badpos <> [] then
>          Add( badcases_strong, [ name, p, ShallowCopy( badpos ) ] );
>          for i in ShallowCopy( badpos ) do
>            q:= SmallestRootInt( orders[i] );
>            if IsPrimeInt( q ) then
>              if ForAny( [ 2 .. n ],
>                         j -> SmallestRootInt( orders[j] ) = q
>                              and not j in badpos ) then
>                RemoveSet( badpos, i );
>              fi;
>            fi;
>          od;
>          if not IsEmpty( badpos ) then
>            Add( badcases_thm, [ name, p, badpos ] );
>          fi;
>        fi;
>      od;
>    od;
gap> badcases_thm;
[ [ "M23", 3, [ 3 ] ], [ "HS", 3, [ 411 ] ] ]
gap> badcases_strong;
[ [ "M11", 5, [ 2 ] ], [ "M12", 5, [ 34 ] ], [ "M22", 3, [ 2 ] ], 
  [ "M22", 5, [ 2 ] ], [ "J2", 3, [ 2 ] ], [ "M23", 3, [ 23 ] ], 
  [ "M23", 5, [ 2 ] ], [ "M23", 7, [ 2 ] ], 
  [ "HS", 3, [ 234567911 ] ], [ "HS", 5, [ 235 ] ], 
  [ "M24", 5, [ 24 ] ], [ "M24", 7, [ 24 ] ], [ "He", 5, [ 2 ] ], 
  [ "Co2", 3, [ 23 ] ], [ "Fi22", 5, [ 2 ] ], [ "Fi22", 7, [ 2 ] ], 
  [ "Fi23", 5, [ 235 ] ], [ "Fi23", 7, [ 2 ] ], [ "B", 7, [ 2 ] ] 
 ]

##  doc2/ctblpope.xml (4461-4496)
gap> prove_generation:= function( name, p )
>    local S, prg, P, reps, good, x, g, U;

>    prg:= AtlasProgram( name, "classes" );
>    if prg = fail then
>      return fail;
>    fi;

>    S:= AtlasGroup( name );
>    P:= SylowSubgroup( S, p );
>    reps:= ResultOfStraightLineProgram( prg.program, GeneratorsOfGroup( S ) );
>    good:= [];
>    for x in Filtered( reps, x -> Order( x ) <> 1 ) do
>      repeat
>        g:= Random( S );
>        U:= ClosureGroup( P, x^g );
>      until Size( U ) = Size( S );
>      Add( good, x^g );
>    od;

>    return [ P, good ];
>  end;;
gap> for entry in badcases_strong do
>      res:= prove_generation( entry[1], entry[2] );
>      if res = fail then
>        Print( "no classes script for ", entry, "\n" );
>      fi;
>    od;
no classes script for [ "He", 5, [ 2 ] ]
no classes script for [ "Fi22", 5, [ 2 ] ]
no classes script for [ "Fi22", 7, [ 2 ] ]
no classes script for [ "Fi23", 5, [ 235 ] ]
no classes script for [ "Fi23", 7, [ 2 ] ]
no classes script for [ "B", 7, [ 2 ] ]

##  doc2/ctblpope.xml (4511-4522)
gap> S:= AtlasGroup( "He" );;
gap> repeat
>      x:= Random( S );
>    until Order( x ) = 10;
gap> x:= x^5;;
gap> P5:= SylowSubgroup( S, 5 );;
gap> repeat
>      g:= Random( S );
>      U:= ClosureGroup( P5, x^g );
>    until Size( U ) = Size( S );

##  doc2/ctblpope.xml (4531-4547)
gap> S:= AtlasGroup( "Fi22" );;
gap> repeat
>      x:= Random( S );
>    until Order( x ) = 30;
gap> x:= x^15;;
gap> P5:= SylowSubgroup( S, 5 );;
gap> repeat
>      g:= Random( S );
>      U:= ClosureGroup( P5, x^g );
>    until Size( U ) = Size( S );
gap> P7:= SylowSubgroup( S, 7 );;
gap> repeat
>      g:= Random( S );
>      U:= ClosureGroup( P7, x^g );
>    until Size( U ) = Size( S );

##  doc2/ctblpope.xml (4556-4572)
gap> S:= AtlasGroup( "Fi23" );;
gap> repeat
>      x:= Random( S );
>    until Order( x ) = 42;
gap> x:= x^21;;
gap> P5:= SylowSubgroup( S, 5 );;
gap> repeat
>      g:= Random( S );
>      U:= ClosureGroup( P5, x^g );
>    until Size( U ) = Size( S );
gap> P7:= SylowSubgroup( S, 7 );;
gap> repeat
>      g:= Random( S );
>      U:= ClosureGroup( P7, x^g );
>    until Size( U ) = Size( S );

##  doc2/ctblpope.xml (4581-4590)
gap> repeat
>      x:= Random( S );
>    until Order( x ) = 60;
gap> x:= x^30;;
gap> repeat
>      g:= Random( S );
>      U:= ClosureGroup( P5, x^g );
>    until Size( U ) = Size( S );

##  doc2/ctblpope.xml (4599-4608)
gap> repeat
>      x:= Random( S );
>    until Order( x ) = 60;
gap> x:= x^20;;
gap> repeat
>      g:= Random( S );
>      U:= ClosureGroup( P5, x^g );
>    until Size( U ) = Size( S );

##  doc2/ctblpope.xml (4624-4635)
gap> t:= CharacterTable( "B" );;
gap> 7pos:= Positions( OrdersClassRepresentatives( t ), 7 );
31 ]
gap> 47pos:= Positions( OrdersClassRepresentatives( t ), 47 );
172173 ]
gap> ClassMultiplicationCoefficient( t, 27pos[1], 47pos[1] );
7332
gap> Filtered( Maxes( t ),
>        x -> Size( CharacterTable( x ) ) mod 47 = 0 );
[ "47:23" ]

##  doc2/ctblpope.xml (4668-4699)
gap> dir:= DirectoriesPackageLibrary( "ctbllib", "data" );;
gap> filename:= Filename( dir, "prim_perm_M.json" );;
gap> Monster_prim_data:= EvalString( StringFile( filename ) )[2];;
gap> Length( Monster_prim_data );
46
gap> t:= CharacterTable( "M" );;
gap> monstermaxindices:= [];;
gap> monstermaxtables:= [];;
gap> for entry in Monster_prim_data do
>      if Length( entry ) = 1 then
>        s:= CharacterTable( entry[1] );
>        Add( monstermaxtables, s );
>        Add( monstermaxindices, Size( t ) / Size( s ) );
>      else
>        Add( monstermaxtables, fail );
>        Add( monstermaxindices, entry[2][1] );
>      fi;
>    od;
gap> odd_prim:= [];;
gap> for i in [ 1 .. Length( Monster_prim_data ) ] do
>      if monstermaxindices[i] mod 2 <> 0 then
>        if monstermaxtables[i] <> fail then
>          Add( odd_prim, TrivialCharacter( monstermaxtables[i] )^t );
>        else
>          Add( odd_prim, Monster_prim_data[i][2] );
>        fi;
>      fi;
>    od;
gap> Length( odd_prim );
5

##  doc2/ctblpope.xml (4707-4713)
gap> sum:= normindices.M * Sum( odd_prim, pi -> pi / pi[1] );;
gap> max:= Maximum( sum{ [ 2 .. Length( sum ) ] } );
12784979/103007903752128375
gap> max < 10^-9;
true

##  doc2/ctblpope.xml (4745-4780)
gap> t:= CharacterTable( "M" );;
gap> orders:= OrdersClassRepresentatives( t );;
gap> for p in Difference( PrimeDivisors( Size( t ) ), [ 19 ] ) do
>   goodpos:= Filtered( [ 1 .. Length( Monster_prim_data ) ],
>                       i -> monstermaxindices[i] mod p <> 0 );
>   sum:= ListWithIdenticalEntries( NrConjugacyClasses( t ), 0 );
>   for i in goodpos do
>     if Length( Monster_prim_data[i] ) = 2 then
>       # We know the permutation character but not the subgroup table.
>       sum:= sum + upper_bound( t, fail, p )
>                   * Monster_prim_data[i][2] / monstermaxindices[i];
>     else
>       s:= monstermaxtables[i];
>       if GetFusionMap( s, t ) <> fail then
>         # We can compute the permutation character.
>         sum:= sum + upper_bound( t, s, p )
>                     * TrivialCharacter( s )^t / monstermaxindices[i];
>       else
>         # We get only candidates for the permutation character.
>         cand:= Set( PossibleClassFusions( s, t ),
>                     map -> InducedClassFunctionsByFusionMap( s, t,
>                                [ TrivialCharacter( s ) ], map )[1] );
>         # For each class, take the maximum of the possible values.
>         sum:= sum + upper_bound( t, s, p )
>                     * List( TransposedMat( cand ), Maximum )
>                     / monstermaxindices[i];
>       fi;
>     fi;
>   od;
>   badpos:= Filtered( [ 2 .. Length( sum ) ], i -> sum[i] >= 1 );
>   if badpos <> [] then
>     Error( "check open cases in ", badpos, "\n" );
>   fi;
> od;

##  doc2/ctblpope.xml (4795-4808)
gap> pos19:= Positions( OrdersClassRepresentatives( t ), 19 );
63 ]
gap> pos71:= Positions( OrdersClassRepresentatives( t ), 71 );
169170 ]
gap> ClassMultiplicationCoefficient( t, pos19[1], pos19[1], pos71[1] );
621743152370566020417806353602387433415016198936
gap> ForAny( monstermaxindices,
>            x -> ( Size( t ) / x ) mod ( 19 * 71 ) = 0 );
false
gap> ForAny( [ "L2(13)", "U3(4)", "U3(8)", "Sz(8)" ],
>            x -> Size( CharacterTable( x ) ) mod 71 = 0 );
false

##
gap> if IsBound( BrowseData ) then
>      data:= BrowseData.defaults.dynamic.replayDefaults;
>      data.replayInterval:= oldinterval;
>    fi;

##
gap> STOP_TEST( "ctblpope.tst" );
gap> SizeScreen( save );;

#############################################################################
##
#E

[zur Elbe Produktseite wechseln0.79QuellennavigatorsAnalyse erneut starten2026-06-17]