defcolonchar58

This section contains some examples of the use of GAP in character theory. First a few very simple commands for handling character tables are introduced, and afterwards we will construct the character tables of (A_5times 3)!colon!2 and of A_6.2^2.

GAP has a large library of character tables, so let us look at one of these tables, e.g., the table of the Mathieu group M_{11}:

```    gap> m11:= CharTable( "M11" );
CharTable( "M11" ) ```

Character tables contain a lot of information. This is not printed in full length since the internal structure is not easy to read. The next statement shows a more comfortable output format.

```    gap> DisplayCharTable( m11 );
M11

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

1a 2a 3a 4a 5a 6a 8a 8b 11a 11b
2P 1a 1a 3a 2a 5a 3a 4a 4a 11b 11a
3P 1a 2a 1a 4a 5a 2a 8a 8b 11a 11b
5P 1a 2a 3a 4a 1a 6a 8b 8a 11a 11b
11P 1a 2a 3a 4a 5a 6a 8a 8b  1a  1a

X.1      1  1  1  1  1  1  1  1   1   1
X.2     10  2  1  2  . -1  .  .  -1  -1
X.3     10 -2  1  .  .  1  A -A  -1  -1
X.4     10 -2  1  .  .  1 -A  A  -1  -1
X.5     11  3  2 -1  1  . -1 -1   .   .
X.6     16  . -2  .  1  .  .  .   B  /B
X.7     16  . -2  .  1  .  .  .  /B   B
X.8     44  4 -1  . -1  1  .  .   .   .
X.9     45 -3  .  1  .  . -1 -1   1   1
X.10    55 -1  1 -1  . -1  1  1   .   .

A = E(8)+E(8)^3
= ER(-2) = i2
B = E(11)+E(11)^3+E(11)^4+E(11)^5+E(11)^9
= (-1+ER(-11))/2 = b11 ```

We are not too much interested in the internal structure of this character table (see Character Table Records); but of course we can access all information about the centralizer orders (first four lines), element orders (next line), power maps for the prime divisors of the group order (next four lines), irreducible characters (lines parametrized by `X.1` ldots `X.10`) and irrational character values (last four lines), see DisplayCharTable for a detailed description of the format of the displayed table. E.g., the irreducible characters are a list with name `m11.irreducibles`, and each character is a list of cyclotomic integers (see chapter Cyclotomics). There are various ways to describe the irrationalities; e.g., the square root of -2 can be entered as `E(8) + E(8)^3` or `ER(-2)`, the famous ATLAS of Finite Groups~CCN85 denotes it as `i2`.

```    gap> m11.irreducibles[3];
[ 10, -2, 1, 0, 0, 1, E(8)+E(8)^3, -E(8)-E(8)^3, -1, -1 ]```

We can for instance form tensor products of this character with all irreducibles, and compute the decomposition into irreducibles.

```    gap> tens:= Tensored( [ last ], m11.irreducibles );;
gap> MatScalarProducts( m11, m11.irreducibles, tens );
[ [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ],
[ 0, 0, 0, 0, 1, 0, 0, 1, 1, 0 ], [ 1, 0, 0, 0, 0, 0, 0, 1, 0, 1 ],
[ 0, 0, 0, 1, 0, 0, 0, 0, 1, 1 ], [ 0, 0, 0, 0, 0, 0, 1, 1, 1, 1 ],
[ 0, 0, 0, 0, 0, 1, 0, 1, 1, 1 ], [ 0, 0, 1, 1, 0, 1, 1, 2, 3, 3 ],
[ 0, 1, 0, 1, 1, 1, 1, 3, 2, 3 ], [ 0, 1, 1, 0, 1, 1, 1, 3, 3, 4 ] ]```

The decomposition means for example that the third character in the list `tens` is the sum of the irreducible characters at positions 5, 8 and 9.

```    gap> tens[3];
[ 100, 4, 1, 0, 0, 1, -2, -2, 1, 1 ]
gap> tens[3] = Sum( Sublist( m11.irreducibles, [ 5, 8, 9 ] ) );
true```

Or we can compute symmetrizations, e.g., the characters chi^{2+}, defined by chi^{2+}(g) = frac{1}{2} ( chi^2(g) + chi(g^2) ), for all irreducibles.

```    gap> sym:= SymmetricParts( m11, m11.irreducibles, 2 );;
gap> MatScalarProducts( m11, m11.irreducibles, sym );
[ [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 0, 0, 0, 0, 0, 1, 0, 0 ],
[ 0, 0, 0, 0, 1, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 0, 1, 0, 0, 1, 0, 0 ],
[ 1, 1, 0, 0, 1, 0, 0, 1, 0, 0 ], [ 0, 1, 0, 0, 1, 0, 1, 1, 0, 1 ],
[ 0, 1, 0, 0, 1, 1, 0, 1, 0, 1 ], [ 1, 3, 0, 0, 3, 2, 2, 8, 4, 6 ],
[ 1, 2, 0, 0, 3, 2, 2, 8, 4, 7 ],
[ 1, 3, 1, 1, 4, 3, 3, 11, 7, 10 ] ]
gap> sym[2];
[ 55, 7, 1, 3, 0, 1, 1, 1, 0, 0 ]
gap> sym[2] = Sum( Sublist( m11.irreducibles, [ 1, 2, 8 ] ) );
true```

If the subgroup fusion into a supergroup is known, characters can be induced to this group, e.g., to obtain the permutation character of the action of M_{12} on the cosets of M_{11}.

