69.2 Class Fusions between Character Tables

Called with two character tables tbl1 and tbl2, FusionConjugacyClasses returns the fusion of conjugacy classes between tbl1 and tbl2. (If one of the tables is a Brauer table, it will delegate this task to the underlying ordinary table.)

Called with two groups H and G where H is a subgroup of G, FusionConjugacyClasses returns the fusion of conjugacy classes between H and G. This is done by delegating to the ordinary character tables of H and G, since class fusions are stored only for character tables and not for groups.

Note that the returned class fusion refers to the ordering of conjugacy classes in the character tables if the arguments are character tables and to the ordering of conjugacy classes in the groups if the arguments are groups (see ConjugacyClasses.ctbl).

Called with a group homomorphism hom, FusionConjugacyClasses returns the fusion of conjugacy classes between the preimage and the image of hom; contrary to the two cases above, also factor fusions can be handled by this variant. If hom is the only argument then the class fusion refers to the ordering of conjugacy classes in the groups. If the character tables of preimage and image are given as tbl1 and tbl2, respectively (each table with its group stored), then the fusion refers to the ordering of classes in these tables.

If no class fusion exists or if the class fusion is not uniquely determined, fail is returned; this may happen when FusionConjugacyClasses is called with two character tables that do not know compatible underlying groups.

Methods for the computation of class fusions can be installed for the operation FusionConjugacyClassesOp.

gap> s4:= SymmetricGroup( 4 );
Sym( [ 1 .. 4 ] )
gap> tbls4:= CharacterTable( s4 );;
gap> d8:= SylowSubgroup( s4, 2 );
Group([ (1,2), (3,4), (1,3)(2,4) ])
gap> FusionConjugacyClasses( d8, s4 );
[ 1, 2, 3, 3, 5 ]
gap> tbls5:= CharacterTable( "S5" );;
gap> FusionConjugacyClasses( CharacterTable( "A5" ), tbls5 );
[ 1, 2, 3, 4, 4 ]
gap> FusionConjugacyClasses( CharacterTable( "A5" ), CharacterTable( "J1" ) );
fail
gap> PossibleClassFusions( CharacterTable( "A5" ), CharacterTable( "J1" ) );
[ [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 5, 4 ] ]

The class fusions from the character table tbl that have been computed already by FusionConjugacyClasses (see FusionConjugacyClasses) or explicitly stored by StoreFusion (see StoreFusion) are stored in the ComputedClassFusions list of tbl1. Each entry of this list is a record with the following components.

name

the Identifier value of the character table to which the fusion maps,

map

the list of positions of image classes,

text (optional)

a string giving additional information about the fusion map, for example whether the map is uniquely determined by the character tables,

specification (optional, rarely used)

a value that distinguishes different fusions between the same tables.

Note that stored fusion maps may differ from the maps returned by GetFusionMap and the maps entered by StoreFusion if the table destination has a nonidentity ClassPermutation value. So if one fetches a fusion map from a table tbl1 to a table tbl2 via access to the data in the ComputedFusionMaps list tbl1 then the stored value must be composed with the ClassPermutation value of tbl2 in order to obtain the correct class fusion. (If one handles fusions only via GetFusionMap and StoreFusion (see GetFusionMap, StoreFusion) then this adjustment is made automatically.)

Fusions are identified via the Identifier value of the destination table and not by this table itself because many fusions between character tables in the GAP character table library are stored on library tables, and it is not desirable to load together with a library table also all those character tables that occur as destinations of fusions from this table.

For storing fusions and accessing stored fusions, see also GetFusionMap, StoreFusion. For accessing the identifiers of tables that store a fusion into a given character table, see NamesOfFusionSources.

For two ordinary character tables source and destination, GetFusionMap checks whether the ComputedClassFusion list of source (see ComputedClassFusions) contains a record with name component Identifier( destination ), and returns returns the map component of the first such record. GetFusionMap( source, destination, specification ) fetches that fusion map for which the record additionally has the specification component specification.

If both source and destination are Brauer tables, first the same is done, and if no fusion map was found then GetFusionMap looks whether a fusion map between the ordinary tables is stored; if so then the fusion map between source and destination is stored on source, and then returned.

If no appropriate fusion is found, GetFusionMap returns fail. For the computation of class fusions, see FusionConjugacyClasses.

For two character tables source and destination, StoreFusion stores the fusion fusion from source to destination in the ComputedClassFusions list (see ComputedClassFusions) of source, and adds the Identifier string of destination to the NamesOfFusionSources list (see NamesOfFusionSources) of destination.

fusion can either be a fusion map (that is, the list of positions of the image classes) or a record as described in ComputedClassFusions.

If fusions to destination are already stored on source then another fusion can be stored only if it has a record component specification that distinguishes it from the stored fusions. In the case of such an ambiguity, StoreFusion raises an error.

gap> ComputedClassFusions( CharacterTable( d8 ) );
[ rec( name := "CT1", map := [ 1, 2, 3, 3, 5 ] ) ]
gap> Identifier( tbls4 );
"CT1"
gap> GetFusionMap( CharacterTable( d8 ), tbls4 );
[ 1, 2, 3, 3, 5 ]
gap> GetFusionMap( tbls4, tbls5 );
fail
gap> poss:= PossibleClassFusions( tbls4, tbls5 );
[ [ 1, 5, 2, 3, 6 ] ]
gap> StoreFusion( tbls4, poss[1], tbls5 );
gap> GetFusionMap( tbls4, tbls5 );
[ 1, 5, 2, 3, 6 ]

