Projectors to traceless mixed-symmetry tensors

Define projectors

General definitions

Attributes[sc]={Orderless};
sc[a_,0]:=0;
sc[a_+b_,c_]:=sc[a,c]+sc[b,c];
sc[a_,num_ b_]:=num sc[a,b]/;NumberQ[num];
sc[a_,sc[x_,y_] b_]:=sc[x,y]sc[a,b];
 sc[{mu_},{mu_}]:=d;
sc/:sc[p_,{mu_}] sc[q_,{mu_}]:=sc[p,q];
sc/:sc[p_,{mu_}]^2:=sc[p,p];
d[a_ b_,x_]:=d[a,x]b+a d[b,x];
d[((a_ )^(n_)),x_]:=n d[a,x](a^(n-1));
d[a_ +b_,y_]:=d[a,y]+ d[b,y];
d[a_/;NumberQ[a],y_]:=0;
d[sc[X_,{mu_}],sc[Y_,{nu_}]]:=If[X===Y,sc[{mu},{nu}],0];
d[sc[X_,Y_],sc[Z_,{mu_}]]:=If[X===Z,sc[Y,{mu}],0]+If[Y===Z,sc[X,{mu}],0];
d[sc[{mu_},{nu_}],a_]:=0;
Const={};
d[b_,a_]:=0;/;MemberQ[Const,b];
d[f_[a_],c_]:=Module[{x},D[f[x],x]/.x-> a]d[a,c];
d[f_[a_,b_],c_]:=Module[{x},D[f[x,b],x]/.x-> a]d[a,c]+Module[{x},D[f[a,x],x]/.x-> b]d[b,c];
d[f_[a_,b_,e_],c_]:=Module[{x},D[f[x,b,e],x]/.x-> a]d[a,c]+Module[{x},D[f[a,x,e],x]/.x-> b]d[b,c]+Module[{x},D[f[a,b,x],x]/.x-> e]d[e,c];
d[a_ListQ,x_]:=Table[d[a[[i]],x],{i,Length[a]}];
del[expr_,dwhat_]:=(d[expr,dwhat]//Expand//Collect[#,sc[__,__]]&)

getT=sc[z1,zb1]->t Sqrt[sc[z1,z1]sc[zb1,zb1]] ;
noT=t->((sc[z1,zb1])/(Sqrt[sc[z1,z1]sc[zb1,zb1]]));
DerivativeToGegenbauer:=DGB[primes_,l_][T_]:>D[GegenbauerC[l,d/2-1,T],{T,primes}]
$RecursionLimit=50000;

Tensor structures

cntLR[a_,b_]:=sc[{a},{b}]-((sc[zb1,{a}]sc[z1,{b}])/(sc[zb1,z1]))
cntLL[a_,b_]:=sc[{a},{b}]-((sc[z1,{a}]sc[z1,{b}])/(sc[z1,z1]))
cntRR[a_,b_]:=sc[{a},{b}]-((sc[zb1,{a}]sc[zb1,{b}])/(sc[zb1,zb1]))
cntL[a_]:=(t^((-1)/2))(((sc[zb1,{a}])/(Sqrt[sc[zb1,zb1]]))-((t sc[z1,{a}])/(Sqrt[sc[z1,z1]])))
cntR[a_]:=(t^((-1)/2))(((sc[z1,{a}])/(Sqrt[sc[z1,z1]]))-((t sc[zb1,{a}])/(Sqrt[sc[zb1,zb1]])))
antisym[a1_,a2_,b1_,b2_]:=(1/2)(sc[{a1},{b1}]sc[{a2},{b2}]-sc[{a1},{b2}]sc[{a2},{b1}])

Q[{l1_,0,0}]={1};

vec[{1,0}]=sc[z2,{a1}]sc[zb2,{b1}];
Q[{l1_,1,0}]={
vec[{1,0}]cntLR[a1,b1]/.getT//Expand//Simplify,
vec[{1,0}]cntL[a1]cntR[b1]/.getT//Expand//Simplify};

vec[{2,0}]=sc[z2,{a1}]sc[z2,{a2}]sc[zb2,{b1}]sc[zb2,{b2}];
Q[{l1_,2,0}]={
vec[{2,0}]cntLR[a1,b1]cntLR[a2,b2]/.getT//Expand//Simplify,
vec[{2,0}]cntLR[a1,b1]cntL[a2]cntR[b2]/.getT//Expand//Simplify,
vec[{2,0}]cntL[a1]cntL[a2]cntR[b1]cntR[b2]/.getT//Expand//Simplify,
vec[{2,0}]cntLL[a1,a2]cntRR[b1,b2]/.getT//Expand//Simplify,
vec[{2,0}](cntLL[a1,a2]cntR[b1]cntR[b2]+cntL[a1]cntL[a2]cntRR[b1,b2])/.getT//Expand//Simplify};

vec[{3,0}]=sc[z2,{a1}]sc[z2,{a2}]sc[z2,{a3}]sc[zb2,{b1}]sc[zb2,{b2}]sc[zb2,{b3}];
Q[{l1_,3,0}]={
vec[{3,0}]cntLR[a1,b1]cntLR[a2,b2]cntLR[a3,b3]//Expand//Simplify,
vec[{3,0}]cntLR[a1,b1]cntLR[a2,b2]cntL[a3]cntR[b3]//Expand//Simplify,
vec[{3,0}]cntLR[a1,b1]cntL[a2]cntR[b2]cntL[a3]cntR[b3]//Expand//Simplify,
vec[{3,0}]cntL[a1]cntR[b1]cntL[a2]cntR[b2]cntL[a3]cntR[b3]//Expand//Simplify,
vec[{3,0}]cntLR[a1,b1]cntLL[a2,a3]cntRR[b2,b3]//Expand//Simplify,
vec[{3,0}]cntL[a1]cntR[b1]cntLL[a2,a3]cntRR[b2,b3]//Expand//Simplify,
vec[{3,0}]cntLR[a1,b1](cntLL[a2,a3]cntR[b2]cntR[b3]+cntL[a2]cntL[a3]cntRR[b2,b3])//Expand//Simplify,
vec[{3,0}]cntL[a1]cntR[b1](cntLL[a2,a3]cntR[b2]cntR[b3]+cntL[a2]cntL[a3]cntRR[b2,b3])//Expand//Simplify};

vec[{4,0}]=sc[z2,{a1}]sc[z2,{a2}]sc[z2,{a3}]sc[z2,{a4}]sc[zb2,{b1}]sc[zb2,{b2}]sc[zb2,{b3}]sc[zb2,{b4}];
Q[{l1_,4,0}]={
vec[{4,0}] cntLR[a1,b1]cntLR[a2,b2]cntLR[a3,b3]cntLR[a4,b4]//Expand//Simplify,
vec[{4,0}] cntLR[a1,b1]cntLR[a2,b2]cntLR[a3,b3]cntL[a4]cntR[b4]//Expand//Simplify,
vec[{4,0}] cntLR[a1,b1]cntLR[a2,b2]cntL[a3]cntR[b3]cntL[a4]cntR[b4]//Expand//Simplify,
vec[{4,0}] cntLR[a1,b1]cntL[a2]cntR[b2]cntL[a3]cntR[b3]cntL[a4]cntR[b4]//Expand//Simplify,
vec[{4,0}] cntL[a1]cntR[b1]cntL[a2]cntR[b2]cntL[a3]cntR[b3]cntL[a4]cntR[b4]//Expand//Simplify,
vec[{4,0}] cntLL[a1,a2]cntRR[b1,b2]cntLR[a3,b3]cntLR[a4,b4]//Expand//Simplify,
vec[{4,0}] cntLL[a1,a2]cntRR[b1,b2]cntLR[a3,b3]cntL[a4]cntR[b4]//Expand//Simplify,
vec[{4,0}] cntLL[a1,a2]cntRR[b1,b2]cntL[a3]cntR[b3]cntL[a4]cntR[b4]//Expand//Simplify,
vec[{4,0}] cntLL[a1,a2]cntRR[b1,b2]cntLL[a3,a4]cntRR[b3,b4]//Expand//Simplify,
vec[{4,0}] cntLR[a1,b1]cntLR[a2,b2](cntLL[a3,a4]cntR[b3]cntR[b4]+cntL[a3]cntL[a4]cntRR[b3,b4])//Expand//Simplify,
vec[{4,0}] cntLR[a1,b1]cntL[a2]cntR[b2](cntLL[a3,a4]cntR[b3]cntR[b4]+cntL[a3]cntL[a4]cntRR[b3,b4])//Expand//Simplify,
vec[{4,0}] cntL[a1]cntR[b1]cntL[a2]cntR[b2](cntLL[a3,a4]cntR[b3]cntR[b4]+cntL[a3]cntL[a4]cntRR[b3,b4])//Expand//Simplify,
vec[{4,0}] (cntLL[a1,a2]cntLL[a3,a4]cntR[b1]cntR[b2]cntR[b3]cntR[b4]+cntL[a1]cntL[a2]cntL[a3]cntL[a4]cntRR[b1,b2]cntRR[b3,b4])//Expand//Simplify,
vec[{4,0}] cntLL[a1,a2]cntRR[b1,b2](cntLL[a3,a4]cntR[b3]cntR[b4]+cntL[a3]cntL[a4]cntRR[b3,b4])//Expand//Simplify};

vec[{1,1}]=sc[z2,{a1}]sc[z3,{a2}]sc[zb2,{b1}]sc[zb3,{b2}];
Q[{l1_,1,1}]={
vec[{1,1}](cntLR[a1,b1]cntLR[a2,b2]-cntLR[a1,b2]cntLR[a2,b1])/2/.getT//Expand//Simplify,
vec[{1,1}](cntLR[a1,b1]cntL[a2]cntR[b2]-cntLR[a2,b1]cntL[a1]cntR[b2]
-cntLR[a1,b2]cntL[a2]cntR[b1]+cntLR[a2,b2]cntL[a1]cntR[b1])/4/.getT//Expand//Simplify};

vec[{2,1}]=sc[z2,{a1}]sc[z2,{u2}]sc[z3,{u3}]sc[zb2,{b1}]sc[zb2,{p2}]sc[zb3,{p3}]antisym[u2,u3,a2,a3]antisym[p2,p3,b2,b3]//Expand;
Q[{l1_,2,1}]={
vec[{2,1}] cntLR[a1,b1]cntLR[a2,b2]cntLR[a3,b3]/.getT//Expand//Simplify,
vec[{2,1}] cntLR[a1,b1]cntLR[a2,b2]cntL[a3]cntR[b3]/.getT//Expand//Simplify,
vec[{2,1}] cntL[a1]cntR[b1]cntLR[a2,b2]cntLR[a3,b3]/.getT//Expand//Simplify,
vec[{2,1}]cntL[a1]cntR[b1]cntL[a2]cntR[b2]cntLR[a3,b3]/.getT//Expand//Simplify,
vec[{2,1}]cntLL[a1,a2]cntRR[b1,b2]cntLR[a3,b3]/.getT//Expand//Simplify,
vec[{2,1}]cntLL[a1,a2]cntRR[b1,b2]cntL[a3]cntR[b3]/.getT//Expand//Simplify,
vec[{2,1}](cntLL[a1,a2]cntR[b1]cntR[b2]+cntL[a1]cntL[a2]cntRR[b1,b2])cntLR[a3,b3]/.getT//Expand//Simplify};

vec[{3,1}]=sc[z2,{a1}]sc[z2,{a2}]sc[z2,{u3}]sc[z3,{u4}]sc[zb2,{b1}]sc[zb2,{b2}]sc[zb2,{p3}]sc[zb3,{p4}]antisym[u3,u4,a3,a4]antisym[p3,p4,b3,b4]//Expand//Simplify;
Q[{l1_,3,1}]={
vec[{3,1}] cntLR[a1,b1]cntLR[a2,b2]cntLR[a3,b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}] cntLR[a1,b1]cntLR[a2,b2]cntLR[a3,b3]cntL[a4]cntR[b4]/.getT//Expand//Simplify,
vec[{3,1}]cntL[a1]cntR[b1]cntLR[a2,b2]cntLR[a3,b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}]cntL[a1]cntR[b1]cntLR[a2,b2]cntL[a3]cntR[b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}]cntL[a1]cntR[b1] cntL[a2]cntR[b2]cntLR[a3,b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}] cntL[a1]cntR[b1] cntL[a2]cntR[b2]cntL[a3]cntR[b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}]cntLR[a1,b1]cntLL[a2,a3]cntRR[b2,b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}]cntL[a1]cntR[b1]cntLL[a2,a3]cntRR[b2,b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}]cntL[a1]cntR[b1]cntLL[a2,a3]cntRR[b2,b3]cntL[a4]cntR[b4]/.getT//Expand//Simplify,
vec[{3,1}]cntLL[a1,a2]cntRR[b1,b2] cntLR[a3,b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}] cntLL[a1,a2]cntRR[b1,b2] cntL[a3]cntR[b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}]cntLR[a1,b1](cntLL[a2,a3]cntR[b2]cntR[b3]+cntL[a2]cntL[a3]cntRR[b2,b3])cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}] cntL[a1]cntR[b1](cntLL[a2,a3]cntR[b2]cntR[b3]+cntL[a2]cntL[a3]cntRR[b2,b3])cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}] (cntLL[a1,a2]cntR[b1]cntR[b2]+cntL[a1]cntL[a2]cntRR[b1,b2])cntLR[a3,b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}] (cntLL[a1,a2]cntR[b1]cntR[b2]+cntL[a1]cntL[a2]cntRR[b1,b2])cntL[a3]cntR[b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{3,1}] (cntL[a1]cntLL[a2,a3]cntRR[b1,b2]cntR[b3]+cntLL[a1,a2]cntL[a3]cntR[b1]cntRR[b2,b3])cntLR[a4,b4]/.getT//Expand//Simplify};//Timing