```    gap> m12:= CharTable( "M12" );;
gap> permchar:= Induced( m11, m12, [ m11.irreducibles[1] ] );
[ [ 12, 0, 4, 3, 0, 0, 4, 2, 0, 1, 0, 2, 0, 1, 1 ] ]
gap> MatScalarProducts( m12, m12.irreducibles, last );
[ [ 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]
gap> DisplayCharTable( m12, rec( chars:= permchar ) );
M12

2  6  4  6  1  2  5  5  1  2  1  3  3   1   .   .
3  3  1  1  3  2  .  .  .  1  1  .  .   .   .   .
5  1  1  .  .  .  .  .  1  .  .  .  .   1   .   .
11  1  .  .  .  .  .  .  .  .  .  .  .   .   1   1

1a 2a 2b 3a 3b 4a 4b 5a 6a 6b 8a 8b 10a 11a 11b
2P 1a 1a 1a 3a 3b 2b 2b 5a 3b 3a 4a 4b  5a 11b 11a
3P 1a 2a 2b 1a 1a 4a 4b 5a 2a 2b 8a 8b 10a 11a 11b
5P 1a 2a 2b 3a 3b 4a 4b 1a 6a 6b 8a 8b  2a 11a 11b
11P 1a 2a 2b 3a 3b 4a 4b 5a 6a 6b 8a 8b 10a  1a  1a

Y.1    12  .  4  3  .  .  4  2  .  1  .  2   .   1   1```

It should be emphasized that the heart of character theory is dealing with lists. Characters are lists, and also the maps which occur are represented as lists. Note that the multiplication of group elements is not available, so we neither have homomorphisms. All we can talk of are class functions, and the lists are regarded as such functions, being the lists of images with respect to a fixed order of conjugacy classes. Therefore we do not write `chi( cl )` or `cl^chi` for the value of the character `chi` on the class `cl`, but `chi[i]` where `i` is the position of the class `cl`.

Since the data structures are so basic, most calculations involve compositions of maps; for example, the embedding of a subgroup in a group is described by the so--called subgroup fusion which is a class function that maps each class c of the subgroup to that class of the group that contains c. Consider the symmetric group S_5 cong A_5.2 as subgroup of M_{11}. (Do not worry about the names that are used to get library tables, see CharTable for an overview.)

```    gap> s5:= CharTable( "A5.2" );;
gap> map:= GetFusionMap( s5, m11 );
[ 1, 2, 3, 5, 2, 4, 6 ]```

The subgroup fusion is already stored on the table. We see that class 1 of `s5` is mapped to class 1 of `m11` (which means that the identity of S_5 maps to the identity of M_{11}), classes 2 and 5 of `s5` both map to class 2 of `m11` (which means that all involutions of S_5 are conjugate in M_{11}), and so on.

The restriction of a character of `m11` to `s5` is just the composition of this character with the subgroup fusion map. Viewing this map as list one would call this composition an indirection.

```    gap> chi:= m11.irreducibles[3];
[ 10, -2, 1, 0, 0, 1, E(8)+E(8)^3, -E(8)-E(8)^3, -1, -1 ]
gap> rest:= List( map, x -> chi[x] );
[ 10, -2, 1, 0, -2, 0, 1 ]```

This looks very easy, and many GAP functions in character theory do such simple calculations. But note that it is not always obvious that a list is regarded as a map, where preimages and/or images refer to positions of certain conjugacy classes.

```    gap> alt:= s5.irreducibles[2];
[ 1, 1, 1, 1, -1, -1, -1 ]
gap> kernel:= KernelChar( last );
[ 1, 2, 3, 4 ]```

The kernel of a character is represented as the list of (positions of) classes lying in the kernel. We know that the kernel of the alternating character `alt` of `s5` is the alternating group A_5. The order of the kernel can be computed as sum of the lengths of the contained classes from the character table, using that the classlengths are stored in the `classes` component of the table.

```    gap> s5.classes;
[ 1, 15, 20, 24, 10, 30, 20 ]
gap> last{ kernel };
[ 1, 15, 20, 24 ]
gap> Sum( last );
60```

We chose those classlengths of `s5` that belong to the S_5--classes contained in the alternating group. The same thing is done in the following command, reflecting the view of the kernel as map.

```    gap> List( kernel, x -> s5.classes[x] );
[ 1, 15, 20, 24 ]
gap> Sum( kernel, x -> s5.classes[x] );
60```

This small example shows how the functions `List` and `Sum` can be used. About Further List Operations, and we will make heavy use of them; in many cases such a command might look very strange, but it is just the translation of a (hardly less complicated) mathematical formula to character theory.

And now let us construct some small character tables!

setlengthunitlength0.1cm The group G = (A_5times 3)!colon!2 is a maximal subgroup of the alternating group A_8; G extends to S_5times S_3 in S_8. We want to construct the character table of G.

First the tables of the subgroup A_5times 3 and the supergroup S_5times S_3 are constructed; the tables of the factors of each direct product are again got from the table library using admissible names, see CharTable for this. put(10,-37)beginpicture(50,45) put(25,5)circle1 put(15,15)circle1 put(25,25)circle1 put(25,30)circle1 put(25,35)circle1 put(35,15)circle1 put(10,20)circle1 put(40,20)circle1 put(20,30)circle1 put(30,30)circle1 put(7,20)makebox(0,0)S_5 put(12,15)makebox(0,0)A_5 put(43,20)makebox(0,0)S_3 put(38,15)makebox(0,0)3 put(27,30)makebox(0,0)G put(25,37)makebox(0,0)S_5times S_3 put(14,30)makebox(0,0)S_5times 3 put(38,30)makebox(0,0)A_5times S_3 put(25,5)line(-1,1)15 put(25,5)line(1,1)15 put(35,15)line(-1,1)15 put(15,15)line(1,1)15 put(40,20)line(-1,1)15 put(10,20)line(1,1)15 put(25,25)line(0,1)10

