Find the conjugate/similar transformation matrices connecting two unitary irreducible representations corresponding to the same character.

Question

According to the GAP manual, the following description is given for the command IrreducibleRepresentationsDixon:

If the option unitary is given, GAP tries, at extra cost, to find a unitary representation (and will issue an error if it cannot do so).

Suppose I already have a unitary irreducible complex representation for a group. In this case, can I find the conjugate/similar transformation matrices connecting the two unitary irreducible complex representations, i.e., the one used by GAP and the one I already have, of the same group?

I would like to use the following example to provide more information. The group is shown below:

The corresponding already known character table and the irreducible representations of the generators are shown below:

The corresponding gap code snippet is as follows:

gap> f:=FreeGroup("P" ,"Q");;
gap> G8_5:=f/ParseRelators(f, "P^4 = Q^4 = 1, Q*P = P^3*Q, Q^2 = P^2");;
gap> char:= First( Irr( G8_5 ), x -> x[1] = 2 );;
gap> hom:=IrreducibleRepresentationsDixon(G8_5, char: unitary );
[ P, Q ] -> [ [ [ E(4), 0 ], [ 0, -E(4) ] ], [ [ 0, 1 ], [ -1, 0 ] ] ]

Taking the R5 for example, as you can see, there are two sets of 2-dimensional irreducible representations matrices given by GAP and the ones corresponding to the generators shown in the screenshot.

Based on the above results, I tried to perform the following test:

# Create group using the generators of the homomorhpism mapping image: 
gap> matg1:=GroupWithGenerators( MappingGeneratorsImages(hom)[2] );
Group([ [ [ -E(4), 0 ], [ 0, E(4) ] ], [ [ 0, -E(4) ], [ -E(4), 0 ] ] ])
# Create group using the representation matrices given in the screenshot:
gap> matg2:=GroupWithGenerators( [ [ [ 0, 1 ], [ -1, 0 ] ], [ [ 0, E(4) ], [ E(4), 0 ] ] ] );
Group([ [ [ 0, 1 ], [ -1, 0 ] ], [ [ 0, E(4) ], [ E(4), 0 ] ] ])

gap> iso:=IsomorphismGroups(matg1,matg2);
CompositionMapping( [ [ [ 0, -1, 0, 0 ], [ 1, 0, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, -1, 0 ] ], 
  [ [ 0, 0, 0, -1 ], [ 0, 0, 1, 0 ], [ 0, -1, 0, 0 ], [ 1, 0, 0, 0 ] ] ] -> [ [ [ 0, 1 ], [ -1, 0 ] ], [ [ 0, E(4) ], [ E(4), 0 ] ] ],
 <mapping: Group([ [ [ -E(4), 0 ], [ 0, E(4) ] ], [ [ 0, -E(4) ], [ -E(4), 0 ] ] ]) -> Group(
[ [ [ 0, -1, 0, 0 ], [ 1, 0, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, -1, 0 ] ], [ [ 0, 0, 0, -1 ], [ 0, 0, 1, 0 ], [ 0, -1, 0, 0 ], [ 1, 0, 0, 0 ] ] ]) > )

gap> Source(iso)=matg1; Range(iso)=matg2;
true
true

gap> IsCompositionMappingRep(iso);
true
gap> ConstituentsCompositionMapping(iso);
[ <mapping: Group([ [ [ E(4), 0 ], [ 0, -E(4) ] ], [ [ 0, E(4) ], [ E(4), 0 ] ] ]) -> Group(
    [ [ [ 0, 1, 0, 0 ], [ -1, 0, 0, 0 ], [ 0, 0, 0, -1 ], [ 0, 0, 1, 0 ] ], 
      [ [ 0, 0, 0, 1 ], [ 0, 0, -1, 0 ], [ 0, 1, 0, 0 ], [ -1, 0, 0, 0 ] ] ]) >, 
  [ [ [ 0, 1, 0, 0 ], [ -1, 0, 0, 0 ], [ 0, 0, 0, -1 ], [ 0, 0, 1, 0 ] ], 
      [ [ 0, 0, 0, 1 ], [ 0, 0, -1, 0 ], [ 0, 1, 0, 0 ], [ -1, 0, 0, 0 ] ] ] -> 
    [ [ [ 0, 1 ], [ -1, 0 ] ], [ [ 0, E(4) ], [ E(4), 0 ] ] ] ]

As you can see, matg1 and matg2 are two isomorphic matrix groups. There should exist an infinite number of conjugate or similar transformations connecting them, which corresponding to different bases selection, i.e., conjugating the matrix group by some invertible matrix. In order to identify/create/find one of them, I tried with the following code snippet, but in vain:

gap> ds_matg1:=DirectSumMat( matg1.1, matg1.2 );
[ [ -E(4), 0, 0, 0 ], [ 0, E(4), 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, -1, 0 ] ]
gap> ds_matg2:=DirectSumMat( matg2.1, matg2.2 );
[ [ 0, 1, 0, 0 ], [ -1, 0, 0, 0 ], [ 0, 0, 0, E(4) ], [ 0, 0, E(4), 0 ] ]
gap> 
gap> ds:=Group(ds_matg1,ds_matg2 );
<matrix group with 2 generators>
gap> 
gap> for i in Elements(ds) do
>   if ds_matg1^i = ds_matg2 then
>       Print(i,"\n",ds_matg1^i,"\n",ds_matg2," \n\n ");
>   fi;
> od;

---

P.S. It seems that the is_similar function provided by sagemath is exactly for this purpose, as described here.

Regards, HZ

Answer 1

The functionality for testing of equivalence of representations (using the MeatAxe functionality, see MTX.IsomorphismModules in the manual) currently only works over finite fields. The reason for not extending the implementation to characteristic 0 is that

• Equivalence for finite group representations in characteristic 0 can be determined using only the character.

• The need to go to a larger field extension makes such a test potentially much more costly in characteristic 0, than over finite fields.