RepRingQ8-AdamsOps.html

> restart: with(linalg):

Warning, the protected names norm and trace have been redefined and unprotected

Let's look at the quaternion group of order 8. See p.6 in "Representations of Compact Lie Groups" by Br\" oker and tom Dieck for notation, and p.189 of Hopkins, Kuhn, and Ravenel's "Morava K-theories of classifying spaces and generalized characters for finite groups" for the character table.

We're going to define the elements of Q_8 to be matrices, that way we can multiply them easily without having to define procedures...

> G:=[
[[1,0],[0,1]], # 1
[[0,1],[-1,0]], # j
[[-1,0],[0,-1]], #-1
[[0,-1],[1,0]],# -j
[[I,0],[0,-I]], # i
[[0,-I],[-I,0]], # -k
[[-I,0],[0,I]], # -i
[[0,I],[I,0]] # k
]:

> #evalm( [[0,1],[-1,0]] &* [[0,1],[-1,0]] );

> #evalm( [[0,1],[-1,0]] &* [[0,1],[-1,0]] &* [[0,1],[-1,0]] );

> #evalm( [[I,0],[0,-I]] &* [[I,0],[0,-I]] &* [[I,0],[0,-I]] );

> #evalm( [[0,I],[I,0]] &* [[0,I],[I,0]] &* [[0,I],[I,0]] );

> g(G[1]):=e: g(G[2]):=j: g(G[3]):=-e: g(G[4]):=-j: g(G[5]):=i: g(G[6]):=-k: g(G[7]):=-i: g(G[8]):=k:
# assign the matrices to names that won't be evaluated by maple (that way,
# the names are immutable just like basis elements!
# we could do this with lists, too, e.g. g:=[seq(f(G[i]),i=1..nops(G))]:

> mm:=(A,B)->[[A[1,1]*B[1,1]+A[1,2]*B[2,1], A[1,1]*B[1,2]+A[1,2]*B[2,2]], [A[2,1]*B[1,1] +A[2,2]*B[2,1],A[2,1]*B[1,2]+A[2,2]*B[2,2]]]:

> g(mm(G[2],G[3]));

> g(G[2]) &* g(G[3]) := g( mm(G[2],G[3]) );

> j &* (-e);

>    # tell maple how to multiply the names
for a from 1 to nops(G) do
  for b from 1 to nops(G) do
    g(G[a]) &* g(G[b]) := g(mm(G[a],G[b]));
  end do;
end do;

> (-j) &* (-k);

> k &* (-j);

>

>    mymulp:=proc()
description "multiply any number of group elts";
local accumulated,m;
    accumulated := args[1] &* args[2];
    for m from 3 to nargs do
        accumulated := accumulated &* args[m];
    end do;
accumulated;
end proc:

> mymulp(k,k,k);

> Q8List:=[e,j,-e,-j,i,-k,-i,k]:

Let's compute the conjugacy classes in Q_8. (skip)
The conjugacy class of e is obviously {e}.

The conjugacy class of -e is {-e}

The conjugacy class of i is {i, -i}

The conjugacy class of j is {j, -j}

The conjugacy class of k is {k, -k}

> ConjClList:=[ [e], [-e], [i,-i], [j,-j], [k,-k] ]:

> nops(ConjClList);

> nops(ConjClList[3]);

> ConjClList[3,2];

> CCR:=[e,-e,i,j,k]:

Let's define the character table. (p 161 James and Liebeck)

> CharTableTransposed:=
[[1,1,1,1,1],
[1,1,1,-1,-1],
[1,1,-1,1,-1],
[1,1,-1,-1,1],
[2,-2,0,0,0]]:

In this character table the columns are indexed by the irreducible characters chi1,chi2,... from left to right, and the rows are indexed by the conjugacy class representatives e, r2, r, f, rf from top to bottom.

> CharTable:=transpose(CharTableTransposed);

>    definecharacter:=proc(CharName, CCL, MtxCol)
description "CharName is the name of the character, and its values on conjugacy class representatives are listed in order in the matrix column of the character table correspoding to the elements in a list of conjugacy class representatives";
local a,b;
for a from 1 to nops(CCL)
   do
      for b from 1 to nops(CCL[a]) do `CharName`(CCL[a,b]):=MtxCol[a];
      od:
   od:
return: end proc:

> definecharacter(chi1,ConjClList,subvector(CharTable,1..nops(ConjClList), 1));

> chi1(e); chi1(-e); chi1(i); chi1(-i); chi1( i &* i);

> defchars:=proc(CharNames, CCL, Mtx)
local a;
for a from 1 to nops(CharNames) do definecharacter(CharNames[a], CCL, subvector(Mtx, 1..nops(CharNames), a)) od: return:
end proc:

> IChar:=[chi1,chi2,chi3,chi4,chi5]:
#IChar:=[ONE,alpha,beta,epsilon,chi5]:

> defchars(IChar,ConjClList,CharTable);

> #beta(f);

> psi:=proc(K,character,conjclassrep)
local a,b;
seq(`character`( mymulp(conjclassrep[a]$K) ),a=1..nops(conjclassrep));
end proc:

> psi(2,chi5,CCR);

> augment(CharTable,[psi(2,chi5,CCR)]);

> gaussjord(%);

> psik2lincombi:=proc(K,character,CC,IrrChar,Mtx)
local CoeffVect;
CoeffVect:=subvector( gaussjord(augment(Mtx,[ psi(K,`character`,CC) ])), 1..nops(CC), nops(CC)+1);
CoeffVect[1]*IrrChar[1] + CoeffVect[2]*IrrChar[2] + CoeffVect[3]*IrrChar[3] + CoeffVect[4]*IrrChar[4] + CoeffVect[5]*IrrChar[5];
end proc:

> psik2lincombi(2,chi5,CCR,IChar,CharTable);

> psik2lincombi(2,chi4,CCR,IChar,CharTable);

> listAdamsOps:=proc(a,b,CC,IrrChar,Mtx)
seq(seq( print([psi^K,IrrChar[l],`=`,psik2lincombi(K,IrrChar[l],CC,IrrChar,Mtx)]), K=a..b), l=1..nops(IrrChar));
end proc:

> listAdamsOps(2,8,CCR,IChar,CharTable);

>