```    gap> a5:= CharTable( "A5" );;
gap> c3:= CharTable( "Cyclic", 3 );;
gap> a5xc3:= CharTableDirectProduct( a5, c3 );;
gap> s5:= CharTable( "A5.2" );;
gap> s3:= CharTable( "Symmetric", 3 );;
gap> s3.irreducibles;
[ [ 1, -1, 1 ], [ 2, 0, -1 ], [ 1, 1, 1 ] ]
# The trivial character shall be the first one.
gap> SortCharactersCharTable( s3 );  # returns the applied permutation
(1,2,3)
gap> s5xs3:= CharTableDirectProduct( s5, s3 );;```

G is the normal subgroup of index 2 in S_5times S_3 which contains neither S_5 nor the normal S_3. We want to find the classes of `s5xs3` whose union is G. For that, we compute the set of kernels of irreducibles --remember that they are given simply by lists of numbers of contained classes-- and then choose those kernels belonging to normal subgroups of index 2.

```    gap> kernels:= Set( List( s5xs3.irreducibles, KernelChar ) );
[ [ 1 ], [ 1, 2, 3 ], [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ],
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21 ], [ 1, 3 ],
[ 1, 3, 4, 6, 7, 9, 10, 12, 13, 15, 16, 18, 19, 21 ],
[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ], [ 1, 4, 7, 10 ],
[ 1, 4, 7, 10, 13, 16, 19 ] ]
gap> sizes:= List( kernels, x -> Sum( Sublist( s5xs3.classes, x ) ) );
[ 1, 6, 360, 720, 3, 360, 360, 60, 120 ]
gap> s5xs3.size;
720
gap> index2:= Sublist( kernels, [ 3, 6, 7 ] );
[ [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ],
[ 1, 3, 4, 6, 7, 9, 10, 12, 13, 15, 16, 18, 19, 21 ],
[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ] ]```

In order to decide which kernel describes G, we consider the embeddings of `s5` and `s3` in `s5xs3`, given by the subgroup fusions.

```    gap> s5ins5xs3:= GetFusionMap( s5, s5xs3 );
[ 1, 4, 7, 10, 13, 16, 19 ]
gap> s3ins5xs3:= GetFusionMap( s3, s5xs3 );
[ 1, 2, 3 ]
gap> Filtered( index2, x->Intersection(x,s5ins5xs3)<>s5ins5xs3 and
>                         Intersection(x,s3ins5xs3)<>s3ins5xs3     );
[ [ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ] ]
gap> nsg:= last[1];
[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ]```

We now construct a first approximation of the character table of this normal subgroup, namely the restriction of `s5xs3` to the classes given by `nsg`.

```    gap> sub:= CharTableNormalSubgroup( s5xs3, nsg );;
#I CharTableNormalSubgroup: classes in [ 8 ] necessarily split
gap> PrintCharTable( sub );
rec( identifier := "Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 2\
0 ])", size :=
360, name := "Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ])",\
order := 360, centralizers := [ 360, 180, 24, 12, 18, 9, 15, 15/2,
12, 4, 6 ], orders := [ 1, 3, 2, 6, 3, 3, 5, 15, 2, 4, 6
], powermap := [ , [ 1, 2, 1, 2, 5, 6, 7, 8, 1, 3, 5 ],
[ 1, 1, 3, 3, 1, 1, 7, 7, 9, 10, 9 ],,
[ 1, 2, 3, 4, 5, 6, 1, 2, 9, 10, 11 ] ], classes :=
[ 1, 2, 15, 30, 20, 40, 24, 48, 30, 90, 60
], operations := CharTableOps, irreducibles :=
[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1 ],
[ 2, -1, 2, -1, 2, -1, 2, -1, 0, 0, 0 ],
[ 6, 6, -2, -2, 0, 0, 1, 1, 0, 0, 0 ],
[ 4, 4, 0, 0, 1, 1, -1, -1, 2, 0, -1 ],
[ 4, 4, 0, 0, 1, 1, -1, -1, -2, 0, 1 ],
[ 8, -4, 0, 0, 2, -1, -2, 1, 0, 0, 0 ],
[ 5, 5, 1, 1, -1, -1, 0, 0, 1, -1, 1 ],
[ 5, 5, 1, 1, -1, -1, 0, 0, -1, 1, -1 ],
[ 10, -5, 2, -1, -2, 1, 0, 0, 0, 0, 0 ] ], fusions := [ rec(
name := [ 'A', '5', '.', '2', 'x', 'S', '3' ],
map := [ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ] ) ] )```

Not all restrictions of irreducible characters of `s5xs3` to `sub` remain irreducible. We compute those restrictions with norm larger than 1.

```    gap> red:= Filtered( Restricted( s5xs3, sub, s5xs3.irreducibles ),
>                    x -> ScalarProduct( sub, x, x ) > 1 );
[ [ 12, -6, -4, 2, 0, 0, 2, -1, 0, 0, 0 ] ]
gap> Filtered( [ 1 .. Length( nsg ) ],
>              x -> not IsInt( sub.centralizers[x] ) );
[ 8 ]```

Note that `sub` is not actually a character table in the sense of mathematics but only a record with components like a character table. GAP does not know about this subtleties and treats it as a character table.

As the list `centralizers` of centralizer orders shows, at least class 8 splits into two conjugacy classes in G, since this is the only possibility to achieve integral centralizer orders.

Since 10 restrictions of irreducible characters remain irreducible for G (`sub` contains 10 irreducibles), only one of the 11 irreducibles of S_5times S_3 splits into two irreducibles of G, in other words, class 8 is the only splitting class.

