(* ::Package:: *)

(************************************************************************)
(* This file was generated automatically by the Mathematica front end.  *)
(* It contains Initialization cells from a Notebook file, which         *)
(* typically will have the same name as this file except ending in      *)
(* ".nb" instead of ".m".                                               *)
(*                                                                      *)
(* This file is intended to be loaded into the Mathematica kernel using *)
(* the package loading commands Get or Needs.  Doing so is equivalent   *)
(* to using the Evaluate Initialization Cells menu command in the front *)
(* end.                                                                 *)
(*                                                                      *)
(* DO NOT EDIT THIS FILE.  This entire file is regenerated              *)
(* automatically each time the parent Notebook file is saved in the     *)
(* Mathematica front end.  Any changes you make to this file will be    *)
(* overwritten.                                                         *)
(************************************************************************)



(* <<Algebra`SymmetricPolynomials` REMOVED: NOT NEEDED *)


<<Combinatorica`       (* Standard in 6.0 *)


(* <<LinearAlgebra`MatrixManipulation` REMOVED: NOT NEEDED *)


Off[General::spell]


Off[General::spell1]


h0[k_Integer,n_] := If[k>0,Coefficient[Series[Product[1/(1-t x[i]),{i,1,n}],{t,0,k}],t^k], If[k==0, 1, 0]]


h[lambda_List]:= Apply[Times, Map[h[#]&,lambda]]


h[lambda_List,n_] := Apply[Times, Map[h0[#, n]&,lambda]]//Expand


he[n_] := Det[HEMat[n]]//Expand


hp[n_] := Det[HPMat[n]]/(n!)//Expand


HList[n_] := Map[h,Partitions[n]]


HList[n_, k_]:=Map[h, Partitions[n,Rows->k]]


HList2[n_, k_]:=Map[h, Partitions[n,Columns->k]]


x0[lambda_List]:=Apply[Times, Map[x[#]&,lambda]]


e0[k_Integer,n_] := Apply[Plus, Map[x0[#]&, KSubsets[Range[n], k]]]


e[lambda_List]:= Apply[Times,Map[e[#]&, lambda]] 


e[lambda_List,n_] := Apply[Times, Map[e0[#, n]&,lambda]]//Expand


eh[n_]:=Det[EHMat[n]]//Expand


ep[n_]:=Det[EPMat[n]]/(n!)//Expand


EList[n_]:=Map[e,Partitions[n]]


EList[n_, k_]:=Map[e,Map[ConjugateP, Partitions[n, Rows->k]]]


monomial[list_] := Product[x[i]^list[[i]],{i,Length[list]}]


m[lambda_List,n_] := Module[{exponents,perms,output},
If[n<Length[lambda],output=0,
(*else*)
exponents = lambda;
While[Length[exponents]<n,AppendTo[exponents,0]];
perms = Permutations[exponents];
output=Apply[Plus,Map[monomial,perms]]
];
output
]


m[lambda_List]:=Apply[m, lambda]


MList[n_]:=Map[m,Partitions[n]]


MList[n_, k_]:=Map[m,Partitions[n, Rows->k]]


p0[k_Integer,n_] := Sum[x[i]^k,{i,n}]//Expand


p[list_List,n_] := Product[p0[list[[j]], n],{j,Length[list]}]//Expand


p[lambda_List]:= Apply[Times, Map[p[#]&,lambda]]


pe[n_]:=Det[PEMat[n]]


ph[n_]:=((-1)^(n-1))*Det[PHMat[n]]


PList[n_]:=Map[p,Partitions[n]]


PList[n_, k_]:=Map[p,Partitions[n, Rows->k]]


s[lambda_List]:=Apply[s, lambda]


sh[lambda_List]:=Det[JTH[lambda]]
sh[numlist__]:=sh[{numlist}]
sh[n_Integer]:=h[n]


se[lambda_List]:=Det[JTE[lambda]]
se[x:(_Integer)..]:=se[{x}]


s[lambda_List,n_] :=sh[lambda]/.h[k_]->h0[k, n]//Simplify//Expand


SList[n_]:=Map[s,Partitions[n]]


SList[n_, k_]:=Map[s,Partitions[n, Rows->k]]


ConjugateP[lambda_]:=Table[Count[lambda, x_/; (x>=i)], {i, lambda[[1]]}]


MonDegrees[f_, varlist_] := Module[{temp, temp2},
temp = CoefficientList[f,varlist];
temp2 = Position[temp,x_/;(x=!= 0),{Length[Dimensions[temp]]},Heads->False]-1;
Sort[Map[Apply[Plus,#]&,temp2]//Union, Greater]
]


XDegrees[f_]:=Module[{f1},
f1=Expand[f];
If[Head[f1]===Plus, 
Sort[Map[Apply[Plus, #]&,Map[XDegrees, Level[f1, 1]]]//Union, Greater],
If[Head[f1]===Times, Apply[Plus, Map[XDegrees, Level[f1, 1]]],
If[Head[f1]===Power, {Level[f1, 2][[-1]]},
If[Head[f1]===x, {1}, {0}]
]
]
]
]


(*Old version*)
XDegrees2[f_]:=Module[{f1},
f1=Expand[f];
If[Head[f1]===Plus, DeleteCases[Sort[Map[Apply[Plus, #]&,Map[XDegrees, Level[f1, 1]]]//Union, Greater], 0],
If[Head[f1]===Times, Apply[Plus, Map[XDegrees, Level[f1, 1]]],
If[Head[f1]===Power, {Level[f1, 2][[-1]]},
If[Head[f1]===x, {1}, 0]
]
]
]
]


SDegrees[f_]:= Module[{f1}, 
f1=Expand[f];
If[Head[f1]===Plus, Sort[Map[Apply[Plus, #]&,( Level[f, 1]/.{Times[_, s[l__]]->{l}, s[l__]->{l}})]//Union, Greater],
If[Head[f1]===Times, {Apply[Plus, (f1/.{Times[_, s[l__]]->{l}, s[l__]->{l}})]},
If[Head[f1]===s,{Apply[Plus, Level[f1, 1]]}, 0]
]
]
]


MDegrees[f_]:= Module[{f1}, 
f1=Expand[f];
If[Head[f1]===Plus, Sort[Map[Apply[Plus, #]&,( Level[f, 1]/.{Times[_, m[l__]]->{l}, m[l__]->{l}})]//Union, Greater],
If[Head[f1]===Times, {Apply[Plus, (f1/.{Times[_, m[l__]]->{l}, m[l__]->{l}})]},
If[Head[f1]===m,{Apply[Plus, Level[f1, 1]]}, 0]
]
]
]


EDegrees[f_]:=Module[{f1},
f1=Expand[f];
If[Head[f1]===Plus, DeleteCases[Sort[Map[Apply[Plus, #]&,Map[EDegrees, Level[f1, 1]]]//Union, Greater], 0],
If[Head[f1]===Times, Apply[Plus, Map[EDegrees, Level[f1, 1]]],
If[Head[f1]===Power, {Level[f1, 2][[1]]*Level[f1, 2][[-1]]},
If[Head[f1]===e, Level[f1, 1], 0]
]
]
]
]


HDegrees[f_]:=Module[{f1},
f1=Expand[f];
If[Head[f1]===Plus, DeleteCases[Sort[Map[Apply[Plus, #]&,Map[HDegrees, Level[f1, 1]]]//Union, Greater], 0],
If[Head[f1]===Times, Apply[Plus, Map[HDegrees, Level[f1, 1]]],
If[Head[f1]===Power, {Level[f1, 2][[1]]*Level[f1, 2][[-1]]},
If[Head[f1]===h, Level[f1, 1], 0]
]
]
]
]


PDegrees[f_]:=Module[{f1},
f1=Expand[f];
If[Head[f1]===Plus, DeleteCases[Sort[Map[Apply[Plus, #]&,Map[PDegrees, Level[f1, 1]]]//Union, Greater], 0],
If[Head[f1]===Times, Apply[Plus, Map[PDegrees, Level[f1, 1]]],
If[Head[f1]===Power, {Level[f1, 2][[1]]*Level[f1, 2][[-1]]},
If[Head[f1]===p, Level[f1, 1], 0]
]
]
]
]


GetCoefficients[expr_, varlist_]:=Table[((Coefficient[Expand[expr], varlist[[i]]])/._[_]->0), {i, 1, Length[varlist]}]


Unprotect[Partitions];
Options[Partitions] = {Rows->Infinity,Columns->Infinity};
Partitions[n_,opts__] := Module[{rows,cols,partitions},
rows=Rows /.{opts}/.Options[Partitions];
cols=Columns /.{opts}/.Options[Partitions];
partitions=Partitions[n];
Select[partitions,((Length[#]<=rows)&&(#[[1]]<=cols))& ]
];
Protect[Partitions];


Unprotect[SymmetricQ];
SymmetricQ[poly_,x_,n_]:=Module[{vars,k,ans=True},
vars=Table[x[k],{k,n}];
For[k=1,k<=Length[vars]-1,k++,
If[Expand[poly-(poly/.{vars[[k]]->vars[[k+1]],vars[[k+1]]->vars[[k]]})]=!=0,ans=False;Break[]];];
ans];
Protect[SymmetricQ];


Symmetrize[f_,x_,n_] := Module[{sum=0,sn},
sn = Permutations[Range[n]];
Do[
sum = sum + (f/. Table[x[i]-> x[sn[[j,i]]],{i,n}]), {j,n!}];
sum
]



Options[Restrict]={Bases->{H, E, P, S, M, X}}
Restrict[f_, n_, opts___]:=Module[{f1=Expand[f],bases, degs, i},
bases=Bases/.{opts}/.Options[Restrict];
If[MemberQ[bases, H],
degs=DeleteCases[HDegrees[f1], 0];
If[degs=!={},
For[i=1, i<=Length[degs], i++, f1=f1/.HRestrictionRules[degs[[i]], n]]
];
];
If[MemberQ[bases, P],
degs=DeleteCases[PDegrees[f1], 0];
If[degs=!={},
For[i=1, i<=Length[degs], i++, f1=f1/.PRestrictionRules[degs[[i]], n]]
];
];
If[MemberQ[bases, M],
f1=f1/.(m[l__]/;Length[{l}]>n)->0
];
If[MemberQ[bases, S],
f1=f1/.(s[l__]/;Length[{l}]>n)->0
];
If[MemberQ[bases, E],
f1=f1/.(e[a_]/;a>n)->0
];
If[MemberQ[bases, X],
f1=f1/.(x[a_]/;a>n)->0
];
f1//Expand
]


rightfunch[lambda_, i_, j_]:=Module[{k},
k=lambda[[i]]+(j-i);
If[k>0,h[k], If[k==0, 1,0]]
]
(* Private, helper function for JTH. Not meant for user use. *)


JTH[lambda_] := Table[rightfunch[lambda, i, j], {i, 1, Length[lambda]}, {j,1, Length[lambda]}]


rightfunce[lambda_, i_, j_]:=Module[{k},
k=lambda[[i]]+(j-i);
If[k>0,e[k], If[k==0, 1,0]]
]
(* Private, helper function for JTE. Not meant for user use. *)


JTE[lambda_] := Table[rightfunce[ConjugateP[lambda], i, j], {i, 1, lambda[[1]]}, {j,1, lambda[[1]]}]


K[n_] := KStar[n]//Inverse//Transpose


K[n_, k_]:=KStar[n, k]//Inverse//Transpose


KInv[n_]:=KStar[n]//Transpose


KInv[n_, k_]:=KStar[n,k]//Transpose


KTr[n_]:=KStar[n]//Inverse


KTr[n_, k_]:=KStar[n, k]//Inverse


KStar[n_]:=Module[{i, parlist},
parlist=Partitions[n];
Table[GetCoefficients[sh[parlist[[i]]], HList[n]], {i,1,PartitionsP[n]}]
]


KStar[n_, k_]:=Module[{i, parlist},
parlist=Partitions[n, Rows->k];
Table[GetCoefficients[sh[parlist[[i]]], HList[n, k]], {i, 1, Length[parlist]}]
]


ChiInv[n_]:=GetCoefficients[Map[SToP,SList[n]],PList[n]]
Chi[n_]:=Inverse[ChiInv[n]]


(*Old version*)
A2[n_]:=Product[x[i]-x[j],{i,1,n},{j,i+1,n}]
delta[n_]:=Table[n-i,{i,n}]
lambdaplusdelta[lambda_,n_]:=Table[If[i>Length[lambda],n-i,lambda[[i]]+n-i],{i,n}]
paladel[n_]:=
Table[p[Partitions[n][[j]],n]*A2[n],{j,PartitionsP[n]}]
(* Helper functions for Chi *)
Chi2[n_]:=Table[Coefficient[paladel[n],monomial[lambdaplusdelta[Partitions[n][[v]],n]]],{v,PartitionsP[n]}]


ChiInv2[n_]:=Inverse[Transpose[Chi[n]].Chi[n]].Transpose[Chi[n]]


J[n_]:= Module[{parlist,i, j},
parlist=Partitions[n];
Table[If[ConjugateP[parlist[[i]]]==parlist[[j]], 1, 0], {i, 1, PartitionsP[n]}, {j, 1, PartitionsP[n]}]
]


SToEMat[n_, k_]:=Module[{i, parlist},
parlist=Partitions[n,Rows->k];
Table[GetCoefficients[se[parlist[[i]]], EList[n, k]], {i, 1, Length[parlist]}]
]


EToSMat[n_, k_]:=SToEMat[n, k]//Inverse


HToH2Mat[deg_, var_]:=Table[GetCoefficients[HList[deg, var][[i]]/.HRestrictionRules[deg, var], HList2[deg, var]], {i, 1, Length[HList[deg, var]]}]


H2ToHMat[deg_, var_]:=HToH2Mat[deg, var]//Inverse


rightpfunce[ i_, j_]:=If[i-j>=0,If[j==1, i*e[i], e[i-j+1]], If[i-j==-1, 1, 0]]
(* Private, helper function for PEMat. Not meant for user use. *)


PEMat[n_] := Table[rightpfunce[i, j], {i, 1, n}, {j,1, n}]


rightpfunch[ i_, j_]:=If[i-j>=0,If[j==1, i*h[i], h[i-j+1]], If[i-j==-1, 1, 0]]
(* Private, helper function for PHMat. Not meant for user use. *)


PHMat[n_] := Table[rightpfunch[i, j], {i, 1, n}, {j,1, n}]


EPMat[n_] := Table[If[i-j>=0, p[i-j+1], If[i-j==-1, i, 0]], {i, 1, n}, {j, 1 , n}]


EHMat[n_] := Table[If[j-i>=0, h[-i+j+1], If[j-i==-1, 1, 0]], {i, 1, n}, {j, 1 , n}]


HPMat[n_] := Table[If[i-j>=0, p[i-j+1], If[i-j==-1,- i, 0]], {i, 1, n}, {j, 1 , n}]


HEMat[n_] :=  Table[If[j-i>=0, e[-i+j+1], If[j-i==-1, 1, 0]], {i, 1, n}, {j, 1 , n}]


NumberOfVars[f_]:=
Max[Extract[f,Position[f,x[_]]]/. x[k_]->k]


(*Old version - has bugs*)
NumberOfVars0[f_]:=Module[{f1, lev},
f1=Expand[f];
lev=Level[f1, 1];
If[Head[f1]===Plus||Head[f1]===Times, Max[Map[NumberOfVars, lev]],
If[Head[f1]===x, lev[[1]], 0]
]
]


XToMRules[n_]:=XToMRules[n]=Module[{atab, pata},
atab=Table[Unique["a"], {n}];
pata=Map[Optional[Pattern[#, Blank[]]]&, atab];
If[n==0, {x[_]->0},
Flatten[Append[{(x[j_]/;j>n)->0, c_. Product[(x[i]^pata[[i]]), {i, 1, n}]/;(Apply[GreaterEqual, Table[atab[[i]], {i, 1, n}]]//Evaluate)->c m[Table[atab[[i]], {i, 1, n}]]}, XToMRules[n-1]]]
]
]


XToM[f_]:=Expand[f]/.XToMRules[NumberOfVars[f]]/.{x[_]->0}


XToH[f_] := MToH[f//XToM,Vars->NumberOfVars[f]]
XToE[f_] := MToE[f//XToM,Vars->NumberOfVars[f]]
XToP[f_] := MToP[f//XToM,Vars->NumberOfVars[f]]
XToS[f_] := MToS[f//XToM,Vars->NumberOfVars[f]]
XToAll[f_] := MToAll[f//XToM,Vars->NumberOfVars[f]]


Options[SToH]={DegreeList->{}, Vars->0};
SToH[f_, opts___] := Module[{i, degs, n1},
n1=Vars/.{opts}/.Options[SToH];
If[n1== 0, Expand[(Expand[f]/.s->sh)],
degs=DegreeList/.{opts}/.Options[SToH];
If[degs==={}, degs=SDegrees[f]];
Expand[Expand[(Expand[f]/.s->sh)]/.Flatten[Table[HRestrictionRules[degs[[i]], n1], {i, 1, Length[degs]}]]]
]
]


Options[SToE]={DegreeList->{}, Vars->0};SToE[f_, opts___] := Module[{n1},
n1=Vars/.{opts}/.Options[SToE];
If[n1==0, Expand[(Expand[f]/.s->se)],
Expand[(Expand[f]/.s->se)]/.{(e[a_]/;a>n1)->0}]
]


Options[SToM]={DegreeList->{}, Vars->0};SToM[f_, opts___] := Module[{i,degs, n1},
degs= DegreeList/.{opts}/.Options[SToM];
n1=Vars/.{opts}/.Options[SToM];
If[degs==={}, degs=SDegrees[f]];
If[n1== 0, Sum[Dot[Dot[GetCoefficients[f, SList[degs[[i]]]],K[degs[[i]]]], MList[degs[[i]]]], {i, 1, Length[degs]}],
 Sum[Dot[Dot[GetCoefficients[f, SList[degs[[i]], n1]],K[degs[[i]], n1]], MList[degs[[i]], n1]], {i, 1, Length[degs]}]]
]


Options[SToP]={DegreeList->{}, Vars->0};SToP[f_,opts___]:= Module[{n1},
n1=Vars/.{opts}/.Options[SToP];
If[n1== 0,EToP[SToE[f]],
EToP[SToE[f], opts]]
]


SToX[f_,n_]:=Expand[f]//.{s->sh, h[k_]->h0[k, n]}//Expand


Options[SToAll]={Targets->{E,P,H,M, X}, Vars->0};SToAll[f_,opts___]  := Module[{targets,out={f}, n},
targets =  Targets/.{opts}/.Options[SToAll];
n=Vars/.{opts}/.Options[SToAll];
If[n==0,
If[MemberQ[targets,E],AppendTo[out,SToE[f]]];
If[MemberQ[targets,H],AppendTo[out,SToH[f]]];
If[MemberQ[targets,P],AppendTo[out,SToP[f]]];
If[MemberQ[targets,M],AppendTo[out,SToM[f]]];,
(* else *)
If[MemberQ[targets,E],AppendTo[out,SToE[f, Vars->n]]];
If[MemberQ[targets,H],AppendTo[out,SToH[f, Vars->n]]];
If[MemberQ[targets,P],AppendTo[out,SToP[f, Vars->n]]];
If[MemberQ[targets,M],AppendTo[out,SToM[f, Vars->n]]];
If[MemberQ[targets,X],AppendTo[out,SToX[f, n]]];
];
out
]


PRestrictionRules[deg_, var_]:=PRestrictionRules[deg, var]=Module[{pl=PList[deg], plr=PList[deg, var]},
Table[pl[[i]]->EToP[PToE[pl[[i]], Vars->var]], {i, 1, Length[pl]}]
]


Options[PToH]={DegreeList->{}, Vars->0};PToH[f_, opts___]:=Module[{n1, degs, i},
n1=Vars/.{opts}/.Options[PToH];
If[n1==0, Expand[(Expand[f]/.p->ph)], 
(*else*)
 degs= DegreeList/.{opts}/.Options[PToH];
If[degs==={}, degs=PDegrees[f]];
Expand[Expand[(Expand[f]/.p->ph)]/.Flatten[Table[HRestrictionRules[degs[[i]], n1], {i, 1, Length[degs]}]] ]
]
]


Options[PToE]={DegreeList->{}, Vars->0};PToE[f_, opts___]:=Module[{n1},
n1=Vars/.{opts}/.Options[PToE];
If[n1==0, Expand[(Expand[f]/.p->pe)], 
Expand[(Expand[f]/.p->pe)]/.{(e[a_]/;a>n1)->0}]
]


Options[PToM]={DegreeList->{}, Vars->0};PToM[f_, opts___]:=HToM[PToH[f], opts]


Options[PToS]={DegreeList->{}, Vars->0};PToS[f_,opts___]:= EToS[PToE[f], opts]


PToX[f_, n_]:=Expand[f]/.p[k_]->p[{k}, n]//Expand 


Options[PToAll]={Targets->{E,H,S,M, X}, Vars->0};PToAll[f_,opts___]  := Module[{targets,out={f}, n},
targets =  Targets/.{opts}/.Options[PToAll];
n=Vars/.{opts}/.Options[PToAll];
If[n==0,
If[MemberQ[targets,E],AppendTo[out,PToE[f]]];
If[MemberQ[targets,H],AppendTo[out,PToH[f]]];
If[MemberQ[targets,S],AppendTo[out,PToS[f]]];
If[MemberQ[targets,M],AppendTo[out,PToM[f]]];,
(* else *)
If[MemberQ[targets,E],AppendTo[out,PToE[f, Vars->n]]];
If[MemberQ[targets,H],AppendTo[out,PToH[f, Vars->n]]];
If[MemberQ[targets,S],AppendTo[out,PToS[f, Vars->n]]];
If[MemberQ[targets,M],AppendTo[out,PToM[f, Vars->n]]];
If[MemberQ[targets,X],AppendTo[out,PToX[f, n]]];
];
out
]


Options[MToH]={DegreeList->{}, Vars->0};MToH[f_, opts___] :=Module[{i, degs, n1},
degs= DegreeList/.{opts}/.Options[MToH];
n1=Vars/.{opts}/.Options[MToH];
If[degs==={}, degs=MDegrees[f]];
If[n1== 0,Sum[Dot[Dot[GetCoefficients[f, MList[degs[[i]]]],Dot[KInv[degs[[i]]], KStar[degs[[i]]]]], HList[degs[[i]]]], {i, 1, Length[degs]}],Sum[Dot[Dot[GetCoefficients[f, MList[degs[[i]], n1]],Dot[KInv[degs[[i]], n1], KStar[degs[[i]], n1]]], HList[degs[[i]], n1]], {i, 1, Length[degs]}] 
]
]


Options[MToE]={DegreeList->{}, Vars->0}; MToE[f_, opts___] := Module[{i, degs, n1},
degs= DegreeList/.{opts}/.Options[MToE];
n1=Vars/.{opts}/.Options[MToE];
If[degs==={}, degs=MDegrees[f]];
If[n1== 0,Sum[Dot[Dot[GetCoefficients[f, MList[degs[[i]]]],Dot[KInv[degs[[i]]], Dot[J[degs[[i]]], KStar[degs[[i]]]]]], EList[degs[[i]]]], {i, 1, Length[degs]}], 
Sum[Dot[Dot[GetCoefficients[f, MList[degs[[i]], n1]],Dot[KInv[degs[[i]], n1], SToEMat[degs[[i]], n1]]], EList[degs[[i]], n1]], {i, 1, Length[degs]}] ]
]


Options[MToP]={DegreeList->{}, Vars->0};MToP[f_, opts___]:=HToP[MToH[f], opts]


Options[MToS]={DegreeList->{}, Vars->0}; MToS[f_, opts___] :=Module[{i, degs, n1},
degs= DegreeList/.{opts}/.Options[MToS];
n1=Vars/.{opts}/.Options[MToS];
If[degs==={}, degs=MDegrees[f]];
If[n1== 0,Sum[Dot[Dot[GetCoefficients[f, MList[degs[[i]]]],KInv[degs[[i]]]], SList[degs[[i]]]], {i, 1, Length[degs]}], 
Sum[Dot[Dot[GetCoefficients[f, MList[degs[[i]], n1]],KInv[degs[[i]], n1]], SList[degs[[i]], n1]], {i, 1, Length[degs]}] ]
]


(* Old version *)
mxlist[degree_,n_]:=Map[m[#,n]&,Partitions[degree]]
MToX[f_,n_]:=
Module[{temp1=MDegrees[f]},
Apply[Plus,Table[GetCoefficients[f,MList[temp1[[i]]]].mxlist[temp1[[i]],n],{i,Length[temp1]}]]//Expand
]


Options[MToAll]={Targets->{E,P,S,H, X}, Vars->0};MToAll[f_,opts___]  := Module[{targets,out={f}, n},
targets =  Targets/.{opts}/.Options[MToAll];
n=Vars/.{opts}/.Options[MToAll];
If[n==0,
If[MemberQ[targets,E],AppendTo[out,MToE[f]]];
If[MemberQ[targets,P],AppendTo[out,MToP[f]]];
If[MemberQ[targets,S],AppendTo[out,MToS[f]]];
If[MemberQ[targets,H],AppendTo[out,MToH[f]]];,
(* else *)
If[MemberQ[targets,E],AppendTo[out,MToE[f, Vars->n]]];
If[MemberQ[targets,P],AppendTo[out,MToP[f, Vars->n]]];
If[MemberQ[targets,S],AppendTo[out,MToS[f, Vars->n]]];
If[MemberQ[targets,H],AppendTo[out,MToH[f, Vars->n]]];
If[MemberQ[targets,X],AppendTo[out,MToX[f, n]]];
];
out
]


Options[EToH]={DegreeList->{}, Vars->0}; EToH[f_, opts___] := Module[{i, n1, degs},
n1=Vars/.{opts}/.Options[EToH];
If[n1== 0,Expand[(Expand[f]/.e->eh)],
(*else*)
 degs= DegreeList/.{opts}/.Options[EToH];
If[degs==={}, degs=EDegrees[f]];
Expand[Expand[(Expand[f]/.e->eh)]/.Flatten[Table[HRestrictionRules[degs[[i]], n1], {i, 1, Length[degs]}]]]
]
]


 Options[EToM]={DegreeList->{}, Vars->0};EToM[f_, opts___] := Module[{i, n1, degs},
n1=Vars/.{opts}/.Options[EToM];
degs=DegreeList/.{opts}/.Options[EToM];
If[degs==={}, degs=EDegrees[f]];
If[n1== 0,Sum[Dot[Dot[GetCoefficients[f, EList[degs[[i]]]],Dot[KTr[degs[[i]]], Dot[J[degs[[i]]], K[degs[[i]]]]]], MList[degs[[i]]]], {i, 1, Length[degs]}], 
Sum[Dot[Dot[GetCoefficients[f, EList[degs[[i]], n1]],Dot[EToSMat[degs[[i]], n1], K[degs[[i]], n1]]], MList[degs[[i]], n1]], {i, 1, Length[degs]}] ]
]


Options[EToP]={DegreeList->{}, Vars->0}; EToP[f_, opts___] := Module[{i, n1, degs},
n1=Vars/.{opts}/.Options[EToP];
If[n1== 0,Expand[(Expand[f]/.e->ep)],
(*else*)
 degs= DegreeList/.{opts}/.Options[EToP];
If[degs==={}, degs=EDegrees[f]];
Expand[Expand[(Expand[f]/.e->ep)]/.Flatten[Table[PRestrictionRules[degs[[i]], n1], {i, 1, Length[degs]}]]]
]
]


Options[EToS]={DegreeList->{}, Vars->0};EToS[f_, opts___] :=  Module[{i, n1, degs},
n1=Vars/.{opts}/.Options[EToS];
degs= DegreeList/.{opts}/.Options[EToS];
If[degs==={}, degs=EDegrees[f]];
If[n1== 0,Sum[Dot[Dot[GetCoefficients[f, EList[degs[[i]]]],Dot[KTr[degs[[i]]], J[degs[[i]]]]], SList[degs[[i]]]], {i, 1, Length[degs]}], 
Sum[Dot[Dot[GetCoefficients[f, EList[degs[[i]], n1]],EToSMat[degs[[i]], n1]], SList[degs[[i]], n1]], {i, 1, Length[degs]}] ]
]


EToX[f_, n_] :=  Expand[f]/.e[l_]->e0[l, n]//Expand


Options[EToAll]={Targets->{H,P,S,M, X}, Vars->0};EToAll[f_,opts___]  := Module[{targets,out={f}, n},
targets =  Targets/.{opts}/.Options[EToAll];
n=Vars/.{opts}/.Options[EToAll];
If[n==0,
If[MemberQ[targets,H],AppendTo[out,EToH[f]]];
If[MemberQ[targets,P],AppendTo[out,EToP[f]]];
If[MemberQ[targets,S],AppendTo[out,EToS[f]]];
If[MemberQ[targets,M],AppendTo[out,EToM[f]]];,
(* else *)
If[MemberQ[targets,H],AppendTo[out,EToH[f, Vars->n]]];
If[MemberQ[targets,P],AppendTo[out,EToP[f, Vars->n]]];
If[MemberQ[targets,S],AppendTo[out,EToS[f, Vars->n]]];
If[MemberQ[targets,M],AppendTo[out,EToM[f, Vars->n]]];
If[MemberQ[targets,X],AppendTo[out,EToX[f, n]]];
];
out
]


HRestrictionRules[deg_, var_]:=HRestrictionRules[deg, var]=Module[{hl=HList[deg], hlr=HList[deg, var]},
Table[hl[[i]]->EToH[HToE[hl[[i]], Vars->var]], {i, 1, Length[hl]}]
]


Options[HToE]={DegreeList->{}, Vars->0};HToE[f_, opts___] :=  Module[{n1},
n1=Vars/.{opts}/.Options[HToE];
If[n1== 0,Expand[(Expand[f]/.h->he)],
 Expand[(Expand[f]/.h->he)]/.{(e[a_]/;a>n1)->0}]
]


Options[HToM]={DegreeList->{}, Vars->0};HToM[f_, opts___] := Module[{i, n1, degs},
n1=Vars/.{opts}/.Options[HToM];
degs= DegreeList/.{opts}/.Options[HToM];
If[degs==={}, degs=HDegrees[f]];
If[n1== 0,Sum[Dot[Dot[GetCoefficients[f, HList[degs[[i]]]],Dot[KTr[degs[[i]]],K[degs[[i]]]]], MList[degs[[i]]]], {i, 1, Length[degs]}], 
Sum[Dot[Dot[Dot[GetCoefficients[Expand[Expand[f]/.HRestrictionRules[degs[[i]], n1]], HList2[degs[[i]], n1]], H2ToHMat[degs[[i]], n1]],Dot[KTr[degs[[i]], n1],K[degs[[i]], n1]]], MList[degs[[i]], n1]], {i, 1, Length[degs]}] ]
]


Options[HToP]={DegreeList->{}, Vars->0};HToP[f_, opts___] := Module[{i, n1, degs},
n1=Vars/.{opts}/.Options[HToP];
If[n1== 0,Expand[(Expand[f]/.h->hp)],
(*else*)
 degs= DegreeList/.{opts}/.Options[HToP];
If[degs==={}, degs=HDegrees[f]];
Expand[Expand[(Expand[f]/.h->hp)]/.Flatten[Table[PRestrictionRules[degs[[i]], n1], {i, 1, Length[degs]}]]]
]
]


Options[HToS]={DegreeList->{}, Vars->0};HToS[f_, opts___] := Module[{i, n1, degs},
n1=Vars/.{opts}/.Options[HToS];
degs= DegreeList/.{opts}/.Options[HToS];
If[degs==={}, degs=HDegrees[f]];
If[n1== 0,Sum[Dot[Dot[GetCoefficients[f, HList[degs[[i]]]],KTr[degs[[i]]]], SList[degs[[i]]]], {i, 1, Length[degs]}], 
Sum[Dot[Dot[Dot[GetCoefficients[Expand[Expand[f]/.HRestrictionRules[degs[[i]], n1]], HList2[degs[[i]], n1]], H2ToHMat[degs[[i]], n1]],KTr[degs[[i]], n1]], SList[degs[[i]], n1]], {i, 1, Length[degs]}]
]
]


HToX[f_, n_]:=Expand[f]/.h[k_]->h0[k, n]//Expand


Options[HToAll]={Targets->{E,P,S,M, X}, Vars->0};HToAll[f_,opts___]  := Module[{targets,out={f}, n},
targets =  Targets/.{opts}/.Options[HToAll];
n=Vars/.{opts}/.Options[HToAll];
If[n==0,
If[MemberQ[targets,E],AppendTo[out,HToE[f]]];
If[MemberQ[targets,P],AppendTo[out,HToP[f]]];
If[MemberQ[targets,S],AppendTo[out,HToS[f]]];
If[MemberQ[targets,M],AppendTo[out,HToM[f]]];,
(* else *)
If[MemberQ[targets,E],AppendTo[out,HToE[f, Vars->n]]];
If[MemberQ[targets,P],AppendTo[out,HToP[f, Vars->n]]];
If[MemberQ[targets,S],AppendTo[out,HToS[f, Vars->n]]];
If[MemberQ[targets,M],AppendTo[out,HToM[f, Vars->n]]];
If[MemberQ[targets,X],AppendTo[out,HToX[f, n]]];
];
out
]


incr[lam_,set_] :=Module[{temp=lam}, Map[(temp[[#]]++)&,set];temp]
DecreasingQ[lambda_]:= Apply[GreaterEqual, lambda]
AddByRows[par_,k_] := Module[{pp,sets,raw, temp},
pp =Join[par,Table[0,{k}]];
sets = KSubsets[Range[Length[pp]],k];
raw=Table[incr[pp,sets[[i]]],{i,Length[sets]}];
temp=Select[raw, DecreasingQ];
Map[Select[#,Positive]&,temp]
]
(*Helper functions for Pieri*)
Pieri[lambda_,k_]:=
Map[ConjugateP,AddByRows[ConjugateP[lambda],k]]//Union
SMult[lambda_,n_]:=
Apply[Plus,Map[s,Pieri[lambda,n]]]


Yamanouchi[t_] := Table[Position[t,i][[1,1]],{i,Length[Flatten[t]]}]


Tableaux2[list_List]:=If[list!={1},Tableaux[list],{{{1}}}]


LatticePerms[type_] := Map[Yamanouchi,Tableaux2[type]]


SumFirstJ[lambda_,mu_,j_] := Sum[lambda[[i]]-mu[[i]],{i,j}]


SkewShapeX[lambda_,mu_]:= Module[{j},
Table[PadRight[Table[x[i],{i,SumFirstJ[lambda,mu,j-1]+lambda[[j]]-mu[[j]],SumFirstJ[lambda,mu,j-1]+1,-1}],lambda[[1]],0,mu[[j]]],{j,Length[lambda]}]
]


XLattice[nu_List]:=Module[{perms=LatticePerms[nu]},
Table[x[i]->perms[[j,i]],{j,Length[perms]},{i,Apply[Plus,nu]}]]


AllNonNegQ[list_] := Apply[And,Map[NonNegative,list]]


AllGreaterEqual[list1_,list2_] := If[Length[list1]<Length[list2],False,
AllNonNegQ[list1-PadRight[list2,Length[list1]]]]


MuFitPartitions[n_Integer,mu_List] := Module[{par=Partitions[n]},
Select[Table[If[Length[par[[j]]]>=Length[mu]&&AllGreaterEqual[par[[j]],mu],par[[j]]],{j,1,Length[par]}],AllNonNegQ]
]


SChoices[mu_List,nu_List]:=Module[{lambdasize=Apply[Plus,mu]+Apply[Plus,nu]},
Map[Apply[s,#]&,MuFitPartitions[lambdasize,mu]]
]


Pad[mu_,n_]:=PadRight[mu,n]


AllSkewShapeX[lambdasize_Integer,mu_List]:=Module[{tpart=MuFitPartitions[lambdasize,mu]},
Table[SkewShapeX[tpart[[i]],Pad[mu,Length[tpart[[i]]]]],{i,Length[tpart]}]]


SSTQ[tab_] := Module[{rowsQ,colsQ},
rowsQ=Apply[And,Map[Apply[LessEqual,Select[#,Positive]]&,tab]];
colsQ=Apply[And,Map[Apply[Less,Select[#,Positive]]&,tab//Transpose]];
rowsQ&&colsQ
]


AllSkewShapeLattice[mu_,nu_]:=
Module[{lambdasize=Apply[Plus,mu]+Apply[Plus,nu],temp},
temp=AllSkewShapeX[lambdasize,mu];
Table[temp[[i]]/.XLattice[nu],{i,Length[temp]}]]


SelectSSTCases[mu_,nu_]:=
Module[{largelist=AllSkewShapeLattice[mu,nu]},
Table[Select[largelist[[i]],SSTQ],{i,Length[largelist]}]]


CoeffLambdas[mu_,nu_]:= Map[Length,SelectSSTCases[mu,nu]]


LRProduct[mu_,nu_] := CoeffLambdas[mu,nu].SChoices[mu,nu]


s[x__]s[y__]^:=LRProduct[{x},{y}]


Unprotect[Plus];
n_ (s[x__]+s[y__])^:=n*s[x]+n*s[y]
Protect[Plus];


s[x__]^n_^:=Apply[Times,Table[s[x],{n}]]//Expand