Element Operations#

Parent and Category#

The category for elements in algebras of symmetric functions is AlgSymElt.

Parent(f): AlgSymElt -> AlgSym#
Category(f): AlgSymElt -> Cat#

Additive Arithmetic Operators#

The usual unary and binary ring element operations are available for symmetric functions. It is possible to combine elements of different algebras (so long as the coefficient rings are compatible) in these operations. Where the elements are written with respect to different bases, the result will be written with respect to the basis of the second operand.

+ a: AlgSymElt -> AlgSymElt#
- a: AlgSymElt -> AlgSymElt#
a + b: AlgSymElt, AlgSymElt -> AlgSymElt#
a - b: AlgSymElt, AlgSymElt -> AlgSymElt#
a +:= b: AlgSymElt, AlgSymElt -> AlgSymElt#
a -:= b: AlgSymElt, AlgSymElt -> AlgSymElt#

Multiplication#

Where the elements being multiplied are expressed with respect to different bases, the result will again be expressed with respect to the basis of the second operand. The algorithm used for multiplication is dependent on the bases with respect to which the elements are expressed.

a * b: AlgSymElt, AlgSymElt -> AlgSymElt#
a *:= b: AlgSymElt, AlgSymElt -> AlgSymElt#

The product of the symmetric functions \(a\) and \(b\).

If \(b\) is expressed with respect to a Schur basis and \(a\) is expressed with respect to a power sum, elementary or monomial basis then the algorithm based on Muirs rule [Muir, 1960] is used. If \(a\) is expressed with respect to a homogeneous basis the algorithm based on the Pieri rule [Macdonald, 1995] is used and if \(a\) is also expressed with respect to a Schur basis then the method of Schubert polynomials [Lascoux and Schützenberger, 1985] is used.

Special algorithms are also used if \(b\) is expressed with respect to a monomial basis and \(a\) is expressed with respect to a homogeneous, elementary or monomial basis.

When both \(a\) and \(b\) have a homogeneous, elementary or power sum basis, the multiplication of basis elements involves the merging of the parts of the partitions. This follows from the definition of the basis elements \(f_\lambda = \prod_i f_{\lambda_i}\) where \(f_\lambda\) is a homogeneous, elementary or power sum basis element.

Otherwise \(a\) is coerced into the parent of \(b\) before the elements are multiplied.

The degree of the result is the sum of the degrees of both the operands.

a ^ k: AlgSymElt, RngIntElt -> AlgSymElt#
Example: mult (ex-cf1c1c)#
> Q := Rationals();
> s := SFASchur(Q);
> m := SFAMonomial(Q);
> m.[3]*s.[2,1];
s.[2,1,1,1,1] + s.[5,1] - s.[2,2,2] - s.[3,3]

Run in calculator

To illustrate the merging of the partitions :

> E := SFAElementary(Q);
> E.4*E.3*E.1;
E.[4,3,1]

Run in calculator

This is the definition of \(e_{[4, 3, 1]}\).

Plethysm#

Plethysm is also referred to as composition of symmetric functions.

a ~ b: AlgSymElt, AlgSymElt -> AlgSymElt#

This operator computes the plethysm or composition of the symmetric functions \(a\) and \(b\). The result is given with respect to the basis of the second operand.

The degree of the result is the product of the degrees of operands which may be very large.

Example: pleth (ex-107368)#
> Q := Rationals();
> s := SFASchur(Q);
> m := SFAMonomial(Q);
> m.[3]~s.[2,1];
s.[4,1,1,1,1,1] - s.[3,2,1,1,1,1] - s.[5,1,1,1,1] + s.[2,2,2,1,1,1] +
s.[3,3,1,1,1] + s.[6,1,1,1] - s.[2,2,2,2,1] - s.[3,3,2,1] - s.[6,2,1] +
s.[4,4,1] + s.[3,2,2,2] + s.[5,2,2] - s.[4,3,2] + 2*s.[3,3,3] + s.[6,3] -
s.[5,4]

Run in calculator

Boolean Operators#

IsHomogeneous(s): AlgSymElt -> BoolElt#