Thus we create a new approximation of the desired character table (which we call `split`) where this class is split; 8th and 9th column of the known irreducibles are of course equal, and due to the splitting the second powermap for these columns is ambiguous.

```    gap> splitting:= [ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ];;
gap> split:= CharTableSplitClasses( sub, splitting );;
gap> PrintCharTable( split );
rec( identifier := "Split(Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14,\
17, 20 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ])", size :=
360, order :=
360, name := "Split(Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 2\
0 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ])", centralizers :=
[ 360, 180, 24, 12, 18, 9, 15, 15, 15, 12, 4, 6 ], classes :=
[ 1, 2, 15, 30, 20, 40, 24, 24, 24, 30, 90, 60 ], orders :=
[ 1, 3, 2, 6, 3, 3, 5, 15, 15, 2, 4, 6 ], powermap :=
[ , [ 1, 2, 1, 2, 5, 6, 7, [ 8, 9 ], [ 8, 9 ], 1, 3, 5 ],
[ 1, 1, 3, 3, 1, 1, 7, 7, 7, 10, 11, 10 ],,
[ 1, 2, 3, 4, 5, 6, 1, 2, 2, 10, 11, 12 ] ], irreducibles :=
[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1 ],
[ 2, -1, 2, -1, 2, -1, 2, -1, -1, 0, 0, 0 ],
[ 6, 6, -2, -2, 0, 0, 1, 1, 1, 0, 0, 0 ],
[ 4, 4, 0, 0, 1, 1, -1, -1, -1, 2, 0, -1 ],
[ 4, 4, 0, 0, 1, 1, -1, -1, -1, -2, 0, 1 ],
[ 8, -4, 0, 0, 2, -1, -2, 1, 1, 0, 0, 0 ],
[ 5, 5, 1, 1, -1, -1, 0, 0, 0, 1, -1, 1 ],
[ 5, 5, 1, 1, -1, -1, 0, 0, 0, -1, 1, -1 ],
[ 10, -5, 2, -1, -2, 1, 0, 0, 0, 0, 0, 0 ] ], fusions := [ rec(
name := "Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ])"
,
map := [ 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 10, 11 ] )
], operations := CharTableOps )
gap> Restricted( sub, split, red );
[ [ 12, -6, -4, 2, 0, 0, 2, -1, -1, 0, 0, 0 ] ]```

To complete the table means to find the missing two irreducibles and to complete the powermaps. For this, there are different possibilities. First, one can try to embed G in A_8.

```    gap> a8:= CharTable( "A8" );;
gap> fus:= SubgroupFusions( split, a8 );
[ [ 1, 4, 3, 9, 4, 5, 8, 13, 14, 3, 7, 9 ],
[ 1, 4, 3, 9, 4, 5, 8, 14, 13, 3, 7, 9 ] ]
gap> fus:= RepresentativesFusions( split, fus, a8 );
#I RepresentativesFusions: no subtable automorphisms stored
[ [ 1, 4, 3, 9, 4, 5, 8, 13, 14, 3, 7, 9 ] ]
gap> StoreFusion( split, a8, fus[1] );```

The subgroup fusion is unique up to table automorphisms. Now we restrict the irreducibles of A_8 to G and reduce.

```    gap> rest:= Restricted( a8, split, a8.irreducibles );;
gap> red:= Reduced( split, split.irreducibles, rest );
rec(
remainders := [  ],
irreducibles :=
[ [ 6, -3, -2, 1, 0, 0, 1, -E(15)-E(15)^2-E(15)^4-E(15)^8,
-E(15)^7-E(15)^11-E(15)^13-E(15)^14, 0, 0, 0 ],
[ 6, -3, -2, 1, 0, 0, 1, -E(15)^7-E(15)^11-E(15)^13-E(15)^14,
-E(15)-E(15)^2-E(15)^4-E(15)^8, 0, 0, 0 ] ] )
gap> Append( split.irreducibles, red.irreducibles );```

The list of irreducibles is now complete, but the powermaps are not yet adjusted. To complete the 2nd powermap, we transfer that of A_8 to G using the subgroup fusion.

```    gap> split.powermap;
[ , [ 1, 2, 1, 2, 5, 6, 7, [ 8, 9 ], [ 8, 9 ], 1, 3, 5 ],
[ 1, 1, 3, 3, 1, 1, 7, 7, 7, 10, 11, 10 ],,
[ 1, 2, 3, 4, 5, 6, 1, 2, 2, 10, 11, 12 ] ]
gap> TransferDiagram( split.powermap[2], fus[1], a8.powermap[2] );;```

And this is the complete table.

```    gap> split.identifier:= "(A5x3):2";;
gap> DisplayCharTable( split );
Split(Rest(A5.2xS3,[ 1, 3, 4, 6, 7, 9, 10, 12, 14, 17, 20 ]),[ 1, 2, 3\
, 4, 5, 6, 7, 8, 8, 9, 10, 11 ])

2  3  2  3  2  1  .  .   .   .  2  2  1
3  2  2  1  1  2  2  1   1   1  1  .  1
5  1  1  .  .  .  .  1   1   1  .  .  .

1a 3a 2a 6a 3b 3c 5a 15a 15b 2b 4a 6b
2P 1a 3a 1a 3a 3b 3c 5a 15a 15b 1a 2a 3b
3P 1a 1a 2a 2a 1a 1a 5a  5a  5a 2b 4a 2b
5P 1a 3a 2a 6a 3b 3c 1a  3a  3a 2b 4a 6b

X.1      1  1  1  1  1  1  1   1   1  1  1  1
X.2      1  1  1  1  1  1  1   1   1 -1 -1 -1
X.3      2 -1  2 -1  2 -1  2  -1  -1  .  .  .
X.4      6  6 -2 -2  .  .  1   1   1  .  .  .
X.5      4  4  .  .  1  1 -1  -1  -1  2  . -1
X.6      4  4  .  .  1  1 -1  -1  -1 -2  .  1
X.7      8 -4  .  .  2 -1 -2   1   1  .  .  .
X.8      5  5  1  1 -1 -1  .   .   .  1 -1  1
X.9      5  5  1  1 -1 -1  .   .   . -1  1 -1
X.10    10 -5  2 -1 -2  1  .   .   .  .  .  .
X.11     6 -3 -2  1  .  .  1   A  /A  .  .  .
X.12     6 -3 -2  1  .  .  1  /A   A  .  .  .

A = -E(15)-E(15)^2-E(15)^4-E(15)^8
= (-1-ER(-15))/2 = -1-b15```

