RepRingD8-AdamsOps.html

> restart: with(linalg):

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

Let's look at the dihedral group of order 8. See p.31 in "Representations and Characters of Groups (first edition)" by James and Liebeck for notation, and p.160-161 for the character table.

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

> G:=[
[[1,0],[0,1]],
[[0,1],[-1,0]],
[[-1,0],[0,-1]],
[[0,-1],[1,0]],
[[1,0],[0,-1]],
[[0,-1],[-1,0]],
[[-1,0],[0,1]],
[[0,1],[1,0]]
]:

> g(G[1]):=e: g(G[2]):=r: g(G[3]):=r2: g(G[4]):=r3: g(G[5]):=f: g(G[6]):=rf: g(G[7]):=r2f: g(G[8]):=r3f:
# 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]) );

> r &* r2;

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

> r &* r2f;

>    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(r,r,r);

> D8List:=[e,r,r2,r3,f,rf,r2f,r3f]:

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

The conjugacy class of r2 is {r2}

The conjugacy class of r is {r3, r}

The conjugacy class of f is {r2f, f}

The conjugacy class of rf is {r3f, rf}

> ConjClList:=[ [e], [r2], [r,r3], [f,r2f], [rf,r3f] ]:

> nops(ConjClList);

> nops(ConjClList[3]);

> ConjClList[3,2];

> CCR:=[e,r2,r,f,rf]:

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 i,j;
for i from 1 to nops(CCL)
   do
      for j from 1 to nops(CCL[i]) do `CharName`(CCL[i,j]):=MtxCol[i];
      od:
   od:
return: end proc:

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

> chi1(e); chi1(r2); chi1(r); chi1(r3); chi1(r&*r);

> defchars:=proc(CharNames, CCL, Mtx)
local i;
for i from 1 to nops(CharNames) do definecharacter(CharNames[i], CCL, subvector(Mtx, 1..nops(CharNames), i)) 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 i,j;
seq(`character`( mymulp(conjclassrep[i]$k) ),i=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);
#print(CoeffVect);
#print(nops(CC));
CoeffVect[1]*IrrChar[1] + CoeffVect[2]*IrrChar[2] + CoeffVect[3]*IrrChar[3] + CoeffVect[4]*IrrChar[4] + CoeffVect[5]*IrrChar[5];
#seq(IrrChar[i],i=1..nops(IrrChar));
#add(CoeffMtx[i,nops(CC)+1]*CC[i],i=1..nops(CC));
end proc:

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

> listAdamsOps:=proc(i,j,CC,IrrChar,Mtx)
#seq(seq( lprint(k,IrrChar[l],psik2lincombi(k,IrrChar[l],CC,IrrChar,Mtx)), l=1..nops(L)), k=i..j);
seq(seq( print([psi^k,IrrChar[l],`=`,psik2lincombi(k,IrrChar[l],CC,IrrChar,Mtx)]), k=i..j), l=1..nops(IrrChar));
end proc:

The correct way to interpret the output is, for example, psi^2(\chi_1) = \chi_1. In other words, just ignore the commas.

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

>