For a character table tbl, NamesOfFusionSources returns the list of identifiers of all those character tables that are known to have fusions to tbl stored. The NamesOfFusionSources value is updated whenever a fusion to tbl is stored using StoreFusion (see StoreFusion).

gap> NamesOfFusionSources( tbls5 );
[ "2.A5.2", "A5", "S3x2","3^1+4:2^1+4.s5", "s4","5:4","CT1" ]

For two ordinary character tables subtbl and tbl of the groups H and G, say, PossibleClassFusions returns the list of all maps that have the following properties of class fusions from subtbl to tbl.

1.

For class i, the centralizer order of the image in G is a multiple of the i-th centralizer order in H, and the element orders in the i-th class and its image are equal. These criteria are checked in InitFusion (see InitFusion).

2.

The class fusion commutes with power maps. This is checked using TestConsistencyMaps (see TestConsistencyMaps).

3.

If the permutation character of G corresponding to the action of G on the cosets of H is specified (see the discussion of the options argument below) then it prescribes for each class C of G the number of elements of H fusing into C. The corresponding function is CheckPermChar (see CheckPermChar).

4.

The table automorphisms of tbl (see AutomorphismsOfTable) are used in order to compute only orbit representatives. (But note that the list returned by PossibleClassFusions contains the full orbits.)

5.

For each character c of G, the restriction to H via the class fusion is a character of H. This condition is checked for all characters specified below, the corresponding function is FusionsAllowedByRestrictions (see FusionsAllowedByRestrictions).

If subtbl and tbl are Brauer tables then the possibilities are computed from those for the underlying ordinary tables.

The optional argument options must be a record that may have the following components:

chars

a list of characters of tbl which are used for the check of 5.; the default is Irr( tbl ),

subchars

a list of characters of subtbl which are constituents of the retrictions of chars, the default is Irr( subtbl ),

fusionmap

a parametrized map which is an approximation of the desired map,

decompose

a boolean; a true value indicates that all constituents of the restrictions of chars computed for criterion 5. lie in subchars, so the restrictions can be decomposed into elements of subchars; the default value of decompose is true if subchars is not bound and Irr( subtbl ) is known, otherwise false,

permchar

(a values list of) a permutation character; only those fusions affording that permutation character are computed,

quick

a boolean; if true then the subroutines are called with value true for the argument quick; especially, as soon as only one possibility remains this possibility is returned immediately; the default value is false

parameters

a record with components maxamb, minamb and maxlen which control the subroutine FusionsAllowedByRestrictions; it only uses characters with current indeterminateness up to maxamb, tests decomposability only for characters with current indeterminateness at least minamb, and admits a branch according to a character only if there is one with at most maxlen possible restrictions.

gap> subtbl:= CharacterTable( "U3(3)" );;  tbl:= CharacterTable( "J4" );;
gap> PossibleClassFusions( subtbl, tbl );
[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ], 
  [ 1, 2, 4, 4, 5, 5, 6, 10, 13, 12, 14, 14, 21, 21 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 15, 15, 22, 22 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 12, 13, 16, 16, 22, 22 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 13, 12, 15, 15, 22, 22 ], 
  [ 1, 2, 4, 4, 6, 6, 6, 10, 13, 12, 16, 16, 22, 22 ] ]

The permutation groups of table automorphisms (see AutomorphismsOfTable) of the subgroup table subtbl and the supergroup table tbl act on the possible class fusions returned by PossibleClassFusions (see PossibleClassFusions), the former by permuting a list via Permuted (see Permuted), the latter by mapping the images via OnPoints (see OnPoints).

If the set of possible fusions with certain properties was computed that are not invariant under the full groups of table automorphisms then only a smaller group acts. This may happen for example if a permutation character or if an explicit approximation of the fusion map is prescribed in the call of PossibleClassFusions.

returns the orbit of the class fusion map fusionmap under the actions of the permutation groups subtblautomorphisms and tblautomorphisms of automorphisms of the character table of the subgroup and the supergroup, respectively.

returns a list of orbit representatives of class fusion maps in the list listofmaps under the action of maximal admissible subgroups of the table automorphisms subtblautomorphisms of the subgroup table and tblautomorphisms of the supergroup table. Both groups of table automorphisms must be permutation groups.

Instead of the groups of table automorphisms, also the character tables subtbl and tbl may be entered. In this case, the AutomorphismsOfTable values of the tables are used.

gap> fus:= GetFusionMap( subtbl, tbl );
[ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ]
gap> orb:= OrbitFusions( AutomorphismsOfTable( subtbl ), fus,
>              AutomorphismsOfTable( tbl ) );
[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ], 
  [ 1, 2, 4, 4, 5, 5, 6, 10, 13, 12, 14, 14, 21, 21 ] ]
gap> rep:= RepresentativesFusions( AutomorphismsOfTable( subtbl ), orb,
>              AutomorphismsOfTable( tbl ) );
[ [ 1, 2, 4, 4, 5, 5, 6, 10, 12, 13, 14, 14, 21, 21 ] ]

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