vec[{2,2}]=(sc[z2,{u1}]sc[z2,{u2}]sc[z3,{u3}]sc[z3,{u4}]sc[zb2,{p1}]sc[zb2,{p2}]sc[zb3,{p3}]sc[zb3,{p4}]*
antisym[u1,u3,a1,a2]antisym[u2,u4,a3,a4]antisym[p1,p3,b1,b2]antisym[p2,p4,b3,b4])//Expand//Simplify;
Q[{l1_,2,2}]={
vec[{2,2}] cntLR[a1,b1]cntLR[a2,b2]cntLR[a3,b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{2,2}] cntLR[a1,b1]cntLR[a2,b2]cntLR[a3,b3]cntL[a4]cntR[b4]/.getT//Expand//Simplify,
vec[{2,2}] cntLR[a1,b1]cntL[a2]cntR[b2]cntLR[a3,b3]cntL[a4]cntR[b4]/.getT//Expand//Simplify,
vec[{2,2}] cntLR[a1,b1]cntLL[a2,a3]cntRR[b2,b3]cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{2,2}] cntLR[a1,b1]cntLL[a2,a3]cntRR[b2,b3]cntL[a4]cntR[b4]/.getT//Expand//Simplify,
vec[{2,2}] cntL[a1]cntR[b1]cntLL[a2,a3]cntRR[b2,b3]cntL[a4]cntR[b4]/.getT//Expand//Simplify,
vec[{2,2}] cntLL[a1,a4]cntLL[a2,a3]cntRR[b2,b3]cntRR[b1,b4]/.getT//Expand//Simplify,
vec[{2,2}] cntLR[a1,b1](cntLL[a2,a3]cntR[b2]cntR[b3]+cntL[a2]cntL[a3]cntRR[b2,b3])cntLR[a4,b4]/.getT//Expand//Simplify,
vec[{2,2}]cntLL[a2,a3]cntRR[b2,b3](cntL[a1]cntL[a4]cntRR[b1,b4]+cntLL[a1,a4]cntR[b1]cntR[b4])/.getT//Expand//Simplify};//Timing