Returns true if the partitions indexing the basis elements present in the symmetric function \(s\) are all of the same weight. This implies that each term has the same degree so is the same as the polynomial expansion of \(s\) being a homogeneous polynomial.

IsZero(s): AlgSymElt -> BoolElt#
IsOne(s): AlgSymElt -> BoolElt#
IsMinusOne(s): AlgSymElt -> BoolElt#
s eq t: AlgSymElt, AlgSymElt -> BoolElt#
s ne t: AlgSymElt, AlgSymElt -> BoolElt#

Return true if the symmetric functions \(s\) and \(t\) are (not) the same.

Accessing Elements#

Coefficient(s, p): AlgSymElt, SeqEnum -> RngElt#

Given a symmetric function \(s\) return the coefficient of the basis element \(A_p\), where \(A\) is the parent of \(s\) and \(p\) is a sequence defining a partition. The coefficient may be zero.

Support(s): AlgSymElt -> [SeqEnum], [RngElt]#

Return two parallel sequences of the partitions indexing the basis elements and the coefficients of those basis elements in the symmetric function \(s\), which is a linear combination of basis elements.

Length(s): AlgSymElt -> RngIntElt#

Given a symmetric function \(s\), return the length of \(s\), i.e., the number of basis elements having non zero coefficients in \(s\), with respect to the current basis.

Example: support (ex-4a300f)#

We pull apart an element and show that we can put it back together again.

> H := SFAHomogeneous(Rationals());
> P := Partitions(4);
> f := &+[Random(1, 5)*H.p : p in P];
> f;
H.[1,1,1,1] + 4*H.[2,1,1] + 4*H.[2,2] + 5*H.[3,1] + 5*H.[4]
> s, e := Support(f);
> s, e;
[
    [ 1, 1, 1, 1 ],
    [ 2, 1, 1 ],
    [ 2, 2 ],
    [ 3, 1 ],
    [ 4 ]
]
[ 1, 4, 4, 5, 5 ]
> f eq &+[e[i]*H.s[i] : i in [1 .. Length(f)]];
true

Run in calculator

Degree(s): AlgSymElt -> RngIntElt#

Given a symmetric function \(s\), return the degree of \(s\), i.e., the maximal degree of the basis elements having non zero coefficients in \(s\), which is the maximal weight of the partitions indexing those basis elements.

Multivariate Polynomials#

A symmetric function may be seen as a polynomial in any number of variables.

P ! s: RngMPol, AlgSymElt -> RngMPolElt#

Return the polynomial expansion of the symmetric function \(s\) in the polynomial ring \(P\).

Example: symmetric polynomials and symmetric functions (ex-10b1c4)#
> S := SFASchur(GF(7));
> s := S.[3,1];

Run in calculator

Now we compute the multivariate polynomial we get by restricting to \(5\) variables.

> G<e1, e2, e3, e4, e5> := PolynomialRing(GF(7), 5);
> p := G!s;
> p;
e1^3*e2 + e1^3*e3 + e1^3*e4 + e1^3*e5 + e1^2*e2^2 + 2*e1^2*e2*e3 + 2*e1^2*e2*e4
    + 2*e1^2*e2*e5 + e1^2*e3^2 + 2*e1^2*e3*e4 + 2*e1^2*e3*e5 + e1^2*e4^2 +
    2*e1^2*e4*e5 + e1^2*e5^2 + e1*e2^3 + 2*e1*e2^2*e3 + 2*e1*e2^2*e4 +
    2*e1*e2^2*e5 + 2*e1*e2*e3^2 + 3*e1*e2*e3*e4 + 3*e1*e2*e3*e5 + 2*e1*e2*e4^2 +
    3*e1*e2*e4*e5 + 2*e1*e2*e5^2 + e1*e3^3 + 2*e1*e3^2*e4 + 2*e1*e3^2*e5 +
    2*e1*e3*e4^2 + 3*e1*e3*e4*e5 + 2*e1*e3*e5^2 + e1*e4^3 + 2*e1*e4^2*e5 +
    2*e1*e4*e5^2 + e1*e5^3 + e2^3*e3 + e2^3*e4 + e2^3*e5 + e2^2*e3^2 +
    2*e2^2*e3*e4 + 2*e2^2*e3*e5 + e2^2*e4^2 + 2*e2^2*e4*e5 + e2^2*e5^2 + e2*e3^3
    + 2*e2*e3^2*e4 + 2*e2*e3^2*e5 + 2*e2*e3*e4^2 + 3*e2*e3*e4*e5 + 2*e2*e3*e5^2
    + e2*e4^3 + 2*e2*e4^2*e5 + 2*e2*e4*e5^2 + e2*e5^3 + e3^3*e4 + e3^3*e5 +
    e3^2*e4^2 + 2*e3^2*e4*e5 + e3^2*e5^2 + e3*e4^3 + 2*e3*e4^2*e5 + 2*e3*e4*e5^2
    + e3*e5^3 + e4^3*e5 + e4^2*e5^2 + e4*e5^3

