Sympol$Examples.nb 
Companion file illustrating the SymPol$Package
Version 1.0 (September 8, 2018)
Version 1.1 (September 15, 2018)
Version 1.2 (September 28, 2018)
Version 1.3 (December 18, 2018)
Robert Coquereaux

This file displays examples that can be run by using the package SymPolPackage`
For the next command (<<) to work,  put the package file SymPolPackage.wl in the directory user/Library/Mathematica/Applications , or use the syntax Get[“Sympol$Package”] with an appropriate path.
Evaluate the following command :

<<SymPol$Package`

(* Get["Sympol$Package"] *)

Disclaimer

This package should be considered as a private document made available on line by its author.
The code can be freely downloaded but it is provided “as is” without warranty of any kind about its reliability.

Caveats

The functions defined in this package are usually not protected against the use of incorrect arguments.
If an input does not follow the syntax precisely described in the usage command, strange (and incorrect) results can appear.

Some commands may take a lot of time :  
For instance, using version 1.0 (as of sept 2018),  the decomposition on the  basis of zonal polynomials of the square of the 3-variables zonal polynomials associated with the integer partition {2t,t} takes respectively about (0.3s, 4s, 38s, 190s, 590s, 1700s} for t in {1,2, 3,4,5,6}.

Such computations may also easily exhaust the available memory.

The underlying philosophy was to perform calculations for Jack polynomials and recover the results for Schur, Zonal, etc, as particular cases.
Admittedly, for some specific problems (for instance the calculation of structure constants aka Littlewood-Richardson coefficients), and especially in the case of Schur polynomials,  other algorithms, much faster (using honeycombs for instance) do exist.

Criticisms and suggestions are welcome : send a note to robert.coquereaux@gmail.com

About Context, the attribute Protect, and a modified TraditionalForm  for declared indexed variables x, e, p

A number of symbols exported by the package SymPolPackage are protected (see the Readme below). 
The symbols $x, $e, $p, $y, $u that are also protected, are used as $x[j], $e[j], $p[j], $y[j],  $u[j] where j is some integer, can be printed as indexed strings (Subscript[x, j]) , etc by using a modified TraditionalForm  (see examples below).

Readme

About Context

$Context

$ContextPath

Context[$α]

Names["SymPol$Package`*"]

The symbols $x,$e,$p,$α,$m,$s,$y,$u,ZJ,ZC,ZP,JJ,JC,JP  are defined in the SymPolPackage` that comes before Global` in the $ContextPath

To prevent possible mistakes, we protect those symbols :  this is done in the file SymPolPackage.wl , after the EndPackage[]

If the value of $α (in the context SymPolPackage) has to be set in some expression, use a rule rather than Set (=).  See the example below.

$α=2;(* this generates a message *)
1+$α

1+$α /. {$α->2}

About the modified format of $x[j], e[j] and p[j]

By default the multivariate symmetric polynomials used in this file are polynomials in the variables $x[1], $x[2], ...
Sometimes, it may be nice to have a result expressed in terms of indexed variables instead.
The $x[j] are defined in such a way that their TraditionalForm is modified by a Format.
Same thing for $α : its TraditionalForm prints as α
See the example below.

$x[3]

$x[3]//TraditionalForm

%//InputForm

%

2 $α^3

%//TraditionalForm

% (* but it is still the same ! *)

Analoguous comments can be made for the elementary symmetric polynomials $e[j] and the power sums $p[j]
Remember also that $x, $e, $p, $y, $u, $α and a few other symbols  defined in the Context SymPolPackage are protected :

With[{sb=Names["SymPol$Package`*"]},Extract[sb,Position[Map[Attributes,sb],{Protected}]]]

Essentials : basic commands

Protected symbols and modified TraditionalForm (suppress $ in output)

{$x[2], $e[2], $p[3], $m[{5,2}],$s[{2,1}]}//TraditionalForm

Standard symmetric polynomials

elementarySum[3,4]
toElementarySymPol[%]

monomialSum[{3,2}]
toMonomialSymPol[%]

completeSum[{2,1}]

powerSum[4,3]
%//toElementarySymPol// toPowerSums //Simplify

Jack polynomials

toPol[JP[{2,1,0}],3]//Simplify//Expand//TraditionalForm

toPol[JJ[{2,1,0}],3]//Simplify//Expand//TraditionalForm

toPol[JC[{2,1,0}],3]//Simplify//TraditionalForm

Jack polynomials : structure constants

toJackPProductPair[{2,1,1},{3,2,0}]//Simplify//TraditionalForm

toJackJProductPair[{2,1,1},{3,2,0}]//Simplify//TraditionalForm

toJackCProductPair[{2,1,1},{3,2,0}]//Simplify//TraditionalForm

Schur polynomials

toPol[$s[{2,1,0}],3]//TraditionalForm

Schur polynomials : structure constants

toSchurProductPair[{2,1,1},{3,2,0}]//TraditionalForm

Zonal polynomials

toPol[ZP[{2,1,0}],3]//TraditionalForm

toPol[ZJ[{2,1,0}],3]//TraditionalForm

toPol[ZC[{2,1,0}],3]//TraditionalForm

Zonal polynomials : structure constants

toZonalPProductPair[{2,1,1},{3,2,0}]//TraditionalForm

toZonalJProductPair[{2,1,1},{3,2,0}]//TraditionalForm

toZonalCProductPair[{2,1,1},{3,2,0}]//TraditionalForm

Quaternionic polynomials

toPol[QP[{2,1,0}],3]//TraditionalForm

toPol[QJ[{2,1,0}],3]//TraditionalForm

toPol[QC[{2,1,0}],3]//TraditionalForm

Quaternionic polynomials : structure constants

toQuaterPProductPair[{2,1,1},{3,2,0}]

toQuaterJProductPair[{2,1,0},{2,1,0}]

toQuaterJProductPair[{2,1,1},{3,2,0}]

toQuaterCProductPair[{2,1,1},{3,2,0}]

Conversions 
In the following commands one can replace “Jack” by “Schur” or “Zonal” or “Quater” ,  and “J” by “C” or “P” for the other types :

JackPtoMonomialSymPol[{3,2,1}]//TraditionalForm
(* replace "Jack" by "Schur" or "Zonal" or "Quater" , and "J" by "C" or "P" for the other types *)

JackJtoElementarySymPol[{3,2,1}]//TraditionalForm

JackPtoPowerSum[{3,2,1}]//TraditionalForm

From zonal or Schur polynomials to Weyl or zonal characters
Here arguments are not partitions but Dynkin labels

SchurToSUnCharPol[{1,1}]//Expand//TraditionalForm (* Laurent polynomial: recognise the Weyl character of the adjoint representation of the Lie group SU(3) *)
SchurToSUnCharTrigo[{1,1}] (* Trigonometric version: recognise the Weyl character of the adjoint representation of the Lie algebra su(3) *)

ZonalPToSUnCharPol[{1,1}]//Expand//TraditionalForm (* Laurent polynomial: SU(3) zonal character for the adjoint representation of the Lie group SU(3) *)
ZonalPToSUnCharTrigo[{1,1}] (* Trigonometric version: this defines the zonal character for the adjoint representation of the Lie algebra su(3) *)

Evaluation subtleties

ZonalPolP[{2,2}]//Expand (* Extended partition of length 2 : Two-variables *)
ZonalPolP[{2,2,0}]//Expand(* Extended partition of length 3 : Three-variables *)

ZP[{2,2}](* Evaluates to itself *)

toPol[ZP[{2,2}],3](* toPol evaluates the first argument with a number of variables given by the last argument *)

toPol[ZP[{2,2}]](* If absent, the number of variables in toPol is the length of the partition *)

toPol[ZonalPolP[{2,2}]]//Expand (* toPol can be used on a function like ZonalPolP which already returns a polynomial, but the number of variables is fixed by the last argument of toPol *) 
toPol[ZonalPolP[{2,2}],3]//Expand

The evaluation of toPol[a_polynomial], when it is evaluated for the first time,  is usually faster than the evaluation of a_polynomial itself.
However, if a_polynomial is re-evaluated, the time taken by the evaluation is extremely short (shorter than the time taken for the evaluation of Pol[a_polynomial]).
The reason is that many functions (like ZonalPolP) store the obtained results; the drawback is that this operation uses the memory.