There are many ways around the block, so two further methods to complete the table `split` shall be demonstrated; but we will not go into details.

Without use of GAP one could work as follows:

The irrationalities --and there must be irrational entries in the character table of G, since the outer 2 can conjugate at most two of the four Galois conjugate classes of elements of order 15-- could also have been found from the structure of G and the restriction of the irreducible S_5times S_3 character of degree 12.

On the classes that did not split the values of this character must just be divided by 2. Let x be one of the irrationalities. The second orthogonality relation tells us that xcdotoverline{x} = 4 (at class `15a`) and x + xast = -1 (at classes `1a` and `15a`); here xast denotes the nontrivial Galois conjugate of x. This has no solution for x = overline{x}, otherwise it leads to the quadratic equation x^2+x+4 = 0 with solutions b15 = frac{1}{2}(-1+sqrt{-15}) and -1-b15.

The third possibility to complete the table is to embed A_5times 3:

```    gap> split.irreducibles := split.irreducibles{ [ 1 .. 10 ] };;
gap> SubgroupFusions( a5xc3, split );
[ [ 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, [ 8, 9 ], [ 8, 9 ], 7, [ 8, 9 ],
[ 8, 9 ] ] ]```

The images of the four classes of element order 15 are not determined, the returned list parametrizes the 2^4 possibilities.

```    gap> fus:= ContainedMaps( last[1] );;
gap> Length( fus );
16
gap> fus[1];
[ 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 7, 8, 8 ]```

Most of these 16 possibilities are excluded using scalar products of induced characters. We take a suitable character `chi` of `a5xc3` and compute the norm of the induced character with respect to each possible map.

```    gap> chi:= a5xc3.irreducibles[5];
[ 3, 3*E(3), 3*E(3)^2, -1, -E(3), -E(3)^2, 0, 0, 0, -E(5)-E(5)^4,
-E(15)^2-E(15)^8, -E(15)^7-E(15)^13, -E(5)^2-E(5)^3,
-E(15)^11-E(15)^14, -E(15)-E(15)^4 ]
gap> List( fus, x -> List( Induced( a5xc3, split, [ chi ], x ),
>                          y -> ScalarProduct( split, y, y ) )[1] );
[ 8/15, -2/3*E(5)-11/15*E(5)^2-11/15*E(5)^3-2/3*E(5)^4,
-2/3*E(5)-11/15*E(5)^2-11/15*E(5)^3-2/3*E(5)^4, 2/3,
-11/15*E(5)-2/3*E(5)^2-2/3*E(5)^3-11/15*E(5)^4, 3/5, 1,
-11/15*E(5)-2/3*E(5)^2-2/3*E(5)^3-11/15*E(5)^4,
-11/15*E(5)-2/3*E(5)^2-2/3*E(5)^3-11/15*E(5)^4, 1, 3/5,
-11/15*E(5)-2/3*E(5)^2-2/3*E(5)^3-11/15*E(5)^4, 2/3,
-2/3*E(5)-11/15*E(5)^2-11/15*E(5)^3-2/3*E(5)^4,
-2/3*E(5)-11/15*E(5)^2-11/15*E(5)^3-2/3*E(5)^4, 8/15 ]
gap> Filtered( [ 1 .. Length( fus ) ], x -> IsInt( last[x] ) );
[ 7, 10 ]```

So only fusions 7 and 10 may be possible. They are equivalent (with respect to table automorphisms), and the list of induced characters contains the missing irreducibles of G:

```    gap> Sublist( fus, last );
[ [ 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 9, 7, 9, 8 ],
[ 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 9, 8, 7, 8, 9 ] ]
gap> ind:= Induced( a5xc3, split, a5xc3.irreducibles, last[1] );;
gap> Reduced( split, split.irreducibles, ind );
rec(
remainders := [  ],
irreducibles :=
[ [ 6, -3, -2, 1, 0, 0, 1, -E(15)-E(15)^2-E(15)^4-E(15)^8,
-E(15)^7-E(15)^11-E(15)^13-E(15)^14, 0, 0, 0 ],
[ 6, -3, -2, 1, 0, 0, 1, -E(15)^7-E(15)^11-E(15)^13-E(15)^14,
-E(15)-E(15)^2-E(15)^4-E(15)^8, 0, 0, 0 ] ] )```

The following example is thought mainly for experts. It shall demonstrate how one can work together with GAP and the ATLAS~CCN85, so better leave out the rest of this section if you are not familiar with the ATLAS.

setlengthunitlength0.1cm We shall construct the character table of the group G = A_6.2^2 cong Aut( A_6 ) from the tables of the normal subgroups A_6.2_1 cong S_6, A_6.2_2 cong PGL(2,9) and A_6.2_3 cong M_{10}.

