67.18 Automorphisms and Equivalence of Character Tables

For a matrix mat, MatrixAutomorphisms returns the group of those permutations of the columns of mat that leave the set of rows of mat invariant.

If the arguments maps and subgroup are given, only the group of those permutations is constructed that additionally fix each list in the list maps under pointwise action OnTuples, and subgroup is a permutation group that is known to be a subgroup of this group of automorphisms.

Each entry in maps must be a list of same length as the rows of mat. For example, if mat is a list of irreducible characters of a group then the list of element orders of the conjugacy classes (see OrdersClassRepresentatives) may be an entry in maps.

TableAutomorphisms returns the permutation group of those matrix automorphisms (see MatrixAutomorphisms) of the list characters that leave the element orders (see OrdersClassRepresentatives) and all stored power maps (see ComputedPowerMaps) of the character table tbl.

If characters is closed under Galois conjugacy --this is always fulfilled for ordinary character tables-- the string "closed" may be entered as third argument.

The attribute AutomorphismsOfTable (see AutomorphismsOfTable) can be used to compute and store the table automorphisms for the case that characters equals Irr( tbl ).

gap> tbld8:= CharacterTable( "Dihedral", 8 );;
gap> irrd8:= Irr( tbld8 );
[ Character( CharacterTable( "D8" ), [ 1, 1, 1, 1, 1 ] ), 
  Character( CharacterTable( "D8" ), [ 1, 1, 1, -1, -1 ] ), 
  Character( CharacterTable( "D8" ), [ 1, -1, 1, 1, -1 ] ), 
  Character( CharacterTable( "D8" ), [ 1, -1, 1, -1, 1 ] ), 
  Character( CharacterTable( "D8" ), [ 2, 0, -2, 0, 0 ] ) ]
gap> orders:= OrdersClassRepresentatives( tbld8 );
[ 1, 4, 2, 2, 2 ]
gap> MatrixAutomorphisms( irrd8 );
Group([ (4,5), (2,4) ])
gap> MatrixAutomorphisms( irrd8, [ orders ], Group( () ) );
Group([ (4,5) ])
gap> TableAutomorphisms( tbld8, irrd8 );
Group([ (4,5) ])

Let mat1 and mat2 be matrices. TransformingPermutations tries to construct a permutation p that transforms the set of rows of the matrix mat1 to the set of rows of the matrix mat2 by permuting the columns.

If such a permutation exists, a record with components columns, rows, and group is returned, otherwise fail. For TransformingPermutations( mat1 , mat2 ) = r ¹ fail, we have mat2 = Permuted( List( mat1, x -> Permuted( x, r.columns ) ),r.rows ).

r.group is the group of matrix automorphisms of mat2 (see MatrixAutomorphisms). This group stabilizes the transformation in the sense that applying any of its elements to the columns of mat2 preserves the set of rows of mat2.

Let tbl1 and tbl2 be character tables. TransformingPermutationsCharacterTables tries to construct a permutation p that transforms the set of rows of the matrix Irr( tbl1 ) to the set of rows of the matrix Irr( tbl2 ) by permuting the columns (see TransformingPermutations), such that p transforms also the power maps and the element orders.

If such a permutation p exists then a record with the components columns ( p), rows (the permutation of Irr( tbl1 ) corresponding to p), and group (the permutation group of table automorphisms of tbl2, see AutomorphismsOfTable) is returned. If no such permutation exists, fail is returned.

gap> tblq8:= CharacterTable( "Quaternionic", 8 );;
gap> irrq8:= Irr( tblq8 );
[ Character( CharacterTable( "Q8" ), [ 1, 1, 1, 1, 1 ] ), 
  Character( CharacterTable( "Q8" ), [ 1, 1, 1, -1, -1 ] ), 
  Character( CharacterTable( "Q8" ), [ 1, -1, 1, 1, -1 ] ), 
  Character( CharacterTable( "Q8" ), [ 1, -1, 1, -1, 1 ] ), 
  Character( CharacterTable( "Q8" ), [ 2, 0, -2, 0, 0 ] ) ]
gap> OrdersClassRepresentatives( tblq8 );
[ 1, 4, 2, 4, 4 ]
gap> TransformingPermutations( irrd8, irrq8 );
rec( columns := (), rows := (), group := Group([ (4,5), (2,4) ]) )
gap> TransformingPermutationsCharacterTables( tbld8, tblq8 );
fail
gap> tbld6:= CharacterTable( "Dihedral", 6 );;
gap> tbls3:= CharacterTable( "Symmetric", 3 );;
gap> TransformingPermutationsCharacterTables( tbld6, tbls3 );
rec( columns := (2,3), rows := (1,3,2), group := Group(()) )

distributes the rows of the matrix mat into families as follows. Two rows of mat belong to the same family if there is a permutation of columns that maps one row to the other row. Each entry in the list maps is regarded to form a family of length 1.

FamiliesOfRows( mat, maps ) returns a record with components

famreps

the list of representatives for each family,

permutations

the list that contains at position i a list of permutations that map the members of the family with representative famreps[i] to that representative,

families

the list that contains at position i the list of positions of members of the family of representative famreps[i]; (for the element maps[i] the only member of the family will get the number Length( mat ) + i).

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