Moreover, in most cases the syntax toPol[ZP[{6,4,4}],3] should be used, in lieu of  ZonalPolP[{6,4,4}, because a toPol often performs a simplifying shift on the partition (compensated by appropriate pre-factors).
For instance toPol[ZP[{6,4,4}],3] does not take much time (it calls and stores the result of ZonalPolP[{2,0,0}={6,4,4}-{4,4,4}]) but the direct evaluation of ZonalPolP[{6,4,4}] is quite long.
This effect is quite noticeable if the partition is large (using a direct call to a function like ZonalPolP can even make the kernel crash in such case).

(* Comparing speeds for small partitions: *)

Timing@toPol[ZP[{2,2,2,1}],4](* first time *)

Timing@toPol[ZP[{2,2,2,1}],4](* second time *)

Timing@ZonalPolP[{2,2,2,1}]//Expand(* first time *)

Timing@ZonalPolP[{2,2,2,1}]//Expand(* second time *)

(* Comparing speeds for large partitions: *)

Timing@toPol[ZP[{6,4,4}],3]//Expand(* first time *)

Timing@ZonalPolP[{6,4,4}]//Expand(* first time *)

Timing@ZonalPolP[{6,4,4}]//Expand(* second time *)

Jack inner product :

JackScalarProduct[JJ[{2,1,1}]*JJ[{2,1,1}],JJ[{2,2,2,1,1}],Infinity, $α]//Factor//TraditionalForm (* better to use that one *)

JackScalarProduct[JackPolJ[{2,1,1}]*JackPolJ[{2,1,1}],JackPolJ[{2,2,2,1,1}],Infinity, $α]//Factor//TraditionalForm

stableNormSqOfJackP[{2,1,1},a]//Factor//TraditionalForm
%/. a-> 2
JackScalarProduct[ZonalPolP[{2,1,1}],ZonalPolP[{2,1,1}],Infinity,$α]/. $α->2 //Factor

JackScalarProduct[$s[{3,1}],$s[{3,1}],Infinity,$α]/. $α->1

JackScalarProduct[JP[{2,1,1}],JP[{2,1,1}],Infinity, $α]//Simplify

JackScalarProduct[$m[{2,1,1}],$m[{3,1}],Infinity,a]//Factor//TraditionalForm 
JackScalarProduct[monomialSum[{2,1,1}],monomialSum[{3,1}],Infinity,a]//Factor//TraditionalForm

JackScalarProduct[ZonalPolP[{2,1,1}],ZonalPolP[{2,1,1}],$x,$α](* Warning *)

JackScalarProduct[ZonalPolP[{2,1,1,0}],ZonalPolP[{2,1,1,0}],$x,$α]//Simplify(* stabilization *)

JackScalarProduct[ZP[{2,1,1}],ZP[{2,1,1}],Infinity, $α]//Simplify

Macdonald inner product

MacdonaldScalarProduct[ZP[{3,2,2}],ZP[{3,2,2}],2]

Table[MacdonaldScalarProduct[ZP[PadRight[{3,2,1},n,0]],ZP[PadRight[{3,2,1},n,0]],2]/( coefDyson[n,2]),{n,310,315}]//N
JackScalarProduct[ZonalPolP[{3,2,1}],ZonalPolP[{3,2,1}],Infinity,2]
%//N

General symmetric polynomials

Young partitions and monomials - Variables are $x[j]

Usage

?monomial

?myCompositions

?ExtendedYoungPartitions

?restrictPartition

?extendPartition

?highestWeightToYoungPartition

?highestWeightToYoungPartition

?highestWeightToExtendedYoungPartition

?youngPartitionToHighestWeight

?ConjugatePartition

?horizontalStripSkewPartitions

?tableauCoordinates

?hook

?lowerhook

?upperhook

?jcoef

?ptojcoef

?ptoccoef

?jtoccoef

?cjames

Examples

Table[$x[j],{j,1,5}]

monomial[{3,2,5}](* The variables (default) are denoted $x[j] *)

%//TraditionalForm(* modified Format prints $x[j] as (Subscript[x, j]) *)

IntegerPartitions[5](* defined in Mathematica *)

IntegerPartitions[5,2](* defined in Mathematica *)

myCompositions[5,3](* This is my version of Compositions[5,3] that was defined in the old package Combinatorica *)

ExtendedYoungPartitions[5,3]

ExtendedYoungPartitions[5](* the default *)

restrictPartition[{3,2,1,0,0}]

extendPartition[{2,2,1}](* extends an integer partition : the default number of variables is the total of the partition *)

extendPartition[{2,2,1,0}](* extends an extended partition *)

extendPartition[{2,2,1,0,0,0,0}](* extends (in this case restricts) an extended partition *)

extendPartition[{2,2,1,0,0,0,0},4](* extends (actually restricts in this case) an extended partition *)

?highestWeightToYoungPartition

highestWeightToYoungPartition[{1,2,0,0}]

extendPartition@highestWeightToYoungPartition[{1,2,0,0}]

highestWeightToYoungPartition[{1,2,0,1}]

extendPartition@highestWeightToYoungPartition[{1,2,0,1}](* since it is extended by extendPartition the length is the total of the partition *)

?highestWeightToExtendedYoungPartition

highestWeightToExtendedYoungPartition[{1,2,0,1}]

youngPartitionToHighestWeight[{2,1},3]

youngPartitionToHighestWeight[{2,0,0},3]

youngPartitionToHighestWeight[{2,1,0,0},3]

ConjugatePartition[{4,1}]

horizontalStripSkewPartitions[{5}]

horizontalStripSkewPartitions[{2,1}]

horizontalStripSkewPartitions[{4,2,1}]

horizontalStripSkewPartitions[{8,6,5,2}]

tableauCoordinates[{4,3,2}]

hook[{4,2,1},1,2]

upperhook[{4,2,1},1,2,$α]

lowerhook[{4,2,1},1,2,$α]

jcoef[{4,2,1},$α]
ptojcoef[{4,2,1},$α]
ptoccoef[{4,2,1},$α]
jtoccoef[{4,2,1},$α]
cjames[{4,2,1},$α]

Use a rule to assign a value to $α :

%/. {$α->2}

(cjames[{5,5,3,3,3,2,2,1,1},$α]/. {$α->2}) ==cjames[{5,5,3,3,3,2,2,1,1}]

Remark (Mathematica predefined commands)

It is useful to remember the following pre defined functions in Mathematica

IntegerPartitions[5]

IntegerPartitions[5,2]

Table[Length@IntegerPartitions[j],{j,1,20}]

Table[PartitionsP[k],{k,1,20}]

Remark :

Table[SeriesCoefficient[q^(1/24)/DedekindEta[Log[q]/(2 Pi I)],{q,0,n}],{n,1,20}]

Elementary symmetric polynomials $e[j] and elementarySum[partition]

Usage

?elementarySum

?tableOfElementarySymPol

?toElementarySymPol

Examples

elementarySum

SymmetricPolynomial[3,{(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3]),(Subscript[x, 4]),(Subscript[x, 5])}](* The variables are explicitly named *)

SymmetricPolynomial[3,Table[x[i],{i,1,5}]](* The variables are explicitly named *)

elementarySum[3,5](* The variables are automatically called $x *)

%//TraditionalForm(* modified Format for TraditionalForm *)

tableOfElementarySymPol[5]

Map[TraditionalForm,%]//TableForm

Extension to arbitrary partitions

elementarySum[{4,2,1,0}]

elementarySum[3,4]==elementarySum[{3,0,0,0}]

toElementarySymPol

elementarySum[3,5]

It is the sum of all distinct products of 3 distinct variables chosen among 5 variables

toElementarySymPol[%]

Warning: the information about the number of variables is lost when one calls toElementarySymPol :

elementarySum[3,4]

toElementarySymPol[%]

elementarySum[3,5]elementarySum[2,5]^2+elementarySum[4,5]//TraditionalForm

