|
The category for elements in algebras of symmetric functions
is
AlgSymElt.
Parent(f) : AlgSymElt -> AlgSym
Category(f) : AlgSymElt -> Cat
By default, elements are printed using a lexicographical ordering on the
partitions indexing the basis elements. For partitions of the same weight w
this ordering is the reverse of that in Partitions(w). More generally,
basis elements indexed by partitions with smaller entries print first
(see Testing Order Relations).
It is possible to rearrange the linear combination
of basis elements so that the basis elements indexed by the longest partition
print first and also so that the basis elements indexed by the partition
with greatest maximal part (first entry) print first.
Retrieve or set the style in which elements of the algebra A will print. The default
is the lexicographical ordering described above, "Lex". Other options
are "Length" and "MaximalPart".
We demonstrate the setting of the PrintStyle and the corresponding
printing of elements.
> M := SFAMonomial(Rationals());
> M`PrintStyle;
Lex
> P := Partitions(3);
> P;
[
[ 3 ],
[ 2, 1 ],
[ 1, 1, 1 ]
]
> f := &+[M.p : p in P];
> f;
M.[1,1,1] + M.[2,1] + M.[3]
> M`PrintStyle := "Length";
> f;
M.[3] + M.[2,1] + M.[1,1,1]
> M`PrintStyle := "MaximalPart";
> f;
M.[1,1,1] + M.[2,1] + M.[3]
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
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 ^ k : AlgSymElt, RngIntElt -> 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 [Mui60] is used. If a is expressed with respect to
a homogeneous basis the algorithm based on the Pieri rule [Mac95] is used
and if a is also expressed with respect to a Schur basis then the method of
Schubert polynomials [LS85] 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λ = ∏i fλi where fλ 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.
> 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]
To illustrate the merging of the partitions :
> E := SFAElementary(Q);
> E.4*E.3*E.1;
E.[4,3,1]
This is the definition of e [4, 3, 1].
Plethysm is also referred to as composition of symmetric functions.
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.
> 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]
IsZero(s) : AlgSymElt -> BoolElt
IsOne(s) : AlgSymElt -> BoolElt
IsMinusOne(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.
s ne t : AlgSymElt, AlgSymElt -> BoolElt
Return true if the symmetric functions s and t are (not) the same.
Given a symmetric function s return the coefficient of the basis
element Ap, where A is the parent of s and p is a sequence
defining a partition. The coefficient may be zero.
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.
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.
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
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.
A symmetric function may be seen as a polynomial in any number of
variables.
Return the polynomial expansion of the symmetric function s in the polynomial ring P.
> S := SFASchur(GF(7));
> s := S.[3,1];
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
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
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]
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]
There is an automorphism which maps the elementary symmetric function to
the homogeneous symmetric function.
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.
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]
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]
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;
An inner product on Λ is defined by
< mλ, hλ ' > = δλ, λ '.
This definition ensures that the bases (mλ) and (hλ) are
dual to each other. This is the inner product used by Magma.
Computes the inner product of the symmetric functions a and b.
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
As it should be the result is 1.
The Schur function is the generating function of standard tableaux.
Therefore, it is possible to get the corresponding tableaux.
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.
A Schur function indexed by a single partition, i.e. a basis element,
corresponds to an irreducible character of the symmetric
group.
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.
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;
And there should be no output.
It is possible to form symmetric functions
whose support is a subset of the support of a given symmetric function, subject
to some restrictions.
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 Λn. If Exact is false then
the basis elements included will have degree ≤n. This is the restriction
of a into bigcupk ≤n Λk.
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 ≤n.
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 ≤n.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|