Functions f(t)

f[λ_]:=((fh[λ])/(dn[λ]))
dn[{l_,0,0}]:=1
dn[{l_,1,0}]:=-1
dn[{l_,2,0}]:=-(d-2)
dn[{l_,3,0}]:=-d
dn[{l_,4,0}]:=-d(d+2)
dn[{l_,1,1}]:=-1
dn[{l_,2,1}]:=-(d-3)
dn[{l_,3,1}]:=-d(d-2)
dn[{l_,2,2}]:=-(d-4)(d-3)
fh[{l1_,0,0}]:={DGB[0,l1][t]}
fh[{l1_,1,0}]:={-((-2+d)*t*DGB[1,l1][t])+(1-t^2)*DGB[2,l1][t],DGB[2,l1][t]}
fh[{l1_,2,0}]:={-((-1+d)*d*(-1+(-2+d)*t^2)*DGB[2,l1][t])-2*(-2+d)*d*t*(-1+t^2)*DGB[3,l1][t]-(-2+d)*(-1+t^2)^2*DGB[4,l1][t],2*(-1+d)*d*DGB[2,l1][t]+2*(-1+d)*d*t*DGB[3,l1][t]+2*(-2+d)*(-1+t^2)*DGB[4,l1][t],(-1+d)*d*DGB[2,l1][t]+2*d*t*DGB[3,l1][t]+(2-d+t^2)*DGB[4,l1][t],d*(-2+(-1+d)*t^2)*DGB[2,l1][t]+2*d*t*(-1+t^2)*DGB[3,l1][t]+(-1+t^2)^2*DGB[4,l1][t],(-1+d)*d*t*DGB[2,l1][t]+2*d*t^2*DGB[3,l1][t]+t*(-1+t^2)*DGB[4,l1][t]}
fh[{l1_,3,0}]:={-(d*(1+d)*(2+d)*t*(-3+d*t^2)*DGB[3,l1][t])-3*(1+d)*(2+d)*(-1+t^2)*(-1+d*t^2)*DGB[4,l1][t]-3*d*(2+d)*t*(-1+t^2)^2*DGB[5,l1][t]-d*(-1+t^2)^3*DGB[6,l1][t],6*d*(1+d)*(2+d)*t*DGB[3,l1][t]+3*(1+d)*(2+d)*(-3+(4+d)*t^2)*DGB[4,l1][t]+6*(1+d)*(2+d)*t*(-1+t^2)*DGB[5,l1][t]+3*d*(-1+t^2)^2*DGB[6,l1][t],3*d*(1+d)*(2+d)*t*DGB[3,l1][t]+9*(1+d)*(2+d)*(-1+t^2)*DGB[4,l1][t]-3*(2+d)*t*(4+d-3*t^2)*DGB[5,l1][t]-3*(d-t^2)*(-1+t^2)*DGB[6,l1][t],-3*(1+d)*(2+d)*DGB[4,l1][t]-6*(2+d)*t*DGB[5,l1][t]+(d-3*t^2)*DGB[6,l1][t],3*d*(2+d)*t*(-4+(1+d)*t^2)*DGB[3,l1][t]+3*(2+d)*(-1+t^2)*(-4+3*(1+d)*t^2)*DGB[4,l1][t]+9*(2+d)*t*(-1+t^2)^2*DGB[5,l1][t]+3*(-1+t^2)^3*DGB[6,l1][t],-3*(2+d)*(-4+(1+d)*t^2)*DGB[4,l1][t]-6*(2+d)*t*(-1+t^2)*DGB[5,l1][t]-3*(-1+t^2)^2*DGB[6,l1][t],3*d*(1+d)*(2+d)*t^2*DGB[3,l1][t]+3*(1+d)*(2+d)*t*(-1+3*t^2)*DGB[4,l1][t]+9*(2+d)*t^2*(-1+t^2)*DGB[5,l1][t]+3*t*(-1+t^2)^2*DGB[6,l1][t],-3*(1+d)*(2+d)*t*DGB[4,l1][t]-6*(2+d)*t^2*DGB[5,l1][t]-3*t*(-1+t^2)*DGB[6,l1][t]}
fh[{l1_,4,0}]:={-((1+d)*(2+d)*(3+d)*(4+d)*(3-6*d*t^2+d*(2+d)*t^4)*DGB[4,l1][t])-4*d*(2+d)*(3+d)*(4+d)*t*(-1+t^2)*(-3+(2+d)*t^2)*DGB[5,l1][t]-6*d*(3+d)*(4+d)*(-1+t^2)^2*(-1+(2+d)*t^2)*DGB[6,l1][t]-4*d*(2+d)*(4+d)*t*(-1+t^2)^3*DGB[7,l1][t]-d*(2+d)*(-1+t^2)^4*DGB[8,l1][t],12*(1+d)*(2+d)*(3+d)*(4+d)*(-1+d*t^2)*DGB[4,l1][t]+4*(2+d)*(3+d)*(4+d)*t*(-3-9*d+d*(11+d)*t^2)*DGB[5,l1][t]+12*d*(3+d)*(4+d)*(-1+t^2)*(-2+(5+d)*t^2)*DGB[6,l1][t]+12*d*(3+d)*(4+d)*t*(-1+t^2)^2*DGB[7,l1][t]+4*d*(2+d)*(-1+t^2)^3*DGB[8,l1][t],6*(1+d)*(2+d)*(3+d)*(4+d)*(-3+d*t^2)*DGB[4,l1][t]+12*(2+d)*(3+d)*(4+d)*t*(-3+d*(-3+2*t^2))*DGB[5,l1][t]-6*(3+d)*(4+d)*(-6*d+(3+d*(16+d))*t^2-6*d*t^4)*DGB[6,l1][t]-12*d*(4+d)*t*(5+d-2*t^2)*(-1+t^2)*DGB[7,l1][t]-6*d*(2+d-t^2)*(-1+t^2)^2*DGB[8,l1][t],-12*(1+d)*(2+d)*(3+d)*(4+d)*DGB[4,l1][t]-12*(2+d)*(3+d)^2*(4+d)*t*DGB[5,l1][t]-12*(3+d)*(4+d)*(-2*d+3*(1+d)*t^2)*DGB[6,l1][t]+4*(4+d)*t*(d*(11+d)-3*(1+3*d)*t^2)*DGB[7,l1][t]+4*d*(2+d-3*t^2)*(-1+t^2)*DGB[8,l1][t],-3*(1+d)*(2+d)*(3+d)*(4+d)*DGB[4,l1][t]-12*(2+d)*(3+d)*(4+d)*t*DGB[5,l1][t]+6*(3+d)*(4+d)*(d-3*t^2)*DGB[6,l1][t]+12*(4+d)*t*(d-t^2)*DGB[7,l1][t]+(-(d*(2+d))+6*d*t^2-3*t^4)*DGB[8,l1][t],6*(1+d)*(2+d)*(4+d)*(4-(1+7*d)*t^2+d*(3+d)*t^4)*DGB[4,l1][t]+12*(2+d)*(4+d)*t*(-1+t^2)*(-1-7*d+2*d*(3+d)*t^2)*DGB[5,l1][t]+6*(4+d)*(-1+t^2)^2*(-1-7*d+6*d*(3+d)*t^2)*DGB[6,l1][t]+24*d*(4+d)*t*(-1+t^2)^3*DGB[7,l1][t]+6*d*(-1+t^2)^4*DGB[8,l1][t],-12*(1+d)*(2+d)*(4+d)*(-4+(3+d)*t^2)*DGB[4,l1][t]-12*(2+d)*(4+d)*t*(-8*(1+d)+(3+d)^2*t^2)*DGB[5,l1][t]-12*(4+d)*(-1+t^2)*(-1-7*d+3*(1+d)*(3+d)*t^2)*DGB[6,l1][t]-12*(4+d)*(1+3*d)*t*(-1+t^2)^2*DGB[7,l1][t]-12*d*(-1+t^2)^3*DGB[8,l1][t],-12*(1+d)*(2+d)*(4+d)*(-2+(3+d)*t^2)*DGB[4,l1][t]-12*(2+d)*(4+d)*t*(-7-d+4*(3+d)*t^2)*DGB[5,l1][t]+6*(4+d)*(-1-7*d+(4+d)*(7+d)*t^2-12*(3+d)*t^4)*DGB[6,l1][t]+12*(4+d)*t*(1+d-4*t^2)*(-1+t^2)*DGB[7,l1][t]+6*(d-2*t^2)*(-1+t^2)^2*DGB[8,l1][t],-3*(2+d)*(4+d)*(8+(1+d)*t^2*(-8+(3+d)*t^2))*DGB[4,l1][t]-12*(2+d)*(4+d)*t*(-1+t^2)*(-4+(3+d)*t^2)*DGB[5,l1][t]-6*(4+d)*(-1+t^2)^2*(-4+3*(3+d)*t^2)*DGB[6,l1][t]-12*(4+d)*t*(-1+t^2)^3*DGB[7,l1][t]-3*(-1+t^2)^4*DGB[8,l1][t],6*(1+d)*(2+d)*(3+d)*(4+d)*t*(-1+d*t^2)*DGB[4,l1][t]+12*(2+d)*(3+d)*(4+d)*t^2*(-1+d*(-1+2*t^2))*DGB[5,l1][t]+6*(3+d)*(4+d)*t*(-1+t^2)*(-1+d*(-1+6*t^2))*DGB[6,l1][t]+24*d*(4+d)*t^2*(-1+t^2)^2*DGB[7,l1][t]+6*d*t*(-1+t^2)^3*DGB[8,l1][t],-12*(1+d)*(2+d)*(3+d)*(4+d)*t*DGB[4,l1][t]-12*(2+d)*(3+d)^2*(4+d)*t^2*DGB[5,l1][t]-12*(1+d)*(3+d)*(4+d)*t*(-1+3*t^2)*DGB[6,l1][t]-12*(4+d)*(1+3*d)*t^2*(-1+t^2)*DGB[7,l1][t]-12*d*t*(-1+t^2)^2*DGB[8,l1][t],-6*(1+d)*(2+d)*(3+d)*(4+d)*t*DGB[4,l1][t]-24*(2+d)*(3+d)*(4+d)*t^2*DGB[5,l1][t]+6*(3+d)*(4+d)*t*(1+d-6*t^2)*DGB[6,l1][t]+12*(4+d)*t^2*(1+d-2*t^2)*DGB[7,l1][t]+6*t*(d-t^2)*(-1+t^2)*DGB[8,l1][t],-3*(1+d)*(2+d)*(3+d)*(4+d)*t^2*DGB[4,l1][t]-12*(2+d)*(3+d)*(4+d)*t^3*DGB[5,l1][t]-6*(3+d)*(4+d)*t^2*(-1+3*t^2)*DGB[6,l1][t]-12*(4+d)*t^3*(-1+t^2)*DGB[7,l1][t]-3*t^2*(-1+t^2)^2*DGB[8,l1][t],-6*(1+d)*(2+d)*(4+d)*t*(-4+(3+d)*t^2)*DGB[4,l1][t]-12*(2+d)*(4+d)*t^2*(-7-d+2*(3+d)*t^2)*DGB[5,l1][t]-6*(4+d)*t*(-1+t^2)*(-7-d+6*(3+d)*t^2)*DGB[6,l1][t]-24*(4+d)*t^2*(-1+t^2)^2*DGB[7,l1][t]-6*t*(-1+t^2)^3*DGB[8,l1][t]}
fh[{l1_,1,1}]:={-((-3+d)*t*DGB[1,l1][t])+(1-t^2)*DGB[2,l1][t],2*DGB[2,l1][t]}
fh[{l1_,2,1}]:={-((-2+d)*d*(-1+(-3+d)*t^2)*DGB[2,l1][t])-(-3+d)*(-1+2*d)*t*(-1+t^2)*DGB[3,l1][t]-(-3+d)*(-1+t^2)^2*DGB[4,l1][t],2*(-2+d)*d*DGB[2,l1][t]+2*(-5+(-1+d)*d)*t*DGB[3,l1][t]+2*(-3+d)*(-1+t^2)*DGB[4,l1][t],(-2+d)*d*DGB[2,l1][t]+(7+(-4+d)*d)*t*DGB[3,l1][t]+(-3+d)*(-1+t^2)*DGB[4,l1][t],2*(-2+d)*d*DGB[2,l1][t]+2*(-1+2*d)*t*DGB[3,l1][t]+2*(3-d+t^2)*DGB[4,l1][t],2*d*(-2+(-2+d)*t^2)*DGB[2,l1][t]+2*(-1+2*d)*t*(-1+t^2)*DGB[3,l1][t]+2*(-1+t^2)^2*DGB[4,l1][t],-4*d*DGB[2,l1][t]-2*(3+d)*t*DGB[3,l1][t]+(2-2*t^2)*DGB[4,l1][t],2*(-2+d)*d*t*DGB[2,l1][t]+2*(-1+2*d)*t^2*DGB[3,l1][t]+2*t*(-1+t^2)*DGB[4,l1][t]}
fh[{l1_,3,1}]:={-((-1+d)*(1+d)*(2+d)*t*(4-3*d+(-2+d)*d*t^2)*DGB[3,l1][t])-(2+d)*(-1+t^2)*(4-3*(-1+d)*d+(-2+d)*d*(1+3*d)*t^2)*DGB[4,l1][t]-(-2+d)*d*(5+3*d)*t*(-1+t^2)^2*DGB[5,l1][t]-(-2+d)*d*(-1+t^2)^3*DGB[6,l1][t],4*(-1+d)*d*(1+d)*(2+d)*t*DGB[3,l1][t]+2*(2+d)*(4-3*(-1+d)*d+d*(-10+d*(5+d))*t^2)*DGB[4,l1][t]+4*d*(-7+d*(2+d))*t*(-1+t^2)*DGB[5,l1][t]+2*(-2+d)*d*(-1+t^2)^2*DGB[6,l1][t],4*(4-5*d^2+d^4)*t*DGB[3,l1][t]+2*(2+d)*(4-4*t^2+(-1+d)*d*(-3+(2+d)*t^2))*DGB[4,l1][t]+4*(-4-d+d^3)*t*(-1+t^2)*DGB[5,l1][t]+2*(-2+d)*d*(-1+t^2)^2*DGB[6,l1][t],4*(-1+d)*d*(1+d)*(2+d)*t*DGB[3,l1][t]+4*(2+d)*(4+d*(3+t^2+3*d*(-1+t^2)))*DGB[4,l1][t]+4*t*(8+d*(6+5*t^2-d*(5+d-3*t^2)))*DGB[5,l1][t]+4*d*(-2+d+t^2-d*t^2+t^4)*DGB[6,l1][t],(-4+d)*(-1+d)*(1+d)*(2+d)*t*DGB[3,l1][t]+(2+d)*(4+3*d-3*d^2+(-4+d)*(1+3*d)*t^2)*DGB[4,l1][t]+t*(16-d*(6+d+d^2)+(-4+d)*(5+3*d)*t^2)*DGB[5,l1][t]+(-1+t^2)*(-((-2+d)*d)+(-4+d)*t^2)*DGB[6,l1][t],-2*(2+d)*(-4+3*(-1+d)*d)*DGB[4,l1][t]-4*(-8+d+3*d^2)*t*DGB[5,l1][t]+(2*(-2+d)*d+2*(4-3*d)*t^2)*DGB[6,l1][t],4*(-1+d)*(1+d)*(2+d)*t*(-4+d*t^2)*DGB[3,l1][t]+4*d*(2+d)*(-1+t^2)*(-4+(1+3*d)*t^2)*DGB[4,l1][t]+4*d*(5+3*d)*t*(-1+t^2)^2*DGB[5,l1][t]+4*d*(-1+t^2)^3*DGB[6,l1][t],-16*(-1+d)*(1+d)*(2+d)*t*DGB[3,l1][t]+8*(2+d)*(4*d-(-2+d*(5+d))*t^2)*DGB[4,l1][t]-16*d*(3+d)*t*(-1+t^2)*DGB[5,l1][t]-8*d*(-1+t^2)^2*DGB[6,l1][t],16*d*(2+d)*DGB[4,l1][t]+4*d*(7+d)*t*DGB[5,l1][t]+4*d*(-1+t^2)*DGB[6,l1][t],(-4+d)*(-2+d+d^2)*t*(-4+(1+d)*t^2)*DGB[3,l1][t]+(-4+d)*(2+d)*(-1+t^2)*(-4+(1+3*d)*t^2)*DGB[4,l1][t]+(-4+d)*(5+3*d)*t*(-1+t^2)^2*DGB[5,l1][t]+(-4+d)*(-1+t^2)^3*DGB[6,l1][t],-16*(-1+d)*(1+d)*(2+d)*t*DGB[3,l1][t]-2*(2+d)*(16-12*d+(-28+3*d*(7+d))*t^2)*DGB[4,l1][t]-4*(-16+3*d*(3+d))*t*(-1+t^2)*DGB[5,l1][t]-2*(-4+3*d)*(-1+t^2)^2*DGB[6,l1][t],4*(-1+d)*d*(1+d)*(2+d)*t^2*DGB[3,l1][t]+4*(2+d)*t*(-4+d-d^2+d*(1+3*d)*t^2)*DGB[4,l1][t]+4*d*(5+3*d)*t^2*(-1+t^2)*DGB[5,l1][t]+4*d*t*(-1+t^2)^2*DGB[6,l1][t],-4*(8+d*(2+d+d^2))*t*DGB[4,l1][t]-8*(2+d+d^2)*t^2*DGB[5,l1][t]-4*d*t*(-1+t^2)*DGB[6,l1][t],(-4+d)*(-1+d)*(1+d)*(2+d)*t^2*DGB[3,l1][t]+(-4+d)*(2+d)*t*(-3+t^2+d*(-1+3*t^2))*DGB[4,l1][t]+(-4+d)*(5+3*d)*t^2*(-1+t^2)*DGB[5,l1][t]+(-4+d)*t*(-1+t^2)^2*DGB[6,l1][t],-2*(-4+d)*(2+d)*(3+d)*t*DGB[4,l1][t]-4*(-4+d)*(3+d)*t^2*DGB[5,l1][t]-2*(-4+d)*t*(-1+t^2)*DGB[6,l1][t],16*(-1+d)*(1+d)*(2+d)*t*DGB[3,l1][t]+4*(2+d)*(-4*d+(-8+d*(11+d))*t^2)*DGB[4,l1][t]+8*(-2+d*(5+d))*t*(-1+t^2)*DGB[5,l1][t]+4*d*(-1+t^2)^2*DGB[6,l1][t]}
fh[{l1_,2,2}]:={-((-3+d)*(-2+d)*(-1+d)*(-1+(-4+d)*t^2)*DGB[2,l1][t])-2*(-4+d)*(-3+d)*(-1+d)*t*(-1+t^2)*DGB[3,l1][t]-(-4+d)*(-3+d)*(-1+t^2)^2*DGB[4,l1][t],4*(-3+d)*(-2+d)*(-1+d)*DGB[2,l1][t]+4*(-3+d)^2*(-1+d)*t*DGB[3,l1][t]+4*(-4+d)*(-3+d)*(-1+t^2)*DGB[4,l1][t],4*(-3+d)*(-2+d)*(-1+d)*DGB[2,l1][t]+8*(-3+d)*(-1+d)*t*DGB[3,l1][t]+4*(-3+d)*(4-d+t^2)*DGB[4,l1][t],4*(-2+d)*(-1+d)*(-2+(-3+d)*t^2)*DGB[2,l1][t]+8*(-3+d)*(-1+d)*t*(-1+t^2)*DGB[3,l1][t]+4*(-3+d)*(-1+t^2)^2*DGB[4,l1][t],-16*(-2+d)*(-1+d)*DGB[2,l1][t]-8*(-1+d)^2*t*DGB[3,l1][t]-8*(-3+d)*(-1+t^2)*DGB[4,l1][t],-8*(-2+d)*(-1+d)*DGB[2,l1][t]-16*(-1+d)*t*DGB[3,l1][t]+4*(-3+d-2*t^2)*DGB[4,l1][t],-2*(-1+d)*(-3+(-2+d)*t^2)*DGB[2,l1][t]-4*(-1+d)*t*(-1+t^2)*DGB[3,l1][t]-2*(-1+t^2)^2*DGB[4,l1][t],4*(-3+d)*(-2+d)*(-1+d)*t*DGB[2,l1][t]+8*(-3+d)*(-1+d)*t^2*DGB[3,l1][t]+4*(-3+d)*t*(-1+t^2)*DGB[4,l1][t],-4*(-2+d)*(-1+d)*t*DGB[2,l1][t]-8*(-1+d)*t^2*DGB[3,l1][t]-4*t*(-1+t^2)*DGB[4,l1][t]}