Run in calculator

To check the polynomial is actually symmetric, we can use the Magma intrinsic IsSymmetric, which also computes an expansion as a sum of elementary symmetric polynomials.

> IsSymmetric(p,G);
true e1^2*e2 + 6*e1*e3 + 6*e2^2 + e4

Run in calculator

Which is identical to the result of

> E := SFAElementary(GF(7));
> E!s;
E.[2,1,1] + 6*E.[2,2] + 6*E.[3,1] + E.[4]

Run in calculator

Example: Change Of Alphabet (ex-86835b)#

These conversions may be used to change the alphabet of a symmetric function. For example, if we substitute the variable \(x_i\) by \(x_i + 1\), the result is again a symmetric function, however we use polynomials to do the evaluation.

> S := SFASchur(Rationals());
> R<a, b, c, d, e> := PolynomialRing(Rationals(), 5);
> p := Polynomial(S.[3,2], R);
> q := Evaluate(p, [a+1, b+1, c+1, d+1, e+1]);
> x, y := IsCoercible(S, q);
> y;
175 + 175*S.[1] + 70*S.[1,1] + 70*S.[2] + 35*S.[2,1] + 7*S.[2,2] + 10*S.[3] +
5*S.[3,1] + S.[3,2]

Run in calculator

Frobenius Homomorphism#

There is an automorphism which maps the elementary symmetric function to the homogeneous symmetric function.

Frobenius(s): AlgSymElt -> AlgSymElt#

Given any symmetric function \(s\), compute the image of \(s\) under the Frobenius automorphism. The image will have the same parent as \(s\). When the power sum symmetric functions are involved, it may be necessary to work with a coefficient ring which allows division by an integer.

Example: Frobenius automorphism (ex-41dc58)#

It is known that the Frobenius automorphism on the Schur functions acts just by conjugating the indexing partitions.

> S := SFASchur(Integers());
> E := SFAElementary(Integers());
> h := S!E.[3,3,3];
> h;
S.[1,1,1,1,1,1,1,1,1] + 2*S.[2,1,1,1,1,1,1,1] + S.[3,1,1,1,1,1,1] +
3*S.[2,2,1,1,1,1,1] + 2*S.[3,2,1,1,1,1] + 4*S.[2,2,2,1,1,1] + S.[3,3,1,1,1] +
3*S.[3,2,2,1,1] + 2*S.[2,2,2,2,1] + 2*S.[3,3,2,1] + S.[3,2,2,2] + S.[3,3,3]

Run in calculator

Now apply the Frobenius automorphism.

> f:=Frobenius(h);
> f;
S.[3,3,3] + 2*S.[4,3,2] + S.[4,4,1] + S.[5,2,2] + 3*S.[5,3,1] + 2*S.[5,4] +
2*S.[6,2,1] + 4*S.[6,3] + S.[7,1,1] + 3*S.[7,2] + 2*S.[8,1] + S.[9]

Run in calculator

To check whether the coefficient of the basis element indexed by a partition in one element is the same as the coefficient of the basis element indexed by the conjugate partition in the other :

> p:=Partitions(f);
> for pp in p do
>    if Coefficient(h, ConjugatePartition(pp)) ne Coefficient(f, pp) then
>       print pp;
>    end if;
> end for;

