69.4 Subroutines for the Construction of Power Maps

For an ordinary character table tbl and a prime prime, InitPowerMap returns a parametrized map that is a first approximation of the prime-th powermap of tbl, using the conditions 1. and 2. listed in the description of PossiblePowerMaps (see PossiblePowerMaps).

If there are classes for which no images are possible, according to these criteria, then fail is returned.

gap> t:= CharacterTable( "U4(3).4" );;
gap> pow:= InitPowerMap( t, 2 );
[ 1, 1, 3, 4, 5, [ 2, 16 ], [ 2, 16, 17 ], 8, 3, [ 3, 4 ], 
  [ 11, 12 ], [ 11, 12 ], [ 6, 7, 18, 19, 30, 31, 32, 33 ], 14, 
  [ 9, 20 ], 1, 1, 2, 2, 3, [ 3, 4, 5 ], [ 3, 4, 5 ], 
  [ 6, 7, 18, 19, 30, 31, 32, 33 ], 8, 9, 9, [ 9, 10, 20, 21, 22 ], 
  [ 11, 12 ], [ 11, 12 ], 16, 16, [ 2, 16 ], [ 2, 16 ], 17, 17, 
  [ 6, 18, 30, 31, 32, 33 ], [ 6, 18, 30, 31, 32, 33 ], 
  [ 6, 7, 18, 19, 30, 31, 32, 33 ], [ 6, 7, 18, 19, 30, 31, 32, 33 ], 
  20, 20, [ 9, 20 ], [ 9, 20 ], [ 9, 10, 20, 21, 22 ], 
  [ 9, 10, 20, 21, 22 ], 24, 24, [ 15, 25, 26, 40, 41, 42, 43 ], 
  [ 15, 25, 26, 40, 41, 42, 43 ], [ 28, 29 ], [ 28, 29 ], [ 28, 29 ], 
  [ 28, 29 ] ]

In the argument lists of the functions Congruences, ConsiderKernels, and ConsiderSmallerPowerMaps, tbl is an ordinary character table, chars a list of (values lists of) characters of tbl, prime a prime integer, approxmap a parametrized map that is an approximation for the prime-th power map of tbl (e.g., a list returned by InitPowerMap, see InitPowerMap), and quick a boolean.

The quick value true means that only those classes are considered for which approxmap lists more than one possible image.

Congruences replaces the entries of approxmap by improved values, according to condition 3. listed in the description of PossiblePowerMaps (see PossiblePowerMaps).

For each class for which no images are possible according to the tests, the new value of approxmap is an empty list. Congruences returns true if no such inconsistencies occur, and false otherwise.

gap> Congruences( t, Irr( t ), pow, 2, false );  pow;
true
[ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, [ 6, 7 ], 14, 9, 1, 1, 2, 2, 3, 4, 5, 
  [ 6, 7 ], 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 18, [ 18, 19 ], 
  [ 18, 19 ], 20, 20, 20, 20, 22, 22, 24, 24, [ 25, 26 ], [ 25, 26 ], 28, 28, 
  29, 29 ]

ConsiderKernels replaces the entries of approxmap by improved values, according to condition 4. listed in the description of PossiblePowerMaps (see PossiblePowerMaps).

Congruences returns true if the orders of the kernels of all characters in chars divide the order of the group of tbl, and false otherwise.

gap> t:= CharacterTable( "A7.2" );;  init:= InitPowerMap( t, 2 );
[ 1, 1, 3, 4, [ 2, 9, 10 ], 6, 3, 8, 1, 1, [ 2, 9, 10 ], 3, [ 3, 4 ], 6, 
  [ 7, 12 ] ]
gap> ConsiderKernels( t, Irr( t ), init, 2, false );
true
gap> init;
[ 1, 1, 3, 4, 2, 6, 3, 8, 1, 1, 2, 3, [ 3, 4 ], 6, 7 ]

ConsiderSmallerPowerMaps replaces the entries of approxmap by improved values, according to condition 5. listed in the description of PossiblePowerMaps (see PossiblePowerMaps).

ConsiderSmallerPowerMaps returns true if each class admits at least one image after the checks, otherwise false is returned. If no element orders of tbl are stored (see OrdersClassRepresentatives) then true is returned without any tests.

gap> t:= CharacterTable( "3.A6" );;  init:= InitPowerMap( t, 5 );
[ 1, [ 2, 3 ], [ 2, 3 ], 4, [ 5, 6 ], [ 5, 6 ], [ 7, 8 ], [ 7, 8 ], 9, 
  [ 10, 11 ], [ 10, 11 ], 1, [ 2, 3 ], [ 2, 3 ], 1, [ 2, 3 ], [ 2, 3 ] ]