Normalization

H[λ_]:=Product[Product[λ[[j]]-j-i+4,{j,1,3}],{i,1,λ[[3]]}]*
Product[Product[λ[[j]]-j-i+3,{j,1,2}],{i,λ[[3]]+1,λ[[2]]}]*
Product[λ[[1]]-i+1,{i,λ[[2]]+1,λ[[1]]}]
b[λ_]:=(((2^(λ[[1]]))Pochhammer[d/2-1,λ[[1]]]Product[λ[[1]]+d-3+i-2,{i,1,λ[[3]]}]Product[λ[[1]]+d-2+i-2,{i,λ[[3]]+1,λ[[2]]}])/((λ[[1]]-λ[[2]])!))
c[λ_]:=(((2^(λ[[3]]))λ[[1]]!λ[[2]]!λ[[3]]!)/(b[λ]H[λ]))

Definition of the projector

projector::usage="projector[λ_] computes the projector to the irreducible SO(d) representation λ.
λ must be a list containing a representation label of the form {(Subscript[l, 1]),(Subscript[l, 2]),(Subscript[l, 3])}, {(Subscript[l, 1]),(Subscript[l, 2])} or {(Subscript[l, 1])}.
(Subscript[l, 2]) and (Subscript[l, 3]) must be integers, picking one of the families of projectors computed in the paper:
((Subscript[l, 1]),0,0), ((Subscript[l, 1]),1,0), ((Subscript[l, 1]),2,0), ((Subscript[l, 1]),3,0), ((Subscript[l, 1]),4,0), ((Subscript[l, 1]),1,1), ((Subscript[l, 1]),2,1), ((Subscript[l, 1]),3,1) or ((Subscript[l, 1]),2,2).
(Subscript[l, 1]) may be an integer or left generic. ";
projector[λin_]:=Module[{λ,res},
λ=Switch[Length[λin],3,λin,2,Join[λin,{0}],1,Join[λin,{0,0}]];
res=c[λ](((sc[z1,z1]sc[zb1,zb1]))^((λ[[1]])/2))f[λ].Q[λ]/.getT/.DerivativeToGegenbauer;
If[NumberQ[λ[[1]]],SimplifyProjector[res],res]
]
SimplifyProjector[func_]:=Collect[func/.noT//.{sc[zb1,zb1]->(sczb1^2),sc[z1,z1]->(scz1^2)},{sczb1,scz1,sc[__,__]},Simplify[#,Assumptions->{sczb1>0,scz1>0}]&]//.{sczb1->((sc[zb1,zb1])^(1/2)),scz1->((sc[z1,z1])^(1/2))}//Factor

Examples

?projector

projector[{2}]

(1/4)d[d[d[d[projector[{2}],sc[z1,{a1}]],sc[z1,{a2}]],sc[zb1,{b1}]],sc[zb1,{b2}]]//Expand

projector[{4,0,0}]

projector[{(Subscript[l, 1]),1,0}]

projector[{3,1,0}]

projector[{(Subscript[l, 1]),2,0}]

projector[{3,2,0}]

Checks

Definitions for checks

CheckLeftRightSymmetry[λ_,n_]:=Module[{proj,proj2,res,i},
res={};
For[i=0,i<n,i++,
proj=projector[λ+{i,0,0}];
proj2=proj//.{z1->x1,z2->x2,z3->x3}//.{zb1->z1,zb2->z2,zb3->z3}//.{x1->zb1,x2->zb2,x3->zb3};
AppendTo[res,Collect[proj-proj2,sc[__,__],Factor]];
]
res
]

CheckMixedSymmetry[poly_,z1_,z2_]:=Block[{aux,μ},
aux=del[poly,sc[z2,{μ}]];
Collect[((sc[z1,{μ}]aux //Expand)/.getT),sc[__,__],Factor]
]
CheckMixedSymmetriesZ[λ_,n_]:=Module[{combos,proj,res,i},
res={};
combos={{z1,z2}};
If[λ[[3]]≠0,combos=Join[combos,{{z1,z3},{z2,z3}}]];
For[i=0,i<n,i++,
proj=projector[λ+{i,0,0}];
AppendTo[res,Table[CheckMixedSymmetry[proj,combos[[j]][[1]],combos[[j]][[2]]],{j,1,Length[combos]}]];
]
res
]

CheckTrace[poly_,z1_,z2_]:=Block[{aux},
aux=del[del[poly,sc[z1,{μ}]],sc[z2,{ν}]];
Collect[((aux sc[{μ},{ν}]//Expand)/.getT),sc[__,__],Factor]
]
CheckTracesZ[λ_,n_]:=Module[{combos,proj,res,i},
res={};
combos={{z1,z1}};
If[λ[[2]]≠0,combos=Join[combos,{{z1,z2}}]];
If[λ[[2]]>1,combos=Join[combos,{{z2,z2}}]];
If[λ[[3]]≠0,combos=Join[combos,{{z1,z3},{z2,z3}}]];
If[λ[[3]]>1,combos=Join[combos,{{z3,z3}}]];
i=0;
For[,i<n,i++,
proj=projector[λ+{i,0,0}];
AppendTo[res,Table[CheckTrace[proj,combos[[j]][[1]],combos[[j]][[2]]],{j,1,Length[combos]}]];
]
res
]

SquareProjector[poly_,λ_]:=Block[{p1,p2,p,aux},
p1=poly/.{zb1->W1,zb2->W2,zb3->W3};
p2=poly/.{z1->Y1,z2->Y2,z3->Y3};
p=p1*p2;
For[n=0,n<λ[[1]],n++,
aux=del[del[p,sc[W1,{μ}]],sc[Y1,{ν}]];
p=Collect[(aux sc[{μ},{ν}]//Expand),sc[__,__]];
];
For[n=0,n<λ[[2]],n++,
aux=del[del[p,sc[W2,{μ}]],sc[Y2,{ν}]];
p=Collect[(aux sc[{μ},{ν}]//Expand),sc[__,__]];
];
For[n=0,n<λ[[3]],n++,
aux=del[del[p,sc[W3,{μ}]],sc[Y3,{ν}]];
p=Collect[(aux sc[{μ},{ν}]//Expand),sc[__,__]];
];
(p/(((λ[[1]]!λ[[2]]!λ[[3]]!))^2))
]
TestIdempotence[λ_,n_]:=Module[{proj,res,i},
res={};
For[i=0,i<n,i++,
proj=projector[λ+{i,0,0}];
AppendTo[res,Collect[SquareProjector[proj,λ+{i,0,0}]-proj,sc[__,__],Factor]];
]
res
]

h[λ_,i_]:=If[i>λ[[1]],0,
If[i>λ[[2]],1,
If[i>λ[[3]],2,3]]]
dim[λ_]:=(1/(H[λ]))Product[d+λ[[i]]+λ[[j]]-i-j,{i,1,h[λ,1]},{j,1,Min[i,λ[[i]]]}]Product[d-h[λ,i]-h[λ,j]+i+j-2,{j,2,λ[[1]]},{i,1,Min[j-1,h[λ,j]]}]
CheckDimsRow1[n_]:=Block[{aux},
aux=projector[{n}];
For[i=0,i<n,i++,
aux=CheckTrace[aux/.noT,z1,zb1]];
(aux/(((n!))^2))-dim[{n,0,0}]//Simplify
]
CheckDimRow2[λ_]:=((1/((λ[[2]])^2))CheckTrace[projector[λ],z2,zb2]-((dim[λ])/(dim[{λ[[1]],λ[[2]]-1,λ[[3]]}])) projector[{λ[[1]],λ[[2]]-1,λ[[3]]}])/.getT/.{sc[z1,z1]->1,sc[zb1,zb1]->1}//Factor
CheckDimRow3[λ_]:=((1/((λ[[3]])^2))CheckTrace[projector[λ],z3,zb3]-((dim[λ])/(dim[{λ[[1]],λ[[2]],λ[[3]]-1}])) projector[{λ[[1]],λ[[2]],λ[[3]]-1}])/.getT/.{sc[z1,z1]->1,sc[zb1,zb1]->1}//Factor

Check left-right symmetry

CheckLeftRightSymmetry[{0,0,0},4]//Timing

CheckLeftRightSymmetry[{1,1,0},4]//Timing

CheckLeftRightSymmetry[{2,2,0},4]//Timing

CheckLeftRightSymmetry[{3,3,0},4]//Timing

CheckLeftRightSymmetry[{4,4,0},4]//Timing

CheckLeftRightSymmetry[{1,1,1},4]//Timing

CheckLeftRightSymmetry[{2,2,1},4]//Timing

CheckLeftRightSymmetry[{3,3,1},4]//Timing

CheckLeftRightSymmetry[{2,2,2},4]//Timing

Check mixed symmetry

CheckMixedSymmetriesZ[{1,1,0},4]//Timing

CheckMixedSymmetriesZ[{2,2,0},4]//Timing

CheckMixedSymmetriesZ[{3,3,0},4]//Timing

CheckMixedSymmetriesZ[{4,4,0},4]//Timing

CheckMixedSymmetriesZ[{1,1,1},4]//Timing

CheckMixedSymmetriesZ[{2,2,1},4]//Timing

CheckMixedSymmetriesZ[{3,3,1},4]//Timing

CheckMixedSymmetriesZ[{2,2,2},4]//Timing

Check tracelessness

CheckTracesZ[{0,0,0},4]//Timing

CheckTracesZ[{1,1,0},4]//Timing

CheckTracesZ[{2,2,0},4]//Timing

CheckTracesZ[{3,3,0},4]//Timing

CheckTracesZ[{4,4,0},4]//Timing

CheckTracesZ[{1,1,1},4]//Timing

CheckTracesZ[{2,2,1},4]//Timing

CheckTracesZ[{3,3,1},2]//Timing
CheckTracesZ[{5,3,1},1]//Timing
CheckTracesZ[{6,3,1},1]//Timing

CheckTracesZ[{2,2,2},2]//Timing
CheckTracesZ[{4,2,2},1]//Timing
CheckTracesZ[{5,2,2},1]//Timing

Check Idempotence

TestIdempotence[{0,0,0},2]//Timing

TestIdempotence[{1,1,0},2]//Timing

TestIdempotence[{2,2,0},2]//Timing

TestIdempotence[{1,1,1},1]//Timing
TestIdempotence[{2,1,1},1]//Timing

TestIdempotence[{3,3,0},1]//Timing
TestIdempotence[{4,3,0},1]//Timing

TestIdempotence[{2,2,1},1]//Timing
TestIdempotence[{3,2,1},1]//Timing

TestIdempotence[{4,4,0},1]//Timing
TestIdempotence[{5,4,0},1]//Timing

TestIdempotence[{3,3,1},1]//Timing

TestIdempotence[{2,2,2},1]//Timing

Check that the trace matches the dimension

Table[CheckDimsRow1[k],{k,0,20}]//Timing

Table[CheckDimRow2[{l1,1,0}],{l1,2,7}]//Timing

Table[CheckDimRow2[{l1,2,0}],{l1,2,7}]//Timing

Table[CheckDimRow2[{l1,3,0}],{l1,3,7}]//Timing

Table[CheckDimRow2[{l1,4,0}],{l1,4,7}]//Timing

Table[CheckDimRow3[{l1,1,1}],{l1,2,7}]//Timing

Table[CheckDimRow3[{l1,2,1}],{l1,2,7}]//Timing

Table[CheckDimRow3[{l1,3,1}],{l1,3,7}]//Timing

Table[CheckDimRow3[{l1,2,2}],{l1,2,7}]//Timing