Bases: sage.combinat.sf.classical.SymmetricFunctionAlgebra_classical
A class for methods related to the Schur symmetric function basis
INPUT:
TESTS:
sage: s = SymmetricFunctions(QQ).s()
sage: s == loads(dumps(s))
True
sage: TestSuite(s).run(skip=['_test_associativity', '_test_distributivity', '_test_prod'])
sage: TestSuite(s).run(elements = [s[1,1]+s[2], s[1]+2*s[1,1]])
Bases: sage.combinat.sf.classical.SymmetricFunctionAlgebra_classical.Element
Create a combinatorial module element. This should never be called directly, but only through the parent combinatorial free module’s __call__() method.
TESTS:
sage: F = CombinatorialFreeModule(QQ, ['a','b','c'])
sage: B = F.basis()
sage: f = B['a'] + 3*B['c']; f
B['a'] + 3*B['c']
sage: f == loads(dumps(f))
True
Expands the symmetric function as a symmetric polynomial in variables.
INPUT:
OUTPUT: a monomial expansion of an instance of self in variables
EXAMPLES:
sage: s = SymmetricFunctions(QQ).s()
sage: a = s([2,1])
sage: a.expand(2)
x0^2*x1 + x0*x1^2
sage: a.expand(3)
x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2
sage: a.expand(4)
x0^2*x1 + x0*x1^2 + x0^2*x2 + 2*x0*x1*x2 + x1^2*x2 + x0*x2^2 + x1*x2^2 + x0^2*x3 + 2*x0*x1*x3 + x1^2*x3 + 2*x0*x2*x3 + 2*x1*x2*x3 + x2^2*x3 + x0*x3^2 + x1*x3^2 + x2*x3^2
sage: a.expand(2, alphabet='y')
y0^2*y1 + y0*y1^2
sage: a.expand(2, alphabet=['a','b'])
a^2*b + a*b^2
sage: s([1,1,1,1]).expand(3)
0
sage: (s([]) + 2*s([1])).expand(3)
2*x0 + 2*x1 + 2*x2 + 1
Return the image of self under the omega automorphism.
The omega automorphism is defined to be the unique algebra
endomorphism of the ring of symmetric functions that
satisfies
for all positive integers
(where
stands for the
-th elementary symmetric
function, and
stands for the
-th complete homogeneous
symmetric function). It furthermore is a Hopf algebra
endomorphism, and sends the power-sum symmetric function
to
for every positive integer
.
The default implementation converts to the Schurs, then performs the automorphism and changes back.
OUTPUT:
EXAMPLES:
sage: s = SymmetricFunctions(QQ).s()
sage: s([2,1]).omega()
s[2, 1]
sage: s([2,1,1]).omega()
s[3, 1]
Returns the standard scalar product between self and .
Note that the Schur functions are self-dual with respect to this scalar product. They are also lower-triangularly related to the monomial symmetric functions with respect to this scalar product.
INPUT:
OUTPUT:
EXAMPLES:
sage: s = SymmetricFunctions(ZZ).s()
sage: a = s([2,1])
sage: b = s([1,1,1])
sage: c = 2*s([1,1,1])
sage: d = a + b
sage: a.scalar(a)
1
sage: b.scalar(b)
1
sage: b.scalar(a)
0
sage: b.scalar(c)
2
sage: c.scalar(c)
4
sage: d.scalar(a)
1
sage: d.scalar(b)
1
sage: d.scalar(c)
2
sage: m = SymmetricFunctions(ZZ).monomial()
sage: p4 = Partitions(4)
sage: l = [ [s(p).scalar(m(q)) for q in p4] for p in p4]
sage: matrix(l)
[ 1 0 0 0 0]
[-1 1 0 0 0]
[ 0 -1 1 0 0]
[ 1 -1 -1 1 0]
[-1 2 1 -3 1]
Return the image of the symmetric function self under the
-th Verschiebung operator.
The -th Verschiebung operator
is defined to be
the unique algebra endomorphism
of the ring of symmetric
functions that satisfies
for every positive
integer
divisible by
, and satisfies
for
every positive integer
not divisible by
. This operator
is a Hopf algebra endomorphism. For every
nonnegative integer
with
, it satisfies
(where is the complete homogeneous basis,
is the
powersum basis, and
is the elementary basis). For every
nonnegative integer
with
, it satisfes
The -th Verschiebung operator is also called the
-th
Verschiebung endomorphism. Its name derives from the Verschiebung
(German for “shift”) endomorphism of the Witt vectors.
The -th Verschiebung operator is adjoint to the
-th
Frobenius operator (see frobenius() for its definition)
with respect to the Hall scalar product (scalar()).
The action of the -th Verschiebung operator on the Schur basis
can also be computed explicitly. The following (probably clumsier
than necessary) description can be obtained by solving exercise
7.61 in Stanley’s [STA].
Let be a partition. Let
be a positive integer. If
the
-core of
is nonempty, then
. Otherwise, the following method
computes
: Write the partition
in the form
for some
nonnegative integer
. (If
does not divide the length of
, then this is achieved by adding trailing zeroes to
.) Set
for every
. Then,
is a strictly decreasing
sequence of nonnegative integers. Stably sort the list
in order of (weakly) increasing remainder of
modulo
. Let
be the sign of the
permutation that is used for this sorting. Let
be the sign
of the permutation that is used to stably sort the list
in order of (weakly) increasing remainder of
modulo
. (Notice that
.)
Then,
, where
is the
-quotient of
.
INPUT:
OUTPUT:
The result of applying the -th Verschiebung operator (on the ring of
symmetric functions) to self.
EXAMPLES:
sage: Sym = SymmetricFunctions(ZZ)
sage: s = Sym.s()
sage: s[5].verschiebung(2)
0
sage: s[6].verschiebung(6)
s[1]
sage: s[6,3].verschiebung(3)
s[2, 1] + s[3]
sage: s[6,3,1].verschiebung(2)
-s[3, 2]
sage: s[3,2,1].verschiebung(1)
s[3, 2, 1]
sage: s([]).verschiebung(1)
s[]
sage: s([]).verschiebung(4)
s[]
TESTS:
Let us check that this method on the powersum basis gives the same result as the implementation in sfa.py on the monomial basis:
sage: Sym = SymmetricFunctions(QQ)
sage: s = Sym.s(); h = Sym.h()
sage: all( h(s(lam)).verschiebung(3) == h(s(lam).verschiebung(3))
....: for lam in Partitions(6) )
True
sage: all( s(h(lam)).verschiebung(2) == s(h(lam).verschiebung(2))
....: for lam in Partitions(4) )
True
sage: all( s(h(lam)).verschiebung(5) == s(h(lam).verschiebung(5))
....: for lam in Partitions(10) )
True
sage: all( s(h(lam)).verschiebung(2) == s(h(lam).verschiebung(2))
....: for lam in Partitions(8) )
True
sage: all( s(h(lam)).verschiebung(3) == s(h(lam).verschiebung(3))
....: for lam in Partitions(12) )
True
sage: all( s(h(lam)).verschiebung(3) == s(h(lam).verschiebung(3))
....: for lam in Partitions(9) )
True
Returns the coproduct of self(mu).
Here self is the basis of Schur functions in the ring of symmetric functions.
INPUT:
OUTPUT:
EXAMPLES:
sage: Sym = SymmetricFunctions(QQ)
sage: s = Sym.schur()
sage: s.coproduct_on_basis([2])
s[] # s[2] + s[1] # s[1] + s[2] # s[]