Run in calculator

Inner Product#

An inner product on \(\Lambda\) is defined by

\[\langle m_\lambda, h_{\lambda '}\rangle = \delta_{\lambda,\lambda '}.\]

This definition ensures that the bases \({m_\lambda}\) and \({h_\lambda}\) are dual to each other. This is the inner product used by Magma.

InnerProduct(a, b): AlgSymElt, AlgSymElt -> RngElt#

Computes the inner product of the symmetric functions \(a\) and \(b\).

Example: Inner Product (ex-71d4ca)#

The inner product of a elementary symmetric function indexed by a partition and the homogeneous symmetric function indexed by the conjugate partition is \(1\). (This allows the computation of irreducible representations of the symmetric group.) To check this with Magma, we do the following:

> E := SFAElementary(Rationals());
> H := SFAHomogeneous(Rationals());
> p:=RandomPartition(45);
> pc:=ConjugatePartition(p);
> InnerProduct(E.p,H.pc);
1

Run in calculator

As it should be the result is 1.

Combinatorial Objects#

The Schur function is the generating function of standard tableaux. Therefore, it is possible to get the corresponding tableaux.

Tableaux(sf, m): AlgSymElt, RngIntElt -> SetMulti#

Given a Schur function \(sf\) over the integers with positive coefficients, return the multiset of the tableaux, with maximal entry \(m\), for which \(sf\) is the generating function.

Symmetric Group Character#

A Schur function indexed by a single partition, i.e. a basis element, corresponds to an irreducible character of the symmetric group.

SymmetricCharacter(sf): AlgSymElt -> AlgChtrElt#

Given an element \(sf\) of an algebra of symmetric functions return a linear combination of irreducible characters of the symmetric group, whose coefficients are the coefficients of \(sf\) with respect to the Schur function basis.

Example: Symmetric Polynomials And Symmetric Functions (ex-102778)#

We look at a result in the representation theory of the symmetric group. There is exactly one irreducible character contained in both the induced character from the identity character of a Young subgroup indexed by the partition \(I\) and the induced character from the alternating character of a Young subgroup indexed by the partition \(J\), conjugate to \(I\). As the induced character of the identity character of a Young subgroup corresponds to the homogeneous symmetric function \(h_I\) and the induced character of the alternating character corresponds to the elementary symmetric function \(e_J\), we can verify this using the following routine:

> H := SFAHomogeneous(Rationals());
> E := SFAElementary(Rationals());
> p := Partitions(7);
> for I in p do
>     a := SymmetricCharacter(H.I);
>     J := ConjugatePartition(I);
>     b := SymmetricCharacter(E.J);
>     i := InnerProduct(a,b);
>     if i ne 1 then print i; end if;
> end for;

Run in calculator

And there should be no output.

Restrictions#

It is possible to form symmetric functions whose support is a subset of the support of a given symmetric function, subject to some restrictions.

RestrictDegree(a, n): AlgSymElt, RngIntElt -> AlgSymElt#
Exact: BoolElt                    Default: true

Return the symmetric function which is a linear combination of those basis elements of the symmetric function \(a\) with degree \(n\). This is the restriction of \(a\) into the submodule \(\Lambda^n\). If Exact is false then the basis elements included will have degree \(\le n\). This is the restriction of \(a\) into \(\bigcup_{k \le n} \Lambda^k\).

RestrictPartitionLength(a, n): AlgSymElt, RngIntElt -> AlgSymElt#
Exact: BoolElt                    Default: true

Return the symmetric function which is a linear combination of those basis elements of the symmetric function \(a\) whose indexing partitions are of length \(n\). If Exact is false, then the indexing partitions will be of length \(\le n\).

RestrictParts(a, n): AlgSymElt, RngIntElt -> AlgSymElt#
Exact: BoolElt                    Default: true

Return the symmetric function which is a linear combination of those basis elements of the symmetric function \(a\) whose indexing partitions have maximal part \(n\). If Exact is false, then the indexing partitions will have maximal part \(\le n\).

On this page