We regard G as a downward extension of the Klein fourgroup 2^2 with A_6. The set of classes of all preimages of cyclic subgroups of 2^2 covers the classes of G, but it may happen that some representatives are conjugate in G, i.e., the classes fuse.

The ATLAS denotes the character tables of G, G.2_1, G.2_2 and G.2_3 as follows: put(5,-40)beginpicture(50,45) put(25,5)circle1 put(25,20)makebox(0,0)A_6 put(25,30)makebox(0,0)A_6.2_3 put(15,30)makebox(0,0)A_6.2_1 put(35,30)makebox(0,0)A_6.2_2 put(25,40)makebox(0,0)G put(25,5)line(0,1)12 put(23,22)line(-1,1)6 put(27,22)line(1,1)6 put(25,22)line(0,1)6 put(23,38)line(-1,-1)6 put(27,38)line(1,-1)6 put(25,38)line(0,-1)6

vbox

```     ;   @   @   @   @   @   @   @   ;   ;   @   @   @   @   @

360   8   9   9   4   5   5          24  24   4   3   3
p power   A   A   A   A   A   A           A   A   A  AB  BC
p```
mboxttchar13
``` part   A   A   A   A   A   A           A   A   A  AB  BC
ind  1A  2A  3A  3B  4A  5A  B* fus ind  2B  2C  4B  6A  6B

```
chi_1
```   +   1   1   1   1   1   1   1   :  ++   1   1   1   1   1

```
chi_2
```   +   5   1   2  -1  -1   0   0   :  ++   3  -1   1   0  -1

```
chi_3
```   +   5   1  -1   2  -1   0   0   :  ++  -1   3   1  -1   0

```
chi_4
```   +   8   0  -1  -1   0 -b5   *   .   +   0   0   0   0   0

```
chi_5
```   +   8   0  -1  -1   0   * -b5   .

```
chi_6
```   +   9   1   0   0   1  -1  -1   :  ++   3   3  -1   0   0

```
chi_7` + 10 -2 1 1 0 0 0 : ++ 2 -2 0 -1 1`

vbox put(6.5,-52)line(0,1)8.5 put(56.25,-69)line(0,1)9 put(56.25,-52)line(0,1)8.5

```   ;   ;  @   @   @   @   @   ;   ;  @   @   @

10   4   4   5   5          2   4   4
A   A   A  BD  AD          A   A   A
A   A   A  AD  BD          A   A   A
fus ind 2D  8A  B* 10A  B* fus ind 4C  8C D**

:  ++  1   1   1   1   1   :  ++  1   1   1   ```
chi_1
```
.   +  0   0   0   0   0   .   +  0   0   0   ```
chi_2
```
.                          .                  ```
chi_3
```
:  ++  2   0   0  b5   *   .   +  0   0   0   ```
chi_4
```
:  ++  2   0   0   *  b5   .                  ```
chi_5
```
:  ++ -1   1   1  -1  -1   :  ++  1  -1  -1   ```
chi_6
```
:  ++  0  r2 -r2   0   0   :  oo  0  i2 -i2   ```
chi_7

First we construct a table whose classes are those of the three subgroups. Note that the exponent of A_6 is 60, so the representative orders could become at most 60 times the value in 2^2.

```    gap> s1:= CharTable( "A6.2_1" );;
gap> s2:= CharTable( "A6.2_2" );;
gap> s3:= CharTable( "A6.2_3" );;
gap> c2:= CharTable( "Cyclic", 2 );;
gap> v4:= CharTableDirectProduct( c2, c2 );;
#I CharTableDirectProduct: existing subgroup fusion on <tbl2> replaced
#I    by actual one
gap> for tbl in [ s1, s2, s3 ] do
>      Print( tbl.irreducibles[2], "\n" );
>    od;
[ 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 ]
[ 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 ]
[ 1, 1, 1, 1, 1, -1, -1, -1 ]
gap> split:= CharTableSplitClasses( v4,
>              [1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4], 60 );;
gap> PrintCharTable( split );
rec( identifier := "Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, \
3, 3, 3, 4, 4, 4 ])", size := 4, order :=
4, name := "Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,\
4, 4, 4 ])", centralizers := [ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4 ], classes := [ 1/5, 1/5, 1/5, 1/5, 1/5, 1/5, 1/5,
1/5, 1/5, 1/5, 1/5, 1/5, 1/5, 1/5, 1/5, 1/3, 1/3, 1/3 ], orders :=
[ 1, [ 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60 ],
[ 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60 ],
[ 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60 ],
[ 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ],
[ 2, 4, 6, 8, 10, 12, 20, 24, 30, 40, 60, 120 ] ], powermap :=
[ , [ 1, [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ],
[ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ],
[ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ],
[ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ],
[ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ],
[ 1, 2, 3, 4, 5 ], [ 1, 2, 3, 4, 5 ] ] ], irreducibles :=
[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1 ],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1 ],
[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1 ]
], fusions := [ rec(
name := [ 'C', '2', 'x', 'C', '2' ],
map := [ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 ]
) ], operations := CharTableOps )```

Now we embed the subgroups and adjust the classlengths, order, centralizers, powermaps and thus the representative orders.

