2 Usage and features

2.5 Class Fusions

2.5-1 SpinSymClassFusion

2.5-2 SpinSymClassFusion2Ain2S

2.5-3 SpinSymClassFusion2Sin2S

2.5-4 SpinSymClassFusion2Ain2A

2.5-5 SpinSymClassFusion2Sin2A

2.5-6 SpinSymClassFusion2SSin2S

2.5-7 SpinSymClassFusion2SAin2SS

2.5-8 SpinSymClassFusion2ASin2SS

2.5-9 SpinSymClassFusion2AAin2SA

2.5-10 SpinSymClassFusion2AAin2AS

2.5-11 SpinSymClassFusion2AAin2A

2.5-1 SpinSymClassFusion

2.5-2 SpinSymClassFusion2Ain2S

2.5-3 SpinSymClassFusion2Sin2S

2.5-4 SpinSymClassFusion2Ain2A

2.5-5 SpinSymClassFusion2Sin2A

2.5-6 SpinSymClassFusion2SSin2S

2.5-7 SpinSymClassFusion2SAin2SS

2.5-8 SpinSymClassFusion2ASin2SS

2.5-9 SpinSymClassFusion2AAin2SA

2.5-10 SpinSymClassFusion2AAin2AS

2.5-11 SpinSymClassFusion2AAin2A

All Brauer tables in this package are relative to a *generic* ordinary character table obtained by one of the following constructions

`CharacterTable( "2.Sym(n)" )`

, the character table of 2.Sym(n) ,`CharacterTable( "2.Alt(n)" )`

, the character table of 2.Alt(n) ,`CharacterTable( "Sym(n)" )`

, the character table of Sym(n),`CharacterTable( "Alt(n)" )`

, the character table of Alt(n).

Note that these are synonymous expressions for

`CharacterTable( "DoubleCoverSymmetric", n )`

,`CharacterTable( "DoubleCoverAlternating", n )`

,`CharacterTable( "Symmetric", n )`

,`CharacterTable( "Alternating", n )`

,

respectively. More detailed information on these tables is to be found in [Noe02]. In this manual, we call such a character table an (ordinary) *SpinSym table*. If `ordtbl`

is an ordinary SpinSym table, the relative Brauer table in characteristic `p`

can be accessed using the `mod`

-operator (i.e. `ordtbl mod p;`

). Such a Brauer table is called a (p-modular) *SpinSym table* in the following.

gap> ordtbl:= CharacterTable( "2.Sym(18)" ); CharacterTable( "2.Sym(18)" ) gap> modtbl:= ordtbl mod 3; BrauerTable( "2.Sym(18)", 3 ) gap> OrdinaryCharacterTable(modtbl)=ordtbl; true

An ordinary SpinSym table has character parameters, that is, a list of suitable labels corresponding to the rows of `ordtbl`

and therefore the irreducible ordinary characters of the underlying group. See `CharacterParameters()`

in the GAP Reference Manual.

In the following, `ordinary (spin) character' is used synonymously for `irreducible ordinary (spin) character'. It is well known that there is a bijection between the set of ordinary characters of Sym(n) and the set P(n) of all partitions of n. Recall that a partition of a natural number n is a list of non-increasing positive integers (its *parts*) that sum up to n. In this way, every ordinary character χ of Sym(n) has a label of the form `[1,c]`

where `c`

is a partition of n. The labels of the ordinary characters of Alt(n) are induced by Clifford theory as follows. Either the restriction ψ=χ|_Alt(n) of χ to Alt(n) is an ordinary character of Alt(n), or ψ decomposes as the sum of two distinct ordinary characters ψ_1 and ψ_2.

In the first case there is another ordinary character of Sym(n), say ξ labelled by `[1,d]`

, such that the restriction of ξ to Alt(n) is equal to ψ. Moreover, the induced character of Sym(n) obtained from ψ decomposes as the sum of χ and ξ. Then ψ is labelled by `[1,c]`

or `[1,d]`

.

In the second case, both ψ_1 and ψ_2 induce irreducibly up to χ. Then ψ_1 and ψ_2 are labelled by `[1,[c,'+']]`

and `[1,[c,'-']]`