gap> Indeterminateness( init );
4096
gap> ConsiderSmallerPowerMaps( t, init, 5, false );
true
gap> Indeterminateness( init );
256

Let character be (the list of values of) a class function c, prime a prime integer p, and prime_powermap a parametrized map that is an approximation of the p-th power map for the character table of c. MinusCharacter returns the parametrized map of values of c^p-, which is defined by c^p-(g) = ( c(g)^p - c(g^p) ) / p.

gap> tbl:= CharacterTable( "S7" );;  pow:= InitPowerMap( tbl, 2 );;
gap> pow;
[ 1, 1, 3, 4, [ 2, 9, 10 ], 6, 3, 8, 1, 1, [ 2, 9, 10 ], 3, [ 3, 4 ], 6, 
  [ 7, 12 ] ]
gap> chars:= Irr( tbl ){ [ 2 .. 5 ] };;
gap> List( chars, x -> MinusCharacter( x, pow, 2 ) );
[ [ 0, 0, 0, 0, [ 0, 1 ], 0, 0, 0, 0, 0, [ 0, 1 ], 0, 0, 0, [ 0, 1 ] ], 
  [ 15, -1, 3, 0, [ -2, -1, 0 ], 0, -1, 1, 5, -3, [ 0, 1, 2 ], -1, 0, 0, 
      [ 0, 1 ] ], 
  [ 15, -1, 3, 0, [ -1, 0, 2 ], 0, -1, 1, 5, -3, [ 1, 2, 4 ], -1, 0, 0, 1 ], 
  [ 190, -2, 1, 1, [ 0, 2 ], 0, 1, 1, -10, -10, [ 0, 2 ], -1, -1, 0, 
      [ -1, 0 ] ] ]

Let tbl be an ordinary character table, prime a prime integer, approxmap a parametrized map that is an approximation of the prime-th power map of tbl (e.g., a list returned by InitPowerMap, see InitPowerMap), chars and subchars two lists of (values lists of) characters of tbl, and parameters a record with components maxlen, minamb, maxamb (three integers), quick (a boolean), and contained (a function). Usual values of contained are ContainedCharacters or ContainedPossibleCharacters.

PowerMapsAllowedBySymmetrizations replaces the entries of approxmap by improved values, according to condition 6. listed in the description of PossiblePowerMaps (see PossiblePowerMaps).

More precisely, the strategy used is as follows.

First, for each c Î chars , let minus:= MinusCharacter( c, approxmap, prime ).

-

If Indeterminateness( minus ) = 1 and parameters.quick = false then the scalar products of minus with subchars are checked; if not all scalar products are nonnegative integers then an empty list is returned, otherwise c is deleted from the list of characters to inspect.

-

Otherwise if Indeterminateness( minus ) is smaller than parameters.minamb then c is deleted from the list of characters.

-

If parameters.minamb £ Indeterminateness( minus ) £ parameters.maxamb then construct the list of contained class functions poss:= parameters.contained( tbl, subchars, minus ) and Parametrized( poss ), and improve the approximation of the power map using UpdateMap.

If this yields no further immediate improvements then we branch. If there is a character from chars left with less or equal parameters.maxlen possible symmetrizations, compute the union of power maps allowed by these possibilities. Otherwise we choose a class C such that the possible symmetrizations of a character in chars differ at C, and compute recursively the union of all allowed power maps with image at C fixed in the set given by the current approximation of the power map.

gap> tbl:= CharacterTable( "U4(3).4" );;
gap> pow:= InitPowerMap( tbl, 2 );;
gap> Congruences( tbl, Irr( tbl ), pow, 2 );;  pow;
[ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, [ 6, 7 ], 14, 9, 1, 1, 2, 2, 3, 4, 5, 
  [ 6, 7 ], 8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 18, [ 18, 19 ], 
  [ 18, 19 ], 20, 20, 20, 20, 22, 22, 24, 24, [ 25, 26 ], [ 25, 26 ], 28, 28, 
  29, 29 ]
gap> PowerMapsAllowedBySymmetrizations( tbl, Irr( tbl ), Irr( tbl ),
>       pow, 2, rec( maxlen:= 10, contained:= ContainedPossibleCharacters,
>       minamb:= 2, maxamb:= infinity, quick:= false ) );
[ [ 1, 1, 3, 4, 5, 2, 2, 8, 3, 4, 11, 12, 6, 14, 9, 1, 1, 2, 2, 3, 4, 5, 6, 
      8, 9, 9, 10, 11, 12, 16, 16, 16, 16, 17, 17, 18, 18, 18, 18, 20, 20, 
      20, 20, 22, 22, 24, 24, 25, 26, 28, 28, 29, 29 ] ]

[Top] [Previous] [Up] [Next] [Index]