```    gap> StoreFusion( s1, split, [1,2,3,3,4,5,6,7,8,9,10]);
gap> StoreFusion( s2, split, [1,2,3,4,5,5,11,12,13,14,15]);
gap> StoreFusion( s3, split, [1,2,3,4,5,16,17,18]);
gap> for tbl in [ s1, s2, s3 ] do
>      fus:= GetFusionMap( tbl, split );
>      for class in Difference( [ 1 .. Length( tbl.classes ) ],
>                               KernelChar(tbl.irreducibles[2]) ) do
>        split.classes[ fus[ class ] ]:= tbl.classes[ class ];
>      od;
>    od;
gap> for class in [ 1 .. 5 ] do
>      split.classes[ class ]:= s3.classes[ class ];
>    od;
gap> split.classes;
[ 1, 45, 80, 90, 144, 15, 15, 90, 120, 120, 36, 90, 90, 72, 72, 180,
90, 90 ]
gap> split.size:= Sum( last );
1440
gap> split.order:= last;
gap> split.centralizers:= List( split.classes, x -> split.order / x );
[ 1440, 32, 18, 16, 10, 96, 96, 16, 12, 12, 40, 16, 16, 20, 20, 8,
16, 16 ]
gap> split.powermap[3]:= InitPowermap( split, 3 );;
gap> split.powermap[5]:= InitPowermap( split, 5 );;
gap> for tbl in [ s1, s2, s3 ] do
>      fus:= GetFusionMap( tbl, split );
>      for p in [ 2, 3, 5 ] do
>        TransferDiagram( tbl.powermap[p], fus, split.powermap[p] );
>      od;
>    od;
gap> split.powermap;
[ , [ 1, 1, 3, 2, 5, 1, 1, 2, 3, 3, 1, 4, 4, 5, 5, 2, 4, 4 ],
[ 1, 2, 1, 4, 5, 6, 7, 8, 6, 7, 11, 13, 12, 15, 14, 16, 17, 18 ],,
[ 1, 2, 3, 4, 1, 6, 7, 8, 9, 10, 11, 13, 12, 11, 11, 16, 18, 17 ] ]
gap> split.orders:= ElementOrdersPowermap( split.powermap );
[ 1, 2, 3, 4, 5, 2, 2, 4, 6, 6, 2, 8, 8, 10, 10, 4, 8, 8 ]```

In order to decide which classes fuse in G, we look at the norms of suitable induced characters, first the + extension of chi_2 to A_6.2_1.

```    gap> ind:= Induced( s1, split, [ s1.irreducibles[3] ] )[1];
[ 10, 2, 1, -2, 0, 6, -2, 2, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0 ]
gap> ScalarProduct( split, ind, ind );
3/2```

The inertia group of this character is A_6.2_1, thus the norm of the induced character must be 1. If the classes `2B` and `2C` fuse, the contribution of these classes is changed from 15cdot 6^2+15cdot(-2)^2 to 30 cdot 2^2, the difference is 480. But we have to subtract 720 which is half the group order, so also `6A` and `6B` fuse. This is not surprising, since it reflects the action of the famous outer automorphism of S_6. Next we examine the + extension of chi_4 to A_6.2_2.

```    gap> ind:= Induced( s2, split, [ s2.irreducibles[4] ] )[1];
[ 16, 0, -2, 0, 1, 0, 0, 0, 0, 0, 4, 0, 0, 2*E(5)+2*E(5)^4,
2*E(5)^2+2*E(5)^3, 0, 0, 0 ]
gap> ScalarProduct( split, ind, ind );
3/2```

Again, the norm must be 1, `10A` and `10B` fuse.

```    gap> collaps:= CharTableCollapsedClasses( split,
>                    [1,2,3,4,5,6,6,7,8,8,9,10,11,12,12,13,14,15] );;
gap> PrintCharTable( collaps );
rec( identifier := "Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2,\
2, 3, 3, 3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 1\
1, 12, 12, 13, 14, 15 ])", size := 1440, order :=
1440, name := "Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3\
, 3, 3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12\
, 12, 13, 14, 15 ])", centralizers := [ 1440, 32, 18, 16, 10, 48, 16,
6, 40, 16, 16, 10, 8, 16, 16 ], orders :=
[ 1, 2, 3, 4, 5, 2, 4, 6, 2, 8, 8, 10, 4, 8, 8 ], powermap :=
[ , [ 1, 1, 3, 2, 5, 1, 2, 3, 1, 4, 4, 5, 2, 4, 4 ],
[ 1, 2, 1, 4, 5, 6, 7, 6, 9, 11, 10, 12, 13, 14, 15 ],,
[ 1, 2, 3, 4, 1, 6, 7, 8, 9, 11, 10, 9, 13, 15, 14 ]
], fusionsource :=
[ "Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 \
])" ], irreducibles :=
[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[ 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1 ],
[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1 ],
[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1 ]
], classes := [ 1, 45, 80, 90, 144, 30, 90, 240, 36, 90, 90, 144,
180, 90, 90 ], operations := CharTableOps )
gap> split.fusions;
[ rec(
name := [ 'C', '2', 'x', 'C', '2' ],
map := [ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 ]
), rec(
name :=
"Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3,\
3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 12, 1\
3, 14, 15 ])",
map := [ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 12, 13,
14, 15 ] ) ]
gap> for tbl in [ s1, s2, s3 ] do
>      StoreFusion( tbl, collaps,
>                   CompositionMaps( GetFusionMap( split, collaps ),
>                                    GetFusionMap( tbl, split ) ) );
>    od;
gap> ind:= Induced( s1, collaps, [ s1.irreducibles[10] ] )[1];
[ 20, -4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
gap> ScalarProduct( collaps, ind, ind );
1```

This character must be equal to any induced character of an irreducible character of degree 10 of A_6.2_2 and A_6.2_3. That means, `8A` fuses with `8B`, and `8C` with `8D`.