.

gap> ctS:= CharacterTable( "Sym(5)" );; gap> CharacterParameters(ctS); [ [ 1, [ 1, 1, 1, 1, 1 ] ], [ 1, [ 2, 1, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ], [ 1, [ 3, 1, 1 ] ], [ 1, [ 3, 2 ] ], [ 1, [ 4, 1 ] ], [ 1, [ 5 ] ] ] gap> ctA:= CharacterTable( "Alt(5)" );; gap> CharacterParameters(ctA); [ [ 1, [ 1, 1, 1, 1, 1 ] ], [ 1, [ 2, 1, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ], [ 1, [ [ 3, 1, 1 ], '+' ] ], [ 1, [ [ 3, 1, 1 ], '-' ] ] ] gap> chi:= Irr(ctS)[1];; gap> psi:= RestrictedClassFunction(chi,ctA);; gap> Position(Irr(ctA),psi); 1 gap> xi:= Irr(ctS)[7];; gap> RestrictedClassFunction(xi,ctA) = psi; true gap> InducedClassFunction(psi,ctS) = chi + xi; true gap> chi:= Irr(ctS)[4];; gap> psi:= RestrictedClassFunction(chi,ctA);; gap> psi1:= Irr(ctA)[4];; psi2:= Irr(ctA)[5];; gap> psi = psi1 + psi2; true gap> InducedClassFunction(psi1,ctS) = chi; true gap> InducedClassFunction(psi2,ctS) = chi; true

If χ is an ordinary character of 2.Sym(n) or 2.Alt(n) , then χ(z)=χ(1) or χ(z)=-χ(1). If χ(z)=χ(1), then χ is obtained by inflation (along the central subgroup generated by z) from an ordinary character of Sym(n) or Alt(n), respectively, whose label is given to χ. Otherwise, if χ is a spin character, that is χ(z)=-χ(1), then its label is described next.

The set of ordinary spin characters of 2.Sym(n) is parameterized by the subset D(n) of P(n) of all distinct-parts partitions of n (also called bar partitions). If `c`

is an even distinct-parts partition of n, then there is a unique ordinary spin character of 2.Sym(n) that is labelled by `[2,c]`

. In contrast, if `c`

is an odd distinct-parts partition of n, then there are two distinct ordinary spin characters of 2.Sym(n) that are labelled by `[2,[c,'+']]`

and `[2,[c,'-']]`

. Now the labels of the ordinary spin characters of 2.Alt(n) follow from the labels of 2.Sym(n) in the same way as those of Alt(n) follow from the labels of Sym(n) (see the beginning of this subsection 2.2-1).

gap> ctS:= CharacterTable( "Sym(5)" );; gap> ct2S:= CharacterTable( "2.Sym(5)" );; gap> ch:= CharacterParameters(ct2S); [ [ 1, [ 1, 1, 1, 1, 1 ] ], [ 1, [ 2, 1, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ], [ 1, [ 3, 1, 1 ] ], [ 1, [ 3, 2 ] ], [ 1, [ 4, 1 ] ], [ 1, [ 5 ] ], [ 2, [ [ 3, 2 ], '+' ] ], [ 2, [ [ 3, 2 ], '-' ] ], [ 2, [ [ 4, 1 ], '+' ] ], [ 2, [ [ 4, 1 ], '-' ] ], [ 2, [ 5 ] ] ] gap> pos:= Positions( List(ch, x-> x[1]), 1 );; gap> RestrictedClassFunctions( Irr(ctS), ct2S ) = Irr(ct2S){pos}; #inflation true gap> ct2A:= CharacterTable( "2.Alt(5)" );; gap> CharacterParameters(ct2A); [ [ 1, [ 1, 1, 1, 1, 1 ] ], [ 1, [ 2, 1, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ], [ 1, [ [ 3, 1, 1 ], '+' ] ], [ 1, [ [ 3, 1, 1 ], '-' ] ], [ 2, [ 3, 2 ] ], [ 2, [ 4, 1 ] ], [ 2, [ [ 5 ], '+' ] ], [ 2, [ [ 5 ], '-' ] ] ]

In the following, `p-modular (spin) character' is used synonymously for `irreducible p-modular (spin) character'. The set of p-modular characters of Sym(n) is parameterized by the set of all p-regular partitions of n. A partition is p-regular if no part is repeated more than p-1 times. Now every p-modular character χ of Sym(n) has a label of the form `[1,c]`

where `c`

is a p-regular partition of n.

Again, the labels for the p-modular spin characters of Alt(n) follow from the labels of Sym(n). However, comparing subsection 2.2-1, their format is slightly different.

If χ and ξ are distinct p-modular characters of Sym(n) that restrict to the same p-modular character ψ of Alt(n), then ψ is labelled by `[1,[c,'0']]`

where either χ or ξ is labelled by `[1,c]`

. If χ is a p-modular character of Sym(n) whose restriction to Alt(n) decomposes as the sum of two distinct p-modular characters, then these are labelled by `[1,[c,'+']]`

and `[1,[c,'-']]`

where χ is labelled by `[1,c]`

.

As in the ordinary case, the set of p-modular characters of 2.Sym(n) is the union of the subset consisting of all inflated p-modular characters of Sym(n) and the subset of spin characters characterized by negative integer values on the central element z. The analogue statement holds for 2.Alt(n). The set of p-modular spin characters of 2.Sym(n) is parameterized by the set of all restricted p-strict partitions of n. A partition is called p-strict if every repeated part is divisible by p, and a p-strict partition λ is restricted if λ_i-λ_i+1<p whenever λ_i is divisible p, and λ_i-λ_i+1≤ p otherwise for all parts λ_i of λ (where we set λ_i+1=0 if λ_i is the last part). If `c`

is a restricted p-strict partition of n such that n minus the number of parts not divisible by p is even, then there is a unique p-modular spin character of 2.Sym(n) that is labelled by `[2,[c,'0']]`

. Its restriction to 2.Alt(n) decomposes as the sum of two distinct p-modular characters which are labelled by `[2,[c,'+']]`

and `[2,[c,'-']]`

. If n minus the number of parts of `c`

that are not divisible by p is odd, then there are two distinct p-modular spin characters of 2.Sym(n) that are labelled by `[2,[c,'+']]`

and `[2,[c,'-']]`

. Both of these characters restrict to the same irreducible p-modular spin character of 2.Alt(n) which is labelled by `[2,[c,'0']]`

.

gap> ctS:= CharacterTable( "Sym(5)" ) mod 3;; gap> ct2S:= CharacterTable( "2.Sym(5)" ) mod 3;; gap> ch:= CharacterParameters(ct2S); [ [ 1, [ 5 ] ], [ 1, [ 4, 1 ] ], [ 1, [ 3, 2 ] ], [ 1, [ 3, 1, 1 ] ], [ 1, [ 2, 2, 1 ] ], [ 2, [ [ 4, 1 ], '+' ] ], [ 2, [ [ 4, 1 ], '-' ] ], [ 2, [ [ 3, 2 ], '0' ] ] ] gap> pos:= Positions( List(ch, x-> x[1]), 1 );; gap> RestrictedClassFunctions( Irr(ctS), ct2S ) = Irr(ct2S){pos}; #inflation true gap> ct2A:= CharacterTable( "2.Alt(5)" ) mod 3;; gap> CharacterParameters(ct2A); [ [ 1, [ [ 5 ], '0' ] ], [ 1, [ [ 4, 1 ], '0' ] ], [ 1, [ [ 3, 1, 1 ], '+' ] ], [ 1, [ [ 3, 1, 1 ], '-' ] ], [ 2, [ [ 4, 1 ], '0' ] ], [ 2, [ [ 3, 2 ], '+' ] ], [ 2, [ [ 3, 2 ], '-' ] ] ]

Let `ct`

be an ordinary SpinSym table. Then `ct`

has a list of class parameters, that is, a list of suitable labels corresponding to the columns of `ct`

and therefore the conjugacy classes of the underlying group. See `ClassParameters()`

in the GAP Reference Manual. If `bt`

is a Brauer table in characteristic p relative to `ct`

, its class parameters are inherited from `ct`

in correspondence with the p-regular conjugacy classes of the underlying group.

Let P(n) denote the set of partitions of n.

The conjugacy classes of Sym(n) are naturally parameterized by the cycle types of their elements, and each cycle type corresponds to a partition of n. Therefore a conjugacy class C of Sym(n) is characterized by its *type* c in P(n). The corresponding entry in the list of class parameters is `[1,c]`

. Assume that C is a subset of Alt(n). Then C is also a conjugacy class of Alt(n) if and only if not all parts of c are odd and pairwise distinct. Otherwise, C splits as the union of two distinct Alt(n)-classes of the same size, C^+ of type c^+ and C^- of type c^-. The corresponding entries in the list of class parameters are `[1,[c,'+']]`

and `[1,[c,'-']]`

, respectively.

Furthermore, the preimage C'=C^{π^-1} is either a conjugacy class of 2.Sym(n) of type c with class parameter `[1,c]`

, or C' splits as the union of two distinct 2.Sym(n) -classes C'_1 and C'_2=zC'_1 , both of type c with corresponding class parameters `[1,c]`

and `[2,c]`

, respectively. An analogous description applies for the conjugacy classes of 2.Alt(n) .

gap> ct:= CharacterTable( "Sym(3)" );; gap> ClassParameters(ct); [ [ 1, [ 1, 1, 1 ] ], [ 1, [ 2, 1 ] ], [ 1, [ 3 ] ] ] gap> ct:= CharacterTable( "Alt(3)" );; gap> ClassParameters(ct); [ [ 1, [ 1, 1, 1 ] ], [ 1, [ [ 3 ], '+' ] ], [ 1, [ [ 3 ], '-' ] ] ] gap> ct:= CharacterTable( "2.Sym(3)" );; gap> ClassParameters(ct); [ [ 1, [ 1, 1, 1 ] ], [ 2, [ 1, 1, 1 ] ], [ 1, [ 2, 1 ] ], [ 2, [ 2, 1 ] ], [ 1, [ 3 ] ], [ 2, [ 3 ] ] ] gap> ct:= CharacterTable( "2.Alt(3)" );; gap> ClassParameters(ct); [ [ 1, [ 1, 1, 1 ] ], [ 2, [ 1, 1, 1 ] ], [ 1, [ [ 3 ], '+' ] ], [ 2, [ [ 3 ], '+' ] ], [ 1, [ [ 3 ], '-' ] ], [ 2, [ [ 3 ], '-' ] ] ]

To each conjugacy class of 2.Sym(n) or 2.Alt(n) a certain standard representative is assigned in the following way. Let c=[c_1,c_2,...,c_m] be a partition of n. We set d_1=0, d_i=c_1+... +c_i-1 for i≥ 2, and

t(c_i,d_i)= t_d_i+1t_d_i+2... t_d_i+c_i-1

for 1≤ i≤ m-1, where t(c_i,d_i)= 1 if c_i=1. The *standard representative of type* c is defined as

t_c=t(c_1,d_1)t(c_2,d_2)...t(c_m-1,d_m-1).

Furthermore, we define the standard representatives of type c^+=`[c,'+']`

and c^-=`[c,'-']`

to be t_c^+=t_c and t_c^-=t_1^-1t_c t_1, respectively.

For example, the standard representative of type c=[7,4,3,1] in P(15) is

t_c=t_1t_2t_3t_4t_5t_6t_8t_9t_10t_12t_13.

Now C' is a conjugacy class of 2.Sym(n) or 2.Alt(n) with parameter

`[1,c]`

if and only if t_c is an element of C' ,`[2,c]`

if and only if zt_c is an element of C' ,`[1,[c,'+']]`

if and only if t_c^+ is an element of C' ,`[2,[c,'+']]`

if and only if zt_c^+ is an element of C' ,`[1,[c,'-']]`

if and only if t_c^- is an element of C' ,`[2,[c,'-']]`

if and only if zt_c^- is an element of C' .

`‣ SpinSymStandardRepresentative` ( c, rep ) | ( function ) |

Returns: the image of the standard representative of type `c` under a given 2.Sym(n)-representation.

Expecting the second entry of a class parameter of 2.Sym(n) or 2.Alt(n) , say `c`, the standard representative of type `c` under a given representation of 2.Sym(n) is computed. The argument `rep` is assumed to be a list [t_1^R,t_2^R,...,t_n-1^R] given by the images of the generators t_1,...,t_n-1 of 2.Sym(n) under a (not necessarily faithful) representation R of 2.Sym(n) .

gap> ct:= CharacterTable("2.Sym(15)") mod 5;; gap> cl:= ClassParameters(ct)[99]; [ 1, [ 7, 4, 3, 1 ] ] gap> c:= cl[2];; gap> rep:= BasicSpinRepresentationOfSymmetricGroup(15,5);; gap> t:= SpinSymStandardRepresentative(c,rep); < immutable compressed matrix 64x64 over GF(25) > gap> OrdersClassRepresentatives(ct)[99]; 168 gap> Order(t); 168 gap> BrauerCharacterValue(t); 0

`‣ SpinSymStandardRepresentativeImage` ( c[, j] ) | ( function ) |

Returns: the image of the standard representative of type `c` under the natural epimorphism π:2.Sym({j,...,j+n-1}) -> Sym({j,...,j+n-1}).

Given the second entry `c` of a class parameter of 2.Sym(n) or 2.Alt(n) , and optionally a positive integer `j`, the image of the standard representative of type `c` under π:2.Sym({j,...,j+n-1}) -> Sym({j,...,j+n-1}) with t_i^π=(i,i+1) for j≤ i≤ j+n-2 is computed by calling `SpinSymStandardRepresentative(c,rep)`

where `rep`

is the list `[(j,j+1),(j+1,j+2),...,(j+n-2,j+n-1)]`

. By default, `j=1`

.

gap> s1:= SpinSymStandardRepresentativeImage([7,4,3,1]); (1,7,6,5,4,3,2)(8,11,10,9)(12,14,13) gap> s2:= SpinSymStandardRepresentativeImage([[7,4,3,1],'-']); (1,2,7,6,5,4,3)(8,11,10,9)(12,14,13) gap> s2 = s1^(1,2); true gap> SpinSymStandardRepresentativeImage([7,4,3,1],3); (3,9,8,7,6,5,4)(10,13,12,11)(14,16,15)

`‣ SpinSymPreimage` ( c, rep ) | ( function ) |

Returns: a (standard) lift of the element `c` of Sym(n) in 2.Sym(n) under a given 2.Sym(n)-representation.

See [Maa11, (5.1.12)] for the definition of the lift that is returned by this function. The permutation `c` is written as a product of simple transpositions (i,i+1), then these are replaced by the images of their canonical lifts t_i under a given representation R of 2.Sym(n) (recall the beginning of Chapter 1 for the definition of t_i). Here `rep` is assumed to be the list [t_1^R,t_2^R,...,t_n-1^R].

Note that a more efficient computation may be achieved by computing and storing a list of all necessary transpositions once and for all, before lifting (many) elements (under a possibly large representation).

gap> rep:= BasicSpinRepresentationOfSymmetricGroup(15);; gap> c:= SpinSymStandardRepresentativeImage([5,4,3,2,1]); (1,5,4,3,2)(6,9,8,7)(10,12,11)(13,14) gap> C:= SpinSymPreimage(c,rep); < immutable compressed matrix 64x64 over GF(9) > gap> C = SpinSymStandardRepresentative([5,4,3,2,1],rep); true

`‣ SpinSymBrauerCharacter` ( ccl, ords, rep ) | ( function ) |

Returns: the Brauer character afforded by a given representation of 2.Sym(n) .

This function is based on a simplified computation of the **GAP** attribute `BrauerCharacterValue(mat)`

for an invertible matrix `mat`

over a finite field whose characteristic is coprime to the order of `mat`

.

The arguments `ccl` and `ords` are expected to be the values of the attributes `ClassParameters(modtbl)`

and `OrdersClassRepresentatives(modtbl)`

of a (possibly incomplete) p-modular SpinSym table `modtbl`

of 2.Sym(n) .

The argument `rep` is assumed to be a list [t_1^R,t_2^R,...,t_n-1^R] given by the images of the generators t_1,...,t_n-1 of 2.Sym(n) under a (not necessarily faithful) 2.Sym(n) -representation R.

gap> ct:= CharacterTable("DoubleCoverSymmetric",15);; gap> bt:= CharacterTableRegular(ct,5);; gap> fus:= GetFusionMap(bt,ct);; gap> ccl:= ClassParameters(ct){fus};; gap> ords:= OrdersClassRepresentatives(bt);; gap> rep:= BasicSpinRepresentationOfSymmetricGroup(15,5);; gap> phi:= SpinSymBrauerCharacter(ccl,ords,rep);; gap> phi in Irr(ct mod 5); true

`‣ SpinSymBasicCharacter` ( modtbl ) | ( function ) |

Returns: a p-modular basic spin character of the (possibly incomplete) p-modular SpinSym table `modtbl` of 2.Sym(n) .

This is just a shortcut for constructing a basic spin representation of 2.Sym(n) in characteristic p and computing its Brauer character by calling `SpinSymBrauerCharacter`

(2.3-4) afterwards.

gap> SetClassParameters(bt,ccl); gap> SpinSymBasicCharacter(bt) = phi; true

Let k and l be integers greater than 1 and set n=k+l. The following subgroup of 2.Sym(n) ,

2.(Sym(k)×Sym(l)) = < t_1,...,t_k-1, t_k+1,...,t_n-1 >,

is called a (maximal) *Young subgroup* of 2.Sym(n) . Similarly, the intersection 2.(Alt(k)×Alt(l)) of 2.(Sym(k)×Sym(l)) and 2.Alt(n) is a (maximal) Young subgroup of 2.Alt(n) . Note that (2.(Sym(k)×Sym(l)))^π is isomorphic to Sym(k)×Sym(l) and (2.(Alt(k)×Alt(l)))^π is isomorphic to Alt(k)×Alt(l) but only 2.(Alt(k)×Alt(l)) which is isomorphic to (2.Alt(k)×2.Alt(l))/ <(z,z)> is a central product. In between 2.(Alt(k)×Alt(l)) and 2.(Sym(k)×Sym(l)) there are further central products 2.(Sym(k)×Alt(l)) which is isomorphic to (2.Sym(k)×2.Alt(l))/<(z,z)> and 2.(Alt(k)×Sym(l)) which is isomorphic to (2.Alt(k)×2.Sym(l))/<(z,z)> which are π-preimages of Sym(k)×Alt(l) and Alt(k)×Sym(l), respectively. See [Maa11, Section 5.2].

`‣ SpinSymCharacterTableOfMaximalYoungSubgroup` ( k, l, type ) | ( function ) |

Returns: the ordinary character table of a maximal Young subgroup depending on `type`.

For integers `k` and `l` greater than 1 the function returns the ordinary character table of 2.(Alt(k)×Alt(l)), 2.(Alt(k)×Sym(l)), 2.(Sym(k)×Alt(l)), or 2.(Sym(k)×Sym(l)) depending on the string `type` being `"Alternating"`

, `"AlternatingSymmetric"`

, `"SymmetricAlternating"`

, or `"Symmetric"`

, respectively.

If `type` is `"Symmetric"`

then the output is computed by means of Clifford's theory from the character tables of 2.(Sym(k)×Alt(l)), 2.(Alt(k)×Alt(l)), and 2.(Alt(k)×Sym(l)) (see [Maa11, Section 5.2]). These `ingredients' are computed and then stored in the attribute `SpinSymIngredients`

so they can be accessed during the construction (and for the construction of a relative Brauer table too, see `SpinSymBrauerTableOfMaximalYoungSubgroup`

(2.4-2)).

The construction of the character tables of `type` `"Alternating"`

, `"AlternatingSymmetric"`

, or `"SymmetricAlternating"`

is straightforward and may be accomplished by first construcing a direct product, for example, the character table of 2.Sym(k)×2.Alt(l), followed by the construction of the character table of the factor group mod <(z,z)>.

However, we use a faster method that builds up the table from scratch, using the appropriate component tables as ingredients (for example, the generic character tables of 2.Sym(k) and 2.Alt(l) ). In this way we can easily build up a suitable list of class parameters that are needed to determine the class fusion in the construction of `type` `"Symmetric"`

.

gap> 2AA:= SpinSymCharacterTableOfMaximalYoungSubgroup(8,5,"Alternating"); CharacterTable( "2.(Alt(8)xAlt(5))" ) gap> SpinSymCharacterTableOfMaximalYoungSubgroup(8,5,"AlternatingSymmetric"); CharacterTable( "2.(Alt(8)xSym(5))" ) gap> SpinSymCharacterTableOfMaximalYoungSubgroup(8,5,"SymmetricAlternating"); CharacterTable( "2.(Sym(8)xAlt(5))" ) gap> 2SS:= SpinSymCharacterTableOfMaximalYoungSubgroup(8,5,"Symmetric"); CharacterTable( "2.(Sym(8)xSym(5))" )

`‣ SpinSymBrauerTableOfMaximalYoungSubgroup` ( ordtbl, p ) | ( function ) |

Returns: the `p`-modular character table of the ordinary character table `ordtbl` returned by the function `SpinSymCharacterTableOfMaximalYoungSubgroup`

(2.4-1).

If the rational prime `p` is odd, then the construction of the irreducible Brauer characters is really the same as in the ordinary case but it depends on the `p`-modular tables of of `ordtbl`'s `ingredients'. If some Brauer table that is necessary for the construction is not available then `fail`

is returned.

Alternatively, the `mod`

-operator may be used.

For `p` =2 the Brauer table is essentially constructed as a direct product by standard **GAP** methods written by Thomas Breuer.

We call a character table returned by `SpinSymCharacterTableOfMaximalYoungSubgroup`

(2.4-1) or `SpinSymBrauerTableOfMaximalYoungSubgroup`

a SpinSym table too. It has lists of class and character parameters whose format is explained in [Maa11, Sections 5.2, 5.3].

gap> SpinSymBrauerTableOfMaximalYoungSubgroup(2AA,3); BrauerTable( "2.(Alt(8)xAlt(5))", 3 ) gap> 2SS mod 5; BrauerTable( "2.(Sym(8)xSym(5))", 5 ) gap> ct:= 2SS mod 2; BrauerTable( "2.(Sym(8)xSym(5))", 2 ) gap> ct1:= CharacterTable("Sym(8)") mod 2;; gap> ct2:= CharacterTable("Sym(5)") mod 2;; gap> Irr(ct1*ct2) = Irr(ct); true

The following functions determine class fusion maps between SpinSym tables by means of their class parameters. Such `default' class fusion maps allow to induce characters from various subgroups of 2.Sym(n) or 2.Alt(n) consistently.

`‣ SpinSymClassFusion` ( ctSource, ctDest ) | ( function ) |

Returns: a fusion map from the SpinSym table `ctSource` to the SpinSym table `ctDest`. This map is stored if there is no other fusion map from `ctSource` to `ctDest` stored yet.

The possible input tables are expected to be either ordinary or p-modular SpinSym tables of the following pairs of groups

Source | -> | Dest |

2.Alt(n) | 2.Sym(n) | |

2.Sym(k) | 2.Sym(n) | |

2.Alt(k) | 2.Alt(n) | |

2.Sym(n-2) | 2.Alt(n) | |

2.(Sym(k)×Sym(l)) | 2.Sym(k+l) | |

2.(Sym(k)×Alt(l)) | 2.(Sym(k)×Sym(l)) | |

2.(Alt(k)×Sym(l)) | 2.(Sym(k)×Sym(l)) | |

2.(Alt(k)×Alt(l)) | 2.(Sym(k)×Alt(l)) | |

2.(Alt(k)×Alt(l)) | 2.(Alt(k)×Sym(l)) | |

2.(Alt(k)×Alt(l)) | 2.Alt(k+l) |

The appropriate function (see the descriptions below) is called to determine the fusion map `fus`

. If `GetFusionMap(ctSource, ctDest)`

fails, then `fus`

is stored by calling `StoreFusion(ctSource, fus, ctDest)`

.

gap> ctD:= CharacterTable("2.Sym(18)");; gap> ctS:= SpinSymCharacterTableOfMaximalYoungSubgroup(10,8,"Symmetric");; gap> GetFusionMap(ctS,ctD); fail gap> SpinSymClassFusion(ctS,ctD);; #I SpinSymClassFusion: stored fusion map from 2.(Sym(10)xSym(8)) to 2.Sym(18) gap> GetFusionMap(ctS,ctD) <> fail; true

`‣ SpinSymClassFusion2Ain2S` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.Alt(n) and 2.Sym(n).

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.Alt(n) and 2.Sym(n), respectively, a corresponding class fusion map is determined. See [Maa11, (5.4.1)].

`‣ SpinSymClassFusion2Sin2S` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.Sym(k) and 2.Sym(n) for k≤ n.

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.Sym(k) and 2.Sym(n) for k≤ n, respectively, a corresponding class fusion map is determined. See [Maa11, (5.4.2)].

gap> ctD:= CharacterTable("2.Sym(18)");; gap> ctS:= CharacterTable("2.Sym(6)");; gap> cclD:= ClassParameters(ctD);; gap> cclS:= ClassParameters(ctS);; gap> fus:= SpinSymClassFusion2Sin2S(cclS,cclD);; gap> StoreFusion(ctS,fus,ctD);

`‣ SpinSymClassFusion2Ain2A` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.Alt(k) and 2.Alt(n) for k≤ n.

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.Alt(k) and 2.Alt(n) for k≤ n, respectively, a corresponding class fusion map is determined. See [Maa11, (5.4.3)].

`‣ SpinSymClassFusion2Sin2A` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.Sym(n-2) and 2.Alt(n).

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.Sym(n-2) and 2.Alt(n), respectively, a corresponding class fusion map with respect to the embedding of < t_1t_n-2,...,t_n-3t_n-1 > isomorphic to 2.Sym(n-2) in 2.Alt(n) is determined. See [Maa11, (5.4.4)].

`‣ SpinSymClassFusion2SSin2S` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.(Sym(k)×Sym(l)) and 2.Sym(k+l).

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.(Sym(k)×Sym(l)) and 2.Sym(k+l), respectively, a corresponding class fusion map is determined by means of [Maa11, (5.1.6)].

gap> ctD:= CharacterTable("2.Sym(18)");; gap> ctS:= SpinSymCharacterTableOfMaximalYoungSubgroup(10,8,"Symmetric");; gap> cclD:= ClassParameters(ctD);; gap> cclS:= ClassParameters(ctS);; gap> fus:= SpinSymClassFusion2SSin2S(cclS,cclD);; gap> StoreFusion(ctS,fus,ctD);

`‣ SpinSymClassFusion2SAin2SS` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.(Sym(k)×Alt(l)) and 2.(Sym(k)×Sym(l)).

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.(Sym(k)×Alt(l)) and 2.(Sym(k)×Sym(l)), respectively, a corresponding class fusion map is determined. See [Maa11, (5.4.6)].

`‣ SpinSymClassFusion2ASin2SS` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.(Alt(k)×Sym(l)) and 2.(Sym(k)×Sym(l)).

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.(Alt(k)×Sym(l)) and 2.(Sym(k)×Sym(l)), respectively, a corresponding class fusion map is determined analogously to [Maa11, (5.4.6)].

`‣ SpinSymClassFusion2AAin2SA` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.(Sym(k)×Alt(l)).

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.(Sym(k)×Alt(l)), respectively, a corresponding class fusion map is determined. See [Maa11, (5.4.7)].

`‣ SpinSymClassFusion2AAin2AS` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.(Alt(k)×Sym(l)).

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.(Alt(k)×Sym(l)), respectively, a corresponding class fusion map is determined analogously to [Maa11, (5.4.7)].

`‣ SpinSymClassFusion2AAin2A` ( cclSource, cclDest ) | ( function ) |

Returns: a fusion map between the SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.Alt(k+l).

Given lists of class parameters `cclSource` and `cclDest` of (ordinary or p-modular) SpinSym tables of 2.(Alt(k)×Alt(l)) and 2.Alt(k+l), respectively, a corresponding class fusion map is determined. See [Maa11, (5.4.8)].

generated by GAPDoc2HTML