toElementarySymPol[%//Expand](* check *)

One could define elementarySum[r,n] to be 0 when r > n.  This is not done in this version.

elementarySum[5,4]

Monomial symmetric polynomials m[partition] and monomialSum[partition]

The argument should be a partition {p1, p2,...}
The number of variables in the polynomial is determined by the length of the extended partition
The variables are always called $x[j]
 If you want another set of variables, for instance z, use a rule like /. {$x[j_]-> z[j]}

Usage

?monomialSum

?listOfMonomialSymPol

?tableOfMonomialSymPol

?toMonomialSymPol

Examples

Monomial Symmetric Polynomials

monomialSum[{3,2,1}]

monomialSum[{3,2,1,0,0}]//TraditionalForm

toMonomialSymPol[%]

toElementarySymPol[%%]//Expand

%//TraditionalForm

listOfMonomialSymPol[3,4]

tableOfMonomialSymPol[3,4]//TraditionalForm

Notice that

elementarySum[3,5]==monomialSum[{1,1,1,0,0}]//Expand

One can decompose elementary symmetric functions on monomial symmetric functions and conversely :

elementarySum[{3,0,0,0}]

toMonomialSymPol[%]

monomialSum[{1,1,1,0}]

elementarySum[{4,2,1,0}]

toMonomialSymPol[%]

elementarySum[3,4]

toMonomialSymPol[%]

elementarySum[3,5]

toMonomialSymPol[%]

Complete symmetric polynomials  h[partition] and completeSum[partition]

Usage

?completeSum

Examples

listOfMonomialSymPol[2,3]//TraditionalForm

completeSum[2,3]//TraditionalForm

Be careful about ordering : completeSum[{2,3}] should make no sense because the ordering is incorrect for a partition,  although it does,  whereas completeSum[{3,2}] is perfectly licit. This should be fixed.

completeSum[{2,1}]

completeSum[{2,1,0}]

Check that $e -> $h is an involution

We use for instance a polynomial with 5 variables :

elementarySum[{3,2,2,0,0}] + elementarySum[{4,0,0,0,0}]//toElementarySymPol

% /. $e -> $h  (* this defines a map, we shall check that it is an involution *)

(%/. {$h[r_] -> Hold@completeSum[r,5]}//ReleaseHold)//toElementarySymPol (* we rewrite the above in terms of the $e's *)

%/. $e -> $h (* we apply the same map again *)

Simplify[%/. {$h[r_] -> Hold@completeSum[r,5]}//ReleaseHold]//toElementarySymPol (* we rewrite the above in terms of the $e's *)

and we are back to the  starting point.  The square of the map $e -> $h is the identity.

The forgotten basis

The $e’s and the  $h’s are two Z-basis of the ring of symmetric functions. There are exchanged by the previous involution.
The monomial sums (the $m’s) is another Z- basis. Applying the previous  involution to the m’s defines the so-called ``forgotten Z-basis’’  (Macdonald).

monomialSum[{2,0,0,0}]
%// toElementarySymPol

Apply the involution $e -> $h

(%/.  {$e[r_] -> Hold@completeSum[r,4]}//ReleaseHold)//Simplify
%// toElementarySymPol

The net result was to multiply by - 1
Let us consider a less trivial example :

toElementarySymPol[monomialSum[{3,2,0,0}]]
((%/.  {$e[r_] -> Hold@completeSum[r,4]}//ReleaseHold)//Simplify)// toElementarySymPol

We could denote $f[{partition}] the polynomials obtained from the $m[{partition}] by using this involution (to do)

Warning (finite number of variables)

The elementarySum[r,n]  are algebraically independent when r ≤ n and  elementarySum[r,n] is not defined (or defined to be 0) when r > n
The monomialSum[r,n]  are algebraically independent when r ≤ n and monomialSum[r,n] is not defined (or defined to be 0) when r > n
But 
The completeSum[r,n]  are algebraically independent when r ≤ n BUT completeSum[r,n] has a meaning when r > n:  it is a non-zero polynomial in the monomialSum[r,m] (or in the elementarySum[r,m]), where  m ≤ n

completeSum[2,3]
%// toElementarySymPol

completeSum[3,2]//Expand
%// toElementarySymPol
%% // toMonomialSymPol

Power-sum symmetric polynomials p[j] and powerSum[partition]

Usage

?powerSum

?elemsymtopow

?toPowerSums

?powsym

?algebraicRelationsForPowSum

Examples

PowerSums

Pre defined in Mathematica :

PowerSymmetricPolynomial[5,{x,y,z}](* Should the documentation in Mathematica be corrected ? *)

PowerSymmetricPolynomial[4,Table[x[j],{j,7}]]

PowerSymmetricPolynomial[4,Table[(Subscript[x, j]),{j,7}]]

The function powerSum :

powerSum[4,7](* Variables are $x[j] by default *)

powerSum[{4,2,0,0}](* The number of variables is the length of the extended partition *)

elemsymtopow

elemsymtopow[3]

%/. {$p[s_] -> powerSum[s,4]}

toElementarySymPol[%]

Warning :

powerSum[4,3]

powerSum[4,3]//toElementarySymPol

%// toPowerSums //Simplify

%/. {$p[s_] -> powerSum[s,3]}(* check *)

Therefore, the following expression should be 0 if the number of variables is smaller or equal to 3 :

$p[4]-(1/6) ((($p[1])^4)-6 (($p[1])^2) $p[2]+3 (($p[2])^2)+8 $p[1] $p[3])//Together

-(($p[1])^4)+6 (($p[1])^2) $p[2]-3 (($p[2])^2)-8 $p[1] $p[3]+6 $p[4]/. {$p[s_] -> powerSum[s,2]}//Expand

-(($p[1])^4)+6 (($p[1])^2) $p[2]-3 (($p[2])^2)-8 $p[1] $p[3]+6 $p[4]/. {$p[s_] -> powerSum[s,3]}//Expand

-(($p[1])^4)+6 (($p[1])^2) $p[2]-3 (($p[2])^2)-8 $p[1] $p[3]+6 $p[4]/. {$p[s_] -> powerSum[s,4]}//Expand

toPowerSums

elementarySum[2,4]elementarySum[3,4]

toPowerSums[%]

%/. {$p[s_] -> powerSum[s,4]}

%==%%%//Expand

powsym

powsym[{4,2,1}]

%/. {$p[s_] -> powerSum[s,4]}

toPowerSums[%]//Simplify

Remark (warning)

The p’s indexed by partitions, form a Q-basis (not a Z-basis) of the ring of symmetric functions :

elementarySum[2,4]//toPowerSums

Moreover, when using  a finite number of variables (ie, symmetric polynomials), one should be careful...
For instance the following sum vanishes when n≤ 3 
$p[4]-(1/6) ((($p[1])^4)-6 (($p[1])^2) $p[2]+3 (($p[2])^2)+8 $p[1] $p[3])

powerSum[{1,1,1,1}]-6powerSum[{2,1,1,0}]+3powerSum[{2,2,0,0}]+8powerSum[{3,1,0,0}]-6 powerSum[{4,0,0,0}](* evaluation using 4 variables *)

%/. $x[4]->0 //Simplify (* evaluation using 3 variables *)

More generally, when the number of variables nbvar is smaller than s, the power sum $p[s] can be expressed in terms of the $p[j], with j < nbvar :

algebraicRelationsForPowSum[s_,nbvar_]:=If[nbvar<s ,Print["If the number of variables is equal to ", nbvar , " we have the relation: "];
{Rule[$p[s], powerSum[s,nbvar]//toPowerSums//Simplify]}, {}]

algebraicRelationsForPowSum[4,1]

algebraicRelationsForPowSum[4,2]

algebraicRelationsForPowSum[4,3]

algebraicRelationsForPowSum[4,4]

algebraicRelationsForPowSum[4,5]

Back to the involution $e -> $h

If we compose $p[lambda], defined by an integer partition lambda (any number of variables),  with the involution $e -> $h, we obtain the same power sum $p[lambda], up to a sign equal to (-1)^(total(lambda) - length(lambda)). 
Cf. Macdonald.

powerSum[{4,1,1,0}]//toElementarySymPol
(%/.  {$e[r_] -> Hold@completeSum[r,4]}//ReleaseHold)//Simplify
%// toElementarySymPol

powerSum[{4,2,0,0}]//toElementarySymPol
(%/.  {$e[r_] -> Hold@completeSum[r,4]}//ReleaseHold)//Simplify
%// toElementarySymPol

powerSum[{4,3,0,0}]//toElementarySymPol
(%/.  {$e[r_] -> Hold@completeSum[r,4]}//ReleaseHold)//Simplify
%// toElementarySymPol

From named symmetric polynomials $e[j], $p[j] or $m[part] to explicit polynomials in $x[j] : the function toPol[expression, n]

Usage

?toPol

Examples

toPol[$e[4],5]

toPol[$p[4],5]

toPol[$m[{3,2}],5]

toPol[$m[{3,2,0}],5]

toPol[powsym[{5,3,2}],6]

%//TraditionalForm

Varia (SUn reduction)

Usage

?SUreductionOnpol

Example

SUreductionOnpol[7$s[{2,2,2}]+2 $s[{3,2,1}]+$s[{3,3,0}]+11$s[{4,1,1}]+$s[{4,2,0}],3]

SUreductionOnpol[7ZP[{2,2,2}]+2 ZP[{3,2,1}]+ZP[{3,3,0}]+11ZP[{4,1,1}]+7ZP[{3,0,0}]+ZP[{4,2,0}],3,ZP]

SUreductionOnpol[5ZP[{2,2,2}]+2 ZP[{3,2,1}]+ZP[{3,3,0}]-11/2ZP[{4,1,1}]+7ZP[{3,0,0}]+ZP[{4,2,0}],3,ZP]

Jack polynomials

Method using sum over sub partitions : JackPolJ[partition], JackPolC[partition] and JackPolP[partition]

Usage

?JackPolJ

?JackPolC

?JackPolP

Examples

JackPolJ[{3,2,1}]

%//TraditionalForm

JackPolC[{3,2,1}]

JackPolP[{3,2,1}]

With 4 variables :

JackPolJ[{3,2,1,0}]//TraditionalForm

JackPolX in terms of monomial symmetric polynomials

Usage

?JackJtoMonomialSymPol

?JackCtoMonomialSymPol

?JackPtoMonomialSymPol

Examples

JackJtoMonomialSymPol[{3,2,1}]

%//TraditionalForm

JackCtoMonomialSymPol[{3,2,1}]

JackPtoMonomialSymPol[{3,2,1}]

JackJtoMonomialSymPol[{3,2,1,0}](* same result as JackJtoMonomialSymPol[{3,2,1}] of course *)

JackPolX in terms of elementary symmetric polynomials

Usage

?JackJtoElementarySymPol

?JackCtoElementarySymPol

?JackPtoElementarySymPol

Examples

JackJtoElementarySymPol[{3,2,1}]

JackCtoElementarySymPol[{3,2,1}]

JackPtoElementarySymPol[{3,2,1}]

%//TraditionalForm

JackPolX in terms of power-sums polynomials

Usage

?JackJtoPowerSum

?JackCtoPowerSum

?JackPtoPowerSum

Examples

JackJtoPowerSum[{3,2,1}]

JackCtoPowerSum[{3,2,1}]

JackPtoPowerSum[{3,2,1}]

%//TraditionalForm

Convert between normalizations JX for named Jack polynomials JJ, JC, JP

Usage

?JXtoJJ

?JXtoJC

?JXtoJP

Example

test=3 JC[{2,1,0}] + 5 JC[{1,1,1}]
JXtoJJ[test]
JXtoJP[%]
JXtoJC[%]

test=3 JJ[{2,1,0}] + 5 JJ[{1,1,1}]
JXtoJC[test]
JXtoJP[%]
JXtoJJ[%]

test=3 JP[{2,1,0}] + 5 JP[{1,1,1}]
JXtoJC[test]
JXtoJJ[%]
JXtoJP[%]

Clear@test

From named Jack polynomials  to explicit polynomials in (Subscript[x, j])

Examples

toPol[JJ[{2,1,0}],3]//Simplify//Expand

JackPolJ[{2,1,0}](* check *)

toPol[JC[{2,1,0}],3]//Simplify//Expand

JackPolC[{2,1,0}](* check *)

toPol[JP[{2,1,0}],3]//Simplify//Expand

JackPolP[{2,1,0}]//Simplify//Expand(* check *)

Translation of 1 of the partition :

toPol[JP[{2,1,0}],3]

%//Expand

toPol[JP[{2+1,1+1,0+1}],3]// Simplify//Expand

$x[1] $x[2] $x[3] %% == % //Simplify

The result is multiplied by $x[1] $x[2]... $x[n]  (here $x[1] $x[2] $x[3] ) BUT this is only true for the normalization P

Structure constants

Usage

?toJackPProdPairUsingPowerSums

?toJackJProdPairUsingPowerSums

?toJackJProductPair

?toJackCProductPair

?toJackJProductPair

Example

toJackPProdPairUsingPowerSums[{2,1,0},{2,1,0}]//Apart//TraditionalForm

% /. $α->1 (* check Schur (below) OK *)

%% /. $α->2 (* check Zonal (below) OK *)

%%% /. $α->1/2 (* check Quaternionic (below) OK *)

toJackPProductPair[{2,1,0},{2,1,0}]//Apart//TraditionalForm

toJackJProductPair[{2,1,0},{2,1,0}]//Apart//TraditionalForm

toJackCProductPair[{2,1,0},{2,1,0}]//Apart//TraditionalForm

Schur polynomials

Definition (using Jack polynomials)

Usage

?SchurPol

?listOfSchurPol

Examples

SchurPol[{3,2,1}]==JackPolP[{3,2,1}] /. {α->1}//Simplify

SchurPol[{3,2,1}]

SchurPol[{3,2,1,0}]

%%==%/. {x[4]->0}

%//TraditionalForm

Using toPol

toPol[$s[{3,2,1}],4]

toPol[$s[{3,2,1}],3]

toPol[$s[{3,2,1}],2]

Schur polynomials in terms of various kinds of symmetric polynomials

Usage

?SchurtoElementarySymPol

?SchurtoMonomialSymPol

?SchurtoPowerSum

Examples

To elementary symmetric polynomials

SchurtoElementarySymPol[{2,1,1}]

SchurtoElementarySymPol[{2,2,0}]

SchurtoElementarySymPol[{3,1,0}]

SchurtoElementarySymPol[{4,0,0}]

(* Warning : the number of variables is the length of the extended partition *)

SchurtoElementarySymPol[{3,2,1}]//Expand

SchurtoElementarySymPol[{3,2,1,0}]//Expand

SchurtoElementarySymPol[{3,2,1,0,0}]//Expand

SchurtoElementarySymPol[{3,2,1,0,0,0}]//Expand
(* The expression stabilizes when the number of variables becomes equal to (or larger than) the total of the extended partition (6 in this example) *)

To monomial symmetric polynomials

SchurtoMonomialSymPol[{3,2,1}]

toElementarySymPol[toPol[%,3]]

SchurtoMonomialSymPol[{3,2,1,0,0}]

toElementarySymPol[toPol[%,5]]

SchurtoMonomialSymPol[{3,2,1,0,0,0}]
(* The expression stabilizes when the number of variables becomes equal to (or larger than) the total of the extended partition (6 in this example) *)

toElementarySymPol[toPol[%,6]]

to power sums

SchurtoPowerSum[{3,2,1}]

SchurtoPowerSum[{3,2,1,0}]

SchurtoPowerSum[{3,2,1,0,0}]

SchurtoPowerSum[{3,2,1,0,0,0}]
(* The expression stabilizes when the number of variables becomes equal to (or larger than) the total of the extended partition (6 in this example) *)

From explicit symmetric polynomials to Schur polynomials (called $s[partition])

Usage

?toSchur

Examples

An example :

test=3monomialSum[{2,2,1}]+2 monomialSum[{3,1,1}]+ monomialSum[{4,1,0}]//Expand

toSchur[test]

Expand[toPol[%,3]]==%% (*check*)

Examples with Timing

test=monomialSum[{2,1,1}]

Timing[toSchur[test]]

Timing[toSchur[test^2]]

Timing[toSchur[test^3]]

Timing[toSchur[test^4]]

Timing[toSchur[test^5]]

Clear[test];

Warning : if the length of the extended partition (the argument of SchurPol)  is too small, as in above examples, the expansion is truncated.
Compare:

toSchur[SchurPol[{2,1,1}]^2]

toSchur[SchurPol[{2,1,1,0}]^2]

toSchur[SchurPol[{2,1,1,0,0}]^2]

toSchur[SchurPol[{2,1,1,0,0,0}]^2]
(* stabilization : the maximal length of partitions appearing in the result (here a product of two) is the sum of lengths, here 3+3=6, so we need extended partitions of lenght 6  *)

toSchur[SchurPol[{2,1,1,0,0,0,0}]^2](* indeed *)

test=SchurPol[{3,2,1,0}];

Timing[toSchur[test^2]](* Kill kernel before test timing *)

Clear[test]

toSchurProductPair[li1,li2] and toSchurProdPairUsingPowerSums[li1,li2], see below the section “Structure constants”  give the same result as toSchur[SchurPol[li1]*SchurPol[li2]] but the first two methods are usually faster.

Warning : the command toSchur does not necessarily assume that  the argument is a symmetric homogeneous polynomial (however the argument should be at least symmetric).
If the terms appearing in the argument do not have all the same (total) degree, i.e., if the argument is not homogeneous, the command toSchur  will also work.

test = 2SchurPol[{2,1,0}] + 3 SchurPol[{1,1,0}](* a 3-variables symmetric polynomial with terms of degree 3 AND terms of degree 2 *)

toSchur[test]

Clear@test

Using toPol

toSchur[toPol[$s[{2,1,1}],3]^2]

toSchur[toPol[$s[{2,1,1}]^2,3]]

From named Schur polynomials  s[partition] to explicit polynomials in (Subscript[x, j])

Examples

toPol[$s[{2,1,0}],3]//TraditionalForm

SchurPol[{2,1,0}]//TraditionalForm

%==%%

Structure constants

Usage

?toSchurProductPair

?toSchurProdPairUsingPowerSums

Examples

The maximal length of an integer partition appearing in the decomposition of a product of two is the sum of the lengths of the integer partitions.
In the following example, the lengths are 3 and 2, the maximal length in the result will be 3+2=5.
If we use polynomials with a number of variables smaller than 5 the result will be truncated. 
Remember that the number of variables is encoded by the length of an extended partition (trailing 0’s).

toSchurProductPair[{2,1,0},{2,1,0}]//TraditionalForm

toSchurProductPair[{2,1,1},{3,1,0}]//TraditionalForm

toSchurProductPair[{2,1,1,0},{3,1,0,0}]//TraditionalForm

toSchurProductPair[{2,1,1,0,0},{3,1,0,0,0}]//TraditionalForm (* stabilization *)

toSchurProductPair[{2,1,1,0,0,0},{3,1,0,0,0,0}]//TraditionalForm(* indeed *)

For timing estimates one should kill the kernel, because the code is written in such a way that many partial results are kept in memory

Timing[toSchurProductPair[{3,2,1,0},{3,2,1,0}]](* Kill kernel before test timing *)

Timing[toSchurProdPairUsingPowerSums[{3,2,1,0,0,0},{3,2,1,0,0,0}]]

From Schur polynomials to the Weyl character polynomials of SU(n)

Usage

?SchurToSUnCharPol

?SchurToSUnCharTrigo

Examples

[1,1] are the Dynkin labels of the highest weight of the adjoint representation of the Lie group SU(3).
The corresponding integer partition is {2,1}, the extended partition returned by highestWeightToExtendedYoungPartition  is {2,1,0}.

youngPartitionToHighestWeight[{2,1,0},3]

highestWeightToExtendedYoungPartition[{1,1}]

SchurPol[{2,1,0}]

SchurToSUnCharPol[{1,1}]

%//Expand//TraditionalForm (* Laurent polynomial: recognise the Weyl character of the adjoint representation of the Lie group SU(3) *)

%/. $y[j_]-> 1 (* the dimension of the adjoint. Notice that variables are still $y[j] ! *)

SchurToSUnCharTrigo[{1,1}] (* Trigonometric version: recognise the Weyl character of the adjoint representation of the Lie algebra su(3) *)

Another example in SU(5) : consider the representation with highest weight [1,0,0,1] :

SchurToSUnCharPol[{1,0,0,1}]//TraditionalForm

%/. $y[j_]-> 1 (* its dimension *)

SchurToSUnCharTrigo[{1,0,0,1}] //TraditionalForm

Zonal polynomials

Definition (using Jack polynomials). The three normalizations.

Usage

?ZonalPolJ

?ZonalPolC

?ZonalPolP

?listOfZonalPolJ

?listOfZonalPolC

?listOfZonalPolP

Examples

ZonalJamesPol polynomials

ZonalPolJ[{2,1,0}]

ZonalPolC[{2,1,0}]

ZonalPolP[{2,1,0}]

toPol[ZJ[{2,1}],3]

toPol[ZC[{2,1}],3]

toPol[ZP[{2,1}],3]

ExtendedYoungPartitions[4,3]
listOfZonalPolJ[4,3]//TableForm //TraditionalForm

ExtendedYoungPartitions[4,3]
listOfZonalPolC[4,3]//TableForm//TraditionalForm

ExtendedYoungPartitions[4,3]
listOfZonalPolP[4,3]//TableForm//TraditionalForm

Zonal polynomials in terms of various kinds of symmetric polynomials

Usage

?ZonalJtoElementarySymPol

?ZonalJtoMonomialSymPol

?ZonalJtoPowerSum

?ZonalCtoElementarySymPol

?ZonalCtoMonomialSymPol

?ZonalCtoPowerSum

?ZonalPtoElementarySymPol

?ZonalPtoMonomialSymPol

?ZonalPtoPowerSum

?ZonalJtoSchur

?ZonalCtoSchur

?ZonalPtoSchur

Examples (general)

To elementary symmetric polynomials

ZonalJtoElementarySymPol[{3,2,1,0,0}]//Expand
ZonalCtoElementarySymPol[{3,2,1,0,0}]//Expand
ZonalPtoElementarySymPol[{3,2,1,0,0}]//Expand

To monomial symmetric polynomials

ZonalJtoMonomialSymPol[{3,2,1,0,0}]//Expand
ZonalCtoMonomialSymPol[{3,2,1,0,0}]//Expand
ZonalPtoMonomialSymPol[{3,2,1,0,0}]//Expand

to power sums

ZonalJtoPowerSum[{3,2,1,0,0}]//Expand
ZonalCtoPowerSum[{3,2,1,0,0}]//Expand
ZonalPtoPowerSum[{3,2,1,0,0}]//Expand

to Schur polynomials

ZonalJtoSchur[{3,2,1,0,0}]//Expand
ZonalCtoSchur[{3,2,1,0,0}]//Expand
ZonalPtoSchur[{3,2,1,0,0}]//Expand

Example : tables of  zonal J polynomials in terms of monomial symmetric polynomials

Tables of  zonal J polynomials in terms of monomial symmetric polynomials  
(replace ZonalJtoMonomialSymPol by ZonalCtoMonomialSymPol or ZonalPtoMonomialSymPol to get the corresponding results with the normalizations C and P)

ExtendedYoungPartitions[1]
Map[ZonalJtoMonomialSymPol,%]//TableForm // TraditionalForm

ExtendedYoungPartitions[2]
Map[ZonalJtoMonomialSymPol,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[3]
Map[ZonalJtoMonomialSymPol,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[4]
Map[ZonalJtoMonomialSymPol,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[5]
Map[ZonalJtoMonomialSymPol,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[6]
Map[ZonalJtoMonomialSymPol,%]//TableForm// TraditionalForm

Example : tables of  zonal J polynomials in terms of power sums

Tables of  zonal J polynomials in terms of power sums  
(replace ZonalJtoPowerSum by ZonalCtoPowerSum or ZonalPtoPowerSum to get the corresponding results with the normalizations C and P)

ExtendedYoungPartitions[1]
Map[ZonalJtoPowerSum,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[2]
Map[ZonalJtoPowerSum,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[3]
Map[ZonalJtoPowerSum,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[4]
Map[ZonalJtoPowerSum,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[5]
Map[ZonalJtoPowerSum,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[6]
Map[ZonalJtoPowerSum,%]//TableForm // TraditionalForm

ExtendedYoungPartitions[7]
Map[ZonalJtoPowerSum,%]//TableForm // TraditionalForm

Example : tables of  zonal J polynomials in terms of Schur polynomials

Tables of  zonal J polynomials in terms of Schur polynomials  
(replace ZonalJtoSchur by ZonalCtoSchur or ZonalPtoSchur to get the corresponding results with the normalizations C and P)

ExtendedYoungPartitions[1]
Map[ZonalJtoSchur,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[2]
Map[ZonalJtoSchur,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[3]
Map[ZonalJtoSchur,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[4]
Map[ZonalJtoSchur,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[5]
Map[ZonalJtoSchur,%]//TableForm// TraditionalForm

ExtendedYoungPartitions[6]
Map[ZonalJtoSchur,%]//TableForm// TraditionalForm

Convert between normalizations ZX for named zonal polynomials ZJ, ZC, ZP

Usage

?ZXtoZJ

?ZXtoZC

?ZXtoZP

Example

test1=3 ZC[{2,1,0}] + 5 ZC[{1,1,1}]
ZXtoZJ[test1]
ZXtoZP[%]
ZXtoZC[%]

test2=3 ZJ[{2,1,0}] + 5 ZJ[{1,1,1}]
ZXtoZC[test2]
ZXtoZP[%]
ZXtoZJ[%]

test3=3 ZP[{2,1,0}] + 5 ZP[{1,1,1}]
ZXtoZC[test3]
ZXtoZJ[%]
ZXtoZP[%]

Clear[test1,test2,test3]

From explicit symmetric polynomials to Zonal polynomials (called ZJ[partition], ZC[partition] or ZP[partition])

Usage

?toZonalJ

?toZonalC

?toZonalP

Examples

test=ZonalPolJ[{2,1,0}]

toZonalJ[test]
toZonalJ[test^2]
toZonalJ[test^3]

toZonalC[test]
toZonalC[test^2]
toZonalC[test^3]

toZonalP[test]
toZonalP[test^2]
toZonalP[test^3]

%//ZXtoZC (* check *)

%% //ZXtoZJ (* check *)

Warning : the commands toZonalJ, toZonalC and toZonalP do not necessarily assume that  the argument is a symmetric homogeneous polynomial (however the argument should be at least symmetric).
If the terms appearing in the argument do not have all the same (total) degree, i.e., if the argument is not homogeneous, these commands will also work.

test = 2ZonalPolJ[{2,1,0}] + 3 ZonalPolJ[{1,1,0}](* a 3-variables symmetric polynomial with terms of degree 3 AND terms of degree 2 *)

toZonalJ[test]

Clear@test

From named zonal polynomials  ZJ, ZC, ZP to explicit polynomials in (Subscript[x, j])

Examples

toPol[ZJ[{2,1,0}],3]

ZonalPolJ[{2,1,0}](* check *)

toPol[ZC[{2,1,0}],3]

toPol[ZP[{2,1,0}],3]//Expand

Translation of 1 of the partition

toPol[ZJ[{2,1,0}],3]

toPol[ZJ[{2+1,1+1,0+1}],3]

toPol[ZC[{2,1,0}],3]//Expand

toPol[ZC[{2+1,1+1,0+1}],3]//Expand

toPol[ZP[{2,1,0}],3]//Expand

toPol[ZP[{2+1,1+1,0+1}],3]//Expand (* The result is multiplied by $x[1] $x[2]... $x[n] : this is only true for the normalization P *)

James constants and evaluation of ZonalJ on the unit

Usage

?cjames

?ZonalJofOne

Examples

cjames

cjames[{3,2,1}]

cjames[{3,2,1},$α]

%/. {$α->2}

Timing[cjames[{13,12,9,7,2},$α]]

%/. {$α->2}

Timing[cjames[{13,12,9,7,2}]](* fast because explicit formula *)

ZonalJofOne

Table[ZonalJofOne[{3,2,1},j],{j,1,10}]

ZonalJofOne[{2,1,0},N]

ZonalJofOne[{3,1,0},N]

ZonalJofOne[{3,1,0,0},N]

%/. N-> 4

ZonalJofOne[{3,1,0,0},3]==ZonalJofOne[{3,1,0},3]

ZonalJofOne[{3,1,0,0,0},N](* it stabilizes *)

ZonalJofOne[{3,1}](* the default : the number of variables is chosen equal to the length of the partition (here 4) *)

Tables :

Recovering and extending tables given in A.T. James (1960). The distribution of the latent roots of the covariance matrix. The Annals of Mathematical Statistics, 31, 151-158.
See also: A.M. Mathai, S. B. Provost, and T. Hayakawa, Bilinear Forms and Zonal Polynomials, Lecture Notes in Statistics 102, Springer Verlag, 1995.

Tables of James constants (cjames) :

ExtendedYoungPartitions[1]
Map[cjames[#]&,%]

ExtendedYoungPartitions[2]
Map[cjames[#]&,%]

ExtendedYoungPartitions[3]
Map[cjames[#]&,%]

ExtendedYoungPartitions[4]
Map[cjames[#]&,%]

ExtendedYoungPartitions[5]
Map[cjames[#]&,%]

ExtendedYoungPartitions[6]
Map[cjames[#]&,%]

Tables of ZonalJofOne :

ExtendedYoungPartitions[1]
Map[ZonalJofOne[#,N]&,%]//TableForm

ExtendedYoungPartitions[2]
Map[ZonalJofOne[#,N]&,%]//TableForm

ExtendedYoungPartitions[3]
Map[ZonalJofOne[#,N]&,%]//TableForm

ExtendedYoungPartitions[4]
Map[ZonalJofOne[#,N]&,%]//TableForm

ExtendedYoungPartitions[5]
Map[ZonalJofOne[#,N]&,%]//TableForm

ExtendedYoungPartitions[6]
Map[ZonalJofOne[#,N]&,%]//TableForm

Structure constants

Usage

?toZonalJProductPair

?toZonalCProductPair

?toZonalPProductPair

Examples

Most of the following examples use zonal polynomials in the J normalization. For the normalizations C and P, replace the command toZonalJProductPair by toZonalCProductPair or toZonalPProductPair.

toZonalJProductPair[{2,1,0},{2,1,0}]

toZonalCProductPair[{2,1,0},{2,1,0}]

toZonalPProductPair[{2,1,0},{2,1,0}]

Warning: in the following examples the integer partition {3,2,1} stays the same but the number of variables, encoded by the extended partition {3,2,1,0,..0}, increases.
When the number of variables is big enough (equal to the sum of lengths of the two integer partitions, here 3+3=6), the result stabilizes.

Timing[toZonalJProductPair[{3,2,1},{3,2,1}]](* Kill kernel before test timing *)

Timing[toZonalJProductPair[{3,2,1,0},{3,2,1,0}]](* Kill kernel before test timing *)

Timing[toZonalJProductPair[{3,2,1,0},{3,2,1,0}]](* Kill kernel before test timing *)

Timing[toZonalJProductPair[{3,2,1,0,0},{3,2,1,0,0}]](* Kill kernel before test timing *)

Using six variables (non-truncated result : stabilization) :

toZonalJProductPair[{3,2,1,0,0,0},{3,2,1,0,0,0}]

Another example

toZonalJProductPair[{2,1},{2,1}]

toZonalJProductPair[{2,1,0},{2,1,0}]

toZonalJProductPair[{2,1,0,0},{2,1,0,0}](* stabilization *)

toZonalJProductPair[{2,1,0,0,0},{2,1,0,0,0}]

Remark : the following two commands give the same result. The first is usually faster.

Timing@toZonalPProductPair[{2,1,0,0},{2,1,0,0}](* two arguments *)

Timing@toZonalP[ZonalPolP[{2,1,0,0}] * ZonalPolP[{2,1,0,0}]](* one argument, which is a product of two *)

Remark : Structure constants can also be calculated by using inner products, see the section Inner products, below.

From zonal polynomials to the SU(n) zonal characters

Usage

?ZonalPToSUnCharPol

?ZonalPToSUnCharTrigo

Note: Compatibility of the P normalization of zonal polynomials with SU(n) restriction (compatibility with conjugation operation)

Schur case
The SU3 dominant weight determined by the partition {2,1} has  Dynkin indices [1,1] and is self-conjugate.
The decomposition of the square of Schur[{2,1,0}] contains s[{3,3,0}] and s[{4,1,1}], with equal multiplicity (namely 1).
This symmetry between {3, 3, 0} and {4, 1, 1} is expected since after SU3 reduction,  they are associated with dominant weights given by the Dynkin indices  [3, 0] and [0, 3] that are complex conjugated.

toSchurProductPair[{2,1,0},{2,1,0}]

ZonalP case
We observe the same symmetry between (3, 3, 0) and (4, 1, 1) :  the structure constants associated with these two terms are equal (=4/3).

toZonalPProductPair[{2,1,0},{2,1,0}]

ZonalJ case : the symmetry is lost

toZonalJProductPair[{2,1,0},{2,1,0}]

ZonalC case : the symmetry is lost

toZonalCProductPair[{2,1,0},{2,1,0}]

This generalizes to all cases. 
The following example {3,2,1} is associated with the dominant weight [1,1,1] of SU(4)  is also self-conjugate.
In the square of this zonalP polynomial, the structure constants of {4,4,3,1} and {5,3,2,2}, for instance, respectively associated with complex conjugate dominant weights [0,1,2] and [2,1,0] in SU(4), are equal.

toZonalPProductPair[{3,2,1,0},{3,2,1,0}]

SU(n) zonal characters

Because of the compatibility between the P normalization of zonal polynomials and the restriction to SU(n), see the previous subsection, the SU(n) zonal characters are defined directly from the ZonalP polynomials. One could use ZonalJ or ZonalC as well while introducing appropriate pre-factors.

[1,1] are the Dynkin labels of the highest weight of the adjoint representation of the Lie group SU(3).
The corresponding integer partition is {2,1}, the extended partition returned by highestWeightToExtendedYoungPartition  is {2,1,0}.

youngPartitionToHighestWeight[{2,1,0},3]

highestWeightToExtendedYoungPartition[{1,1}]

ZonalPolP[{2,1,0}]

Warning : arguments of ZonalPToSUnCharPol and of ZonalPToSUnCharTrigo are dominant weights in the Dynkin basis (fundamental weights). They are NOT partitions.

ZonalPToSUnCharPol[{1,1}]

%//Expand//TraditionalForm (* Laurent polynomial: SU(3) zonal character for the adjoint representation of the Lie group SU(3) *)

Compared to the Weyl character (ie the Schur case),  the coefficients are different -- actually in the present example only the constant term is modified (3/2 rather than 2) but in other examples,  other coefficients would be also modified.

%/. $y[j_]-> 1 (* the "zonal dimension" of the adjoint *)

ZonalPToSUnCharTrigo[{1,1}] (* Trigonometric version: this defines the zonal character for the adjoint representation of the Lie algebra su(3) *)

Another example in SU(5) : consider the representation with highest weight [1,0,0,1] :

ZonalPToSUnCharPol[{1,0,0,1}]//TraditionalForm

%/. $y[j_]-> 1 (* its "zonal dimension" *)

ZonalPToSUnCharTrigo[{1,0,0,1}] //TraditionalForm

Quaternionic polynomials

At the moment the package only implements a few commands. It could be extended like the section Zonal Polynomials

Usage

?QuaterPolJ

?QuaterPolC

?QuaterPolP

?QuaterPtoMonomialSymPol

?toQuaterPProductPair

?toQuaterJProductPair

?toQuaterCProductPair

Example

QuaterPolJ[{2,1,0}]

QuaterPolC[{2,1,0}]

QuaterPolP[{2,1,0}]//Expand

toPol[QP[{2,1}],3]

Translation of 1 of the partition

QuaterPolP[{2+1,1+1,0+1}]//Expand(* The result is multiplied by $x[1] $x[2]... $x[n] : this is only true for the normalization P *)

QuaterPtoMonomialSymPol[{2,1,0}]

toQuaterPProductPair[{2,1,0},{2,1,0}]

Inner products

The Jack inner products

Usage

?JackScalarProduct

?stableNormSqOfJackJ

?stableNormSqOfJackC

?stableNormSqOfJackP

Example

The command JackScalarProduct returns the Jack scalar product with  parameter α of the two symmetric functions pol1 and pol2.
It can be thought as a renormalized and stabilized version of an n-variables scalar product. See the usage ?JackScalarProduct and the examples below.
Reminder: 
If p[lambda] and p[mu] are two symmetric functions defined by the integer partitions lambda and mu, their Jack scalar product (with parameter a) is the real number 
KroneckerDelta(lambda,mu) a^ell(lambda)  (1^m1, 2^m2...) m1! m2! ...  where mj is the number of parts of lambda equal to j,  and  where ell(lambda) is the length of lambda.

Example :

monomialSum[{2,1,1}]//TraditionalForm
monomialSum[{3,1}]//TraditionalForm
JackScalarProduct[monomialSum[{2,1,1}],monomialSum[{3,1}],$x,a]//Factor//TraditionalForm

JackScalarProduct[monomialSum[{2,1,1}],monomialSum[{3,1,0}],$x,a]//Factor//TraditionalForm

JackScalarProduct[monomialSum[{2,1,1,0}],monomialSum[{3,1,0,0}],$x,a]//Factor

But the last one coincides with the stabilized value since we are using extended partitions with a number of variables equal to the total of each partition :

JackScalarProduct[monomialSum[{2,1,1}],monomialSum[{3,1}],Infinity,a]//Factor//TraditionalForm

monomialSum[{2,1,1}]
monomialSum[{3,1}]

JackScalarProduct[(($x[1])^2) $x[2] $x[3]+$x[1] (($x[2])^2) $x[3]+$x[1] $x[2] (($x[3])^2),(($x[1])^3) $x[2]+$x[1] (($x[2])^3),$x,a](* no warning in this case *)

The following example was first computed by P. Hanlon (quoted by R.P. Stanley) :

JackScalarProduct[JackPolJ[{2,1,1}]*JackPolJ[{2,1,1}],JackPolJ[{2,2,2,1,1}],Infinity, $α]//Factor//TraditionalForm

If we only want to calculate the norm square of a Jack polynomial using this scalar product, use the command(s) stableNormSqOfJackJ (or P, or C), which is much faster.

stableNormSqOfJackJ[{2,1,1},a]//Factor

JackScalarProduct[JackPolJ[{2,1,1}],JackPolJ[{2,1,1}],Infinity,$α]//Factor

JackScalarProduct[JackPolC[{2,1,1}],JackPolC[{2,1,1}],Infinity,$α]//Factor

JackScalarProduct[JackPolP[{2,1,1}],JackPolP[{2,1,1}],Infinity,$α]//Factor

Compare timing :

Timing@stableNormSqOfJackJ[{2,2,2},$α]//Factor//TraditionalForm

Timing@JackScalarProduct[JackPolJ[{2,2,2}],JackPolJ[{2,2,2}],Infinity,$α]//Factor//TraditionalForm

For the three normalizations of Jack :

stableNormSqOfJackJ[{2,1,1},$α]//Factor

stableNormSqOfJackC[{2,1,1},$α]//Factor

stableNormSqOfJackP[{2,1,1},$α]//Factor

In the Schur case, use the rule $α  -> 1 in stableNormSqOfJackP (normalisation P)
In the zonal case (three normalizations), use the rule $α  -> 2

stableNormSqOfJackP[{2,1,1},$α]/. $α->1  (* This is for Schur *)

{stableNormSqOfJackJ[{2,1,1},$α]/. $α->2,stableNormSqOfJackC[{2,1,1},$α]/. $α->2,stableNormSqOfJackP[{2,1,1},$α]/. $α->2} 
(* This is for Zonal J C P *)

Jack polynomials (and in particular Schur and zonal polynomials) are orthogonal for the Jack scalar product (provided one selects the appropriate parameter)

JackScalarProduct[JackPolJ[{2,1,1}],JackPolJ[{3,1}],Infinity,$α]//Factor

Moreover  Schur polynomials are orthonormal for this scalar product

JackScalarProduct[SchurPol[{3,1}],SchurPol[{3,1}],Infinity,$α]/. $α->1

equivalently,

JackScalarProduct[JackPolP[{3,1}],JackPolP[{3,1}],Infinity,$α]/. $α->1 //Factor

But zonal polynomial are not orthonormal  (they are only orthogonal) :

JackScalarProduct[ZonalPolJ[{3,1}],ZonalPolJ[{3,1}],Infinity,$α]/. $α->2 //Factor

JackScalarProduct[ZonalPolC[{3,1}],ZonalPolC[{3,1}],Infinity,$α]/. $α->2 //Factor

JackScalarProduct[ZonalPolP[{3,1}],ZonalPolP[{3,1}],Infinity,$α]/. $α->2 //Factor

As already mentioned it is faster to use stableNormSqOfJackX :

{stableNormSqOfJackJ[{3,1},$α]/. $α->2,stableNormSqOfJackC[{3,1},$α]/. $α->2,stableNormSqOfJackP[{3,1},$α]/. $α->2}

One can use this inner product to obtain structure constants : see the next section

The Jack scalar product with parameter a can be used on arguments that are Jack polynomials with parameter $α  (with a≠ $α ).
There is no orthogonality in that case :

JackScalarProduct[JackPolJ[{2,1,1}],JackPolJ[{3,1}],Infinity,a]//Factor

Structure constants via inner products

The square of ZonalP [{3, 2, 1, 0, 0, 0}], for instance, when decomposed on ZonalJ polynomials,  contains a term (72/25) ZP[{2,2,2,1,1}] .
This can be seen by using toZonalPProductPair , see section Zonal Polynomials / Structure constants (and below).
This structure coefficient can be recovered as follows, using inner products :

toZonalPProductPair[{2,1,1,0,0},{2,1,1,0,0}]

JackScalarProduct[JackPolP[{2,1,1}]*JackPolP[{2,1,1}],JackPolP[{2,2,2,1,1}],Infinity, $α]//Factor//TraditionalForm
stableNormSqOfJackP[{2,2,2,1,1},$α]//TraditionalForm

%%/.{$α->2}
%%/.{$α->2}

%%/%

Another example : the coefficient of  ZP[{3,2,2,1,0}]

JackScalarProduct[JackPolP[{2,1,1}]*JackPolP[{2,1,1}],JackPolP[{3,2,2,1}],Infinity, $α]/. {$α->2}

stableNormSqOfJackP[{3,2,2,1},$α]/. {$α->2}

%%/%

Note : a Stanley-Macdonald conjecture.
The fact, for JackScalarProduct[JackPolJ[{2,1,1}]*JackPolJ[{2,1,1}],JackPolJ[{3,2,2,1}],Infinity, $α], to be polynomial in $α is one of the Stanley-Macdonald conjectures (warning : one has to use the normalisation J)

JackScalarProduct[JackPolJ[{2,1,1}]*JackPolJ[{2,1,1}],JackPolJ[{3,2,2,1}],Infinity,$α]//FullSimplify

JackScalarProduct[JackPolC[{2,1,1}]*JackPolC[{2,1,1}],JackPolC[{3,2,2,1}],Infinity,$α]//FullSimplify

JackScalarProduct[JackPolP[{2,1,1}]*JackPolP[{2,1,1}],JackPolP[{3,2,2,1}],Infinity,$α]//FullSimplify

JackScalarProduct[JackPolJ[{2,1,1}],JackPolJ[{2,1,1}],Infinity,$α]

stableNormSqOfJackJ[{2,1,1},$α]

JackScalarProduct[JackPolJ[{2,1,1}],JackPolJ[{2,1,1}],Infinity,$α]

JackScalarProduct[JackPolJ[{2,1,1}],JackPolJ[{2,1,1}],Infinity,$α]

Taking  distinct parameters $α (for Jack) and a (for the scalar product) :

JackScalarProduct[JackPolJ[{2,1,1}]*JackPolJ[{2,1,1}],JackPolJ[{3,2,2,1}],Infinity, a]//FullSimplify

% //TraditionalForm

stableNormSqOfJackJ[{3,2,2,1},$α]//TraditionalForm

A family of inner products defined by integration over polynomials with n variables (Macdonald)

Usage

?MacdonaldScalarProduct

?coefDyson

?scalarProductForSchurViaSeries

Example

The Dyson coefficient

coefDyson[5,$α]//TraditionalForm

Macdonald inner product  (α-dependent) between arbitrary linear combinations of Jack polynomials (JJ, JC, JP), and, in particular, arbitrary linear combinations of Schur polynomials or zonal polynomials (three normalizations)

MacdonaldScalarProduct[2 JJ[{1,1,1}] + 5 JJ[{2,1,0}] + 7 JJ[{3,0,0}], 3 JJ[{1,1,1}] + 11 JJ[{2,1,0}] +  JJ[{3,0,0}],$α]//TraditionalForm

MacdonaldScalarProduct[2 JC[{1,1,1}] + 5 JC[{2,1,0}] + 7 JC[{3,0,0}], 3 JC[{1,1,1}] + 11 JC[{2,1,0}] +  JC[{3,0,0}],$α]//TraditionalForm

MacdonaldScalarProduct[2 JP[{1,1,1}] + 5 JP[{2,1,0}] + 7 JP[{3,0,0}], 3 JP[{1,1,1}] + 11 JP[{2,1,0}] +  JP[{3,0,0}],$α]//TraditionalForm

MacdonaldScalarProduct[2 ZJ[{1,1,1}] + 5 ZJ[{2,1,0}] + 7 ZJ[{3,0,0}], 3 ZJ[{1,1,1}] + 11 ZJ[{2,1,0}] +  ZJ[{3,0,0}],2]

MacdonaldScalarProduct[2 ZC[{1,1,1}] + 5 ZC[{2,1,0}] + 7 ZC[{3,0,0}], 3 ZC[{1,1,1}] + 11 ZC[{2,1,0}] +  ZC[{3,0,0}],2]

MacdonaldScalarProduct[2 ZP[{1,1,1}] + 5 ZP[{2,1,0}] + 7 ZP[{3,0,0}], 3 ZP[{1,1,1}] + 11 ZP[{2,1,0}] +  ZP[{3,0,0}],2]

MacdonaldScalarProduct[2 $s[{1,1,1}] + 5 $s[{2,1,0}] + 7 $s[{3,0,0}], 3$s[{1,1,1}] + 11 $s[{2,1,0}] +  $s[{3,0,0}],1]

Macdonald inner product  (α-dependent) between explicit multivariate  polynomials with n variables $x[j]

Compare timing !

JackPolJ[{1,1,1}]

Timing@MacdonaldScalarProduct[JackPolJ[{1,1,1}], JackPolJ[{1,1,1}],$x,$α](* A 3-dimensional integral *)

Timing[%/. {SymPol$Package`Private`t[j_]-> (Subscript[t, j])}]

Timing[{% /. $α->1,%% /. $α->2}]

Timing@MacdonaldScalarProduct[JackPolJ[{1,1,1}], JackPolJ[{1,1,1}],$x,1]

Timing@MacdonaldScalarProduct[JackPolJ[{1,1,1}], JackPolJ[{1,1,1}],$x,2]

Timing@MacdonaldScalarProduct[JJ[{1,1,1}], JJ[{1,1,1}],1]

Timing@MacdonaldScalarProduct[JJ[{1,1,1}], JJ[{1,1,1}],2]

Another example :

{(test1 = monomialSum[{3,1,1}]),(test2 = monomialSum[{4,1,0}])}//TraditionalForm

{toSchur[test1],toSchur[test2]}

Timing@MacdonaldScalarProduct[toSchur[test1],toSchur[test2],1](* inner product calculated using algebraic identities *)

Timing@MacdonaldScalarProduct[test1,test2,$x,1](* inner product calculated using integration *)

{toZonalJ[test1],toZonalJ[test2]}

Timing@MacdonaldScalarProduct[toZonalJ[test1],toZonalJ[test2],2](* inner product calculated using algebraic identities *)

Timing@MacdonaldScalarProduct[test1,test2,$x,2](* inner product calculated using integration *)

Note : given two explicit  symmetric multivariate polynomials, it is much faster to decompose them first on an appropriate basis (Schur, Zonal, etc) and calculate their inner product using the algebraic version of MacdonaldScalarProduct rather performing an n-dimensional integral (second version of MacdonaldScalarProduct).

In the Schur case ($α = 1), the command scalarProductViaSeries does not perform an n-dimensional integral but selects the constant term in a Laurent series.
It is almost as fast as the above algebraic version of MacdonaldScalarProduct and may be easier to use in some cases.

Timing@scalarProductForSchurViaSeries[test1, test2,1]

From Macdonald inner products to the Jack inner product : using the Dyson coefficient

Consider the norm square (using the Macdonald inner product with parameter 2) of the zonal polynomial defined by the partition {3,2,1}, with normalization P, when the number of variables n increases :

Table[MacdonaldScalarProduct[ZP[PadRight[{3,2,1},n,0]],ZP[PadRight[{3,2,1},n,0]],2]/( coefDyson[n,2]),{n,3,20}]

%//N

This sequence increases slowly...

Table[MacdonaldScalarProduct[ZP[PadRight[{3,2,1},n,0]],ZP[PadRight[{3,2,1},n,0]],2]/( coefDyson[n,2]),{n,300,310}]

%//N

with a limit which is given by the Jack scalar product :

{JackScalarProduct[ZonalPolP[{3,2,1}],ZonalPolP[{3,2,1}],2],%//N}

Exercise : using  the fact that the Log of the  Dyson coefficient Log[coefDyson[n,2]]  behaves as

Series[n Log[2]-(1/2) n Log[π]+LogGamma[1+(n/2)]-LogGamma[1+n],{n,Infinity,3}]

one  finds that the Log of the square norm (for the Macdonald inner product with parameter 2)  of the n-variables  zonal polynomial ZP (normalization P) defined by the partition {3,2,1} behaves, when n goes to infinity, as

Log[(100/7)]+ (1/2) (1+Log[2]-Log[n]-Log[π]) n-((Log[2])/2)+(1/(12 n))-(7/(360 (n^3)))+((O[(1/n)])^4)

SU(3) special case (three-variables homogenous symmetric polynomials with condition x1 x2 x3 = 1)

In the Schur case, the code  uses the (semi) magic square algorithm, that works only for SU(3) but is extremely fast.
We could use  the honeycombs-oblade method, which is rather fast and works for all SU(n).
For the zonal, quaternionic or Jack cases, we do not have (yet) alternative... and we have to rely on the general code.

Schur case:  using the  (semi) magic square algorithm

Usage

?HornFull

?magicmult

?SchurProductPairMagicMethod

?SU3MultiplicityYoung

?SU3MultiplicityDynkin

Examples

Choose two extended partitions of length 3, for instance α = {4,3,1} and β = {3,1,0}.
The possible γ’s that appear in the decomposition of α times β are such that Total[α]+Total[β] == Total[γ]  and such that its components γ1,γ2,γ3 lie in the range of the Horn polytope HornFull[α,β]

α={4,3,1};β={3,1,0};
Total[α]+Total[β]
HornFull[α,β]

We can take  γ1=6, γ2=4, γ3=2

γ={6,4,2};

SU(3) reduction on p=(p1,p2,p3) is obtained by performing a constant shift (substract p3) : get q = {p1-p3, p2-p3,0}.
α ⟶{3,2,0},  β⟶{3,1,0}, γ ⟶{4,2,0}
Dynkin components of (q1,q2,0) are [q1-q2, q2]
α ⟶{3,2,0} ⟶ λ = [1,2] ,  β⟶{3,1,0} ⟶ μ = [2,1], γ ⟶{4,2,0} ⟶  ν  = [2,2]
One can obtain directly these Dynkin components by using the command  youngPartitionToHighestWeight :

With[{n=3},Map[youngPartitionToHighestWeight[#,n]&,{α,β,γ} ]]

{λ,μ,ν} = %;

The multiplicity of γ in the product α ⊗ β , or equivalently, of ν  in λ ⊗ μ
is given by

magicmult[λ,μ,Reverse[ν]]
(* Warning-1: arguments of magicmult are Dynkin components, they are not partitions. *)
(* Warning-2: This command actually gives the dimension of the space of intertwiners (Subscript[Hom, SU3])[λ ⊗ μ ⊗ (OverBar[ν])] where (OverBar[ν]) denotes the complex conjugate of the irrep ν; so if one wants the multiplicity of ν in λ⊗ μ one has to reverse the components of ν as in the example. *)

We now do  this calculation for all possible γ’s in one stroke:  here are all the partitions that appear in the product of the 3-variable Schur polynomials Schur s[α] * s[β], and their coefficients (multiplicities).

Timing@SchurProdPairMagicMethod[α,β](* Arguments and results are given in terms of partitions *)

In the case of 3-variables polynomials, and only in this case, using the algorithm that relies on the semi-magic square property og SU(3) intertwiners, ie the command SchurProdPairMagicMethod is extremely fast.  One can of course obtain the same results by using the general  command  toSchurProductPair (cf examples given in a previous section), but it takes much longer time !
Compare timings :

Timing@toSchurProductPair[α,β]//TraditionalForm

Or equivalently

SchurPol[α]//TraditionalForm
SchurPol[β]//TraditionalForm  
toSchur[SchurPol[α]*SchurPol[β]]//TraditionalForm

If one is only interested in the irreducible representations of SU(3) that appear in the tensor product α ⊗ β one has to perform an SU(3) - reduction on the γ’s ie  substract an appropriate multiple of {1,1,1}.
For instance the partition {5,4,3} becomes the partition {5-3, 4-3, 3-3} = {2,1,0} .  The third line of the associated Young diagram being empty (0), it is usual to remove it : one gets the partition {2,1}.
The final result expressed in terms of extended partitions (of length two) is obtained directly

SU3MultiplicityYoung[{1,2},{2,1}](* Arguments are Dynkin components λ, μ and the results are (extended) partitions of length 2 *)

SU3MultiplicityDynkin[{1,2},{2,1}](* Arguments are Dynkin components λ, μ and the results are also Dynkin components *)

Clear[α,β,γ,λ,μ,ν]

Note : the reduction of the tensor product of SU(n) irreducible representations, for any n, can be simply obtained from the notebook tensorprodirrep.nb or even more simply, by using the cdf file (Manipulate commands) tensorprodirrep.cdf , on the same website, that uses an improved version of the  honeycomb algorithm. Follow the link : http://www.cpt.univ-mrs.fr/~coque/Computer_programs/index.html
The user can also finds there other Mathematica notebooks (or cdf files) that draw the honeycombs or a dual version of them called O-blades. 

The present section was included for completeness sake, in order to relate both problems (manipulation of symmetric polynomials, in particular Schur polynomials, and determination of the decomposition of a tensor product of SU(n) irreps), but if one is only interested in the latter problem, one should use  the files  tensorprodirrep.nb or tensorprodirrep.cdf  instead.

Another example

The following command uses symmetric polynomials :

Timing@toSchurProductPair[3{2,1,0},3{2,1,0}]//TraditionalForm

The following command uses the (semi) magic square algorithm -- which is SU(3) specific.

Timing@SchurProdPairMagicMethod[3{2,1,0},3{2,1,0}]

Another example (again: warning about conjugating the third argument)

magicmult[{1,0},{1,0},{1,0}]
(* Warning : this tells us that the dimension of the space of intertwiners Hom({1,0}⊗{1,0}⊗{1,0}-->C) is 1.
From a branching rule perspective one should conjugate the last argument : {1,0}⊗{1,0} contains (0,1) with multiplicity 1 *)

SU3MultiplicityDynkin[{1,0},{1,0}]

Miscellaneous comments

On notations for symmetric polynomials (text)

Notations
There are several families of symmetric polynomials : the most “elementary” ones being those called Elementary symmetric polynomials (notation e), Monomial symmetric polynomials (notation m), Power-sum symmetric polynomials (notation p), Complete homogeneous symmetric polynomials (notation h). Slightly less elementary are the so-called Schur and zonal polynomials. To be specific, one should in principle specify the chosen number n of variables, that I shall call x “=(x1, x2, . . . xn) in the sequel. A member of the above families of polynomials is usually labelled by an integer partition, say κ ={κ1, . . . , κs}, with κj >= κj+1, and by the n-plet of its variables, for instance eκ(x1, x2, . . . xn).
The notations e, m, p, h seem to be standard, nowadays.
Given an integer partition κ, say of length s, and assuming that n >= s it is often convenient, in order to specify the number of variables, to call “Young partition” of length n, or “extended partition” of length n, the  partition that has been obtained from κ by padding 0’s to the right of κ. The length of the obtained partition (no longer an integer partition in the strict sense) is then equal to n, the chosen number of variables. For instance, if we consider 5 variables, the Young partition obtained by extending the length 3 integer partition {2, 1, 1} is {2, 1, 1, 0, 0}. 
Notice that we cannot take n < s, which is usually not a problem because, in general, symmetric functions corresponding to a case n < s either do not make sense, or vanish.
To remember what they are, here a few examples : 

Elementary sums :
e({3, 0, 0, 0)} =  x1x2x3+x1x4x3+x2x4x3+x1x5x3+x2x5x3+x4x5x3+x1x2x4+x1x2x5+x1x4x5+x2x4x5 
e({4,2,1,0)} = x1x2x3x4 (x1x2 +x3x2 +x4x2 +x1x3 +x1x4 +x3x4)(x1 +x2 +x3 +x4)

When there is only one product of elementary sums, another notation is quite standard. 
For instance e({3,0,0,0)} above is often written e3{x1, x2, x3, x4}.

Monomial sums :
m({2, 1)} = x2 x1^2 +  x2^2 x1
m({2, 1, 0})= x2 x1^2 + x3 x1^2 +  x2^2 x1 +  x3^2 x1 + x2 x3^2+  x2^2 x3

Power-sums :
p({2,0,0})=p2(x1,x2,x3) = x1^2 + x2^2 + x3^2
p({1,2,0})=(x1 + x2 + x3)(x1^2 + x2^2 + x3^2)

Complete sums:
h({2, 1, 0}) = (x1^2 +x2^2 +x3^2 +x2 x1 +x3 x1 +x2x3)(x1 +x2 +x3)

Warning : the remark about the fact that one should specify the number of variables is not totally trivial. Indeed, it is not too difficult to find algebraic combinations of power sums, for instance, that are not formally zero, but that become equal to zero when the number of xj variables is too small. Example : the following expression is zero if the number n of x variables is smaller than 4.
23 p1^6 - 105 p2 p1^4 + 152 p3  p1^3 - 93 p2^2 p1^2 - 78 p4 p1^2 + 216 p2 p3 p1 - 48 p5 p1 + 63p2^3 + 8 p3^2 - 114 p2 p4 - 24 p6
See the function algebraicRelationsForPowSum and the discussion in the section about power sums.

It is sometimes convenient to assume that the number of x variables is indeterminate, or infinite. This point of view may simplify the statements but one has to be careful when applying them to cases where the number of variables is finite, and actually “small” (see the discussion in the section Jack inner products).

On notations for symmetric polynomials  (illustration of the previous comments using the SymPolPackage)

elementarySum[{3,0,0,0}]

toElementarySymPol[%]

elementarySum[{4,2,1,0}]

toElementarySymPol[%]

monomialSum[{2,1}]

toMonomialSymPol[%]

monomialSum[{2,1,0}]

toMonomialSymPolSA[%]

powerSum[{2,0,0}]

toPowerSums[%]

powerSum[{1,2,0}]

toPowerSums[%]//Simplify

completeSum[{2,1,0}]

%//TraditionalForm

zerotest=23 p[1]^6 - 105 p[2] p[1]^4 + 152 p[3]  p[1]^3 - 93 p[2]^2 p[1]^2 - 78 p[4] p[1]^2 + 216 p[2] p[3] p[1] - 48 p[5] p[1] + 63p[2]^3 + 8 p[3]^2 - 114 p[2] p[4] - 24 p[6];

With[{n=6},zerotest/.  {p[s_]:>Sum[((x[k])^s),{k,n}]}]//Simplify

With[{n=5},zerotest/.  {p[s_]:>Sum[((x[k])^s),{k,n}]}]//Simplify

With[{n=4},zerotest/.  {p[s_]:>Sum[((x[k])^s),{k,n}]}]//Simplify

With[{n=3},zerotest/.  {p[s_]:>Sum[((x[k])^s),{k,n}]}]//Simplify

Clear@zerotest

Versions

Version 1.0 (September 8, 2018)

Version 1.1 (September 15, 2018)

The functions toSchur, toZonalJ, toZonalC and toZonalP are modified, to take care of  the cases where the argument f, a symmetric polynomial, is not necessarily homogeneous.
A new section : SU(3) special case  was added.

Version 1.2 (September 28, 2018)

The function HallScalarProduct was renamed JackScalarProduct (to prevent possible confusion), and the syntax was changed.  See Usage (?).

Version 1.3 (September 28, 2018)

A new version of toPol was introduced: it introduces a simplifying shift on the partition (compensated by appropriate pre-factors).
Only the polynomial obtained after this simplification is kept (then toPol uses the old toPol renamed toPolbasic at the internal level, and toPolbasic calls the x-polynomial itself).
All the functions that determine structure constants (like toSchurProductPair, toJackProductPair, etc.) were re-written using the above, and renamed toXXXProductPair rather than toSchurProdPair.
The code for the Jack inner product was also modified to take the new toPol into account.
A new section Essentials : basic commands has been added at the beginning of the SymPol$Example.nb file (this file).