```    gap> a6v4:= CharTableCollapsedClasses( collaps,
>     [1,2,3,4,5,6,7,8,9,10,10,11,12,13,13] );;
gap> PrintCharTable( a6v4 );
rec( identifier := "Collapsed(Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2\
, 2, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8\
, 9, 10, 11, 12, 12, 13, 14, 15 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10\
, 11, 12, 13, 13 ])", size := 1440, order :=
1440, name := "Collapsed(Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, \
2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, \
10, 11, 12, 12, 13, 14, 15 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 11,\
12, 13, 13 ])", centralizers := [ 1440, 32, 18, 16, 10, 48, 16, 6,
40, 8, 10, 8, 8 ], orders := [ 1, 2, 3, 4, 5, 2, 4, 6, 2, 8, 10, 4,
8 ], powermap := [ , [ 1, 1, 3, 2, 5, 1, 2, 3, 1, 4, 5, 2, 4 ],
[ 1, 2, 1, 4, 5, 6, 7, 6, 9, 10, 11, 12, 13 ],,
[ 1, 2, 3, 4, 1, 6, 7, 8, 9, 10, 9, 12, 13 ] ], fusionsource :=
[ "Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3\
, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 12, 13, 14\
, 15 ])" ], irreducibles :=
[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[ 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1 ],
[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 ],
[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1 ] ], classes :=
[ 1, 45, 80, 90, 144, 30, 90, 240, 36, 180, 144, 180, 180
], operations := CharTableOps )
gap> for tbl in [ s1, s2, s3 ] do
>      StoreFusion( tbl, a6v4,
>                   CompositionMaps( GetFusionMap( collaps, a6v4 ),
>                                    GetFusionMap( tbl, collaps ) ) );
>    od;```

Now the classes of G are known, the only remaining work is to compute the irreducibles.

```    gap> a6v4.irreducibles;
[ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[ 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1 ],
[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 ],
[ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1 ] ]
gap> for tbl in [ s1, s2, s3 ] do
>      ind:= Set( Induced( tbl, a6v4, tbl.irreducibles ) );
>      Append( a6v4.irreducibles,
>              Filtered( ind, x -> ScalarProduct( a6v4,x,x ) = 1 ) );
>    od;
gap> a6v4.irreducibles:= Set( a6v4.irreducibles );
[ [ 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1 ],
[ 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, -1 ],
[ 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1 ],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[ 10, 2, 1, -2, 0, -2, -2, 1, 0, 0, 0, 0, 0 ],
[ 10, 2, 1, -2, 0, 2, 2, -1, 0, 0, 0, 0, 0 ],
[ 16, 0, -2, 0, 1, 0, 0, 0, -4, 0, 1, 0, 0 ],
[ 16, 0, -2, 0, 1, 0, 0, 0, 4, 0, -1, 0, 0 ],
[ 20, -4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]
gap> sym:= Symmetrizations( a6v4, [ a6v4.irreducibles[5] ], 2 );
[ [ 45, -3, 0, 1, 0, -3, 1, 0, -5, 1, 0, -1, 1 ],
[ 55, 7, 1, 3, 0, 7, 3, 1, 5, -1, 0, 1, -1 ] ]
gap> Reduced( a6v4, a6v4.irreducibles, sym );
rec(
remainders := [ [ 27, 3, 0, 3, -3, 3, -1, 0, 1, -1, 1, 1, -1 ] ],
irreducibles := [ [ 9, 1, 0, 1, -1, -3, 1, 0, -1, 1, -1, -1, 1 ] ] )
gap> Append( a6v4.irreducibles,
>            Tensored( last.irreducibles,
>                      Sublist( a6v4.irreducibles, [ 1 .. 4 ] ) ) );
gap> SortCharactersCharTable( a6v4,
>                             (1,4)(2,3)(5,6)(7,8)(9,13,10,11,12) );;
gap> a6v4.identifier:= "A6.2^2";;
gap> DisplayCharTable( a6v4 );
Collapsed(Collapsed(Split(C2xC2,[ 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, \
3, 3, 3, 4, 4, 4 ]),[ 1, 2, 3, 4, 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 12,\
13, 14, 15 ]),[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 13 ])

2  5  5  1  4  1  4  4  1  3  3   1  3  3
3  2  .  2  .  .  1  .  1  .  .   .  .  .
5  1  .  .  .  1  .  .  .  1  .   1  .  .

1a 2a 3a 4a 5a 2b 4b 6a 2c 8a 10a 4c 8b
2P 1a 1a 3a 2a 5a 1a 2a 3a 1a 4a  5a 2a 4a
3P 1a 2a 1a 4a 5a 2b 4b 2b 2c 8a 10a 4c 8b
5P 1a 2a 3a 4a 1a 2b 4b 6a 2c 8a  2c 4c 8b

X.1      1  1  1  1  1  1  1  1  1  1   1  1  1
X.2      1  1  1  1  1  1  1  1 -1 -1  -1 -1 -1
X.3      1  1  1  1  1 -1 -1 -1  1  1   1 -1 -1
X.4      1  1  1  1  1 -1 -1 -1 -1 -1  -1  1  1
X.5     10  2  1 -2  .  2  2 -1  .  .   .  .  .
X.6     10  2  1 -2  . -2 -2  1  .  .   .  .  .
X.7     16  . -2  .  1  .  .  .  4  .  -1  .  .
X.8     16  . -2  .  1  .  .  . -4  .   1  .  .
X.9      9  1  .  1 -1 -3  1  .  1 -1   1  1 -1
X.10     9  1  .  1 -1 -3  1  . -1  1  -1 -1  1
X.11     9  1  .  1 -1  3 -1  .  1 -1   1 -1  1
X.12     9  1  .  1 -1  3 -1  . -1  1  -1  1 -1
X.13    20 -4  2  .  .  .  .  .  .  .   .  .  .```

GAP 3.4.4
April 1997