Affine Stanley symmetric functions
system:sage


<p>The goal of this talk is to</p>
<ul>
<li>learn how to use symmetric functions</li>
<li>learn how to use affine Stanley symmetric functions</li>
<li>use the set-up that Jason introduced to make them live in the right space</li>
</ul>

<p><strong><span style="font-size: xx-large;">Getting Started: Symmetric functions</span></strong></p>

{{{id=18|
SF = SymmetricFunctions(QQ);
SF.inject_shorthands();
///
}}}

{{{id=19|
h
///
}}}

{{{id=20|
e
///
}}}

{{{id=21|
s
///
}}}

{{{id=22|
m
///
}}}

{{{id=23|
m(s[2,1])
///
}}}

{{{id=24|
s(m[3,1])
///
}}}

{{{id=25|
ks3 = kSchurFunctions(QQ, 3); ks3
///
}}}

{{{id=27|
ks3.base_ring()
///
}}}

{{{id=28|
s = SFASchur(ks3.base_ring())
///
}}}

{{{id=26|
s(ks3[3,3,1])
///
}}}

{{{id=29|
ks3 = kSchurFunctions(QQ, 3, 1); ks3
///
}}}

{{{id=30|
s = SFASchur(ks3.base_ring())
///
}}}

{{{id=31|
s(ks3[3,3,1])
///
}}}

{{{id=32|
ks3(ks3[3,1]*ks3[2,1])
///
}}}

<p><strong><span style="font-size: xx-large;">Affine Stanley symmetric functions</span></strong></p>
<p>implemented by Steve Pon, Nicolas Thiery, ...</p>

{{{id=34|
W = WeylGroup(['A', 3, 1])
w = W.from_reduced_word([3,1,2,0,3,1,0])
w
///
}}}

{{{id=35|
w.stanley_symmetric_function()
///
}}}

{{{id=36|
w.stanley_symmetric_function??
///
}}}

{{{id=37|
w.stanley_symmetric_function_as_polynomial??
///
}}}

{{{id=38|
W = WeylGroup(['C',3,1])
W.from_reduced_word([0,2,1,0]).stanley_symmetric_function()
///
}}}

{{{id=33|
W = WeylGroup(['B',3,1])
W.from_reduced_word([3,2,1]).stanley_symmetric_function()
///
}}}

{{{id=41|
mu = Partition([2,1])
mu.from_kbounded_to_grassmannian(2)
///
}}}

{{{id=39|
def dual_k_schur(mu, k):
    return Partition(mu).from_kbounded_to_grassmannian(k).stanley_symmetric_function()
///
}}}

{{{id=42|
dual_k_schur([3,1],3)
///
}}}

{{{id=44|
p = SFAPower(QQ)
p(dual_k_schur([3,1],3))
///
}}}

<p><strong><span style="font-size: xx-large;">Quotient Space</span></strong></p>

<p>Now we let the Stanley symmetric functions live in the quotient space</strong></p>

{{{id=12|
class SFQuotient_basis(CombinatorialFreeModule):

    def __init__(self, R, k, basis_name):
        self._basis = basis_name
        self._prefix = basis_name
        CombinatorialFreeModule.__init__(self, R,
            Partitions(NonNegativeIntegers(), max_part=k),
            category = GradedHopfAlgebrasWithBasis(R))
        self.k = k
        self.SF = SymmetricFunctions(R)
///
}}}

{{{id=7|
class SFQuotient_basis_classical(SFQuotient_basis):

    def __init__(self, R, k, classical):
        assert classical in ['m','p']
        prefix = classical + classical
        SFQuotient_basis.__init__(self, R, k, prefix)
        if classical=='m':
            self._ambient = self.SF.monomial()
        else:
            self._ambient = self.SF.power()

        self._module_morphism(self._ambient.monomial).register_as_coercion()
        self._ambient._module_morphism(self.retract_on_basis, codomain=self).register_as_coercion()

    def retract_on_basis(self, mu):
        return self.monomial(mu) if (len(mu) == 0 or mu[0] <= self.k) else self.zero()
///
}}}

{{{id=6|
class Dual_ks(SFQuotient_basis):

    def __init__(self, R, k):
        self._ambient = SFQuotient_basis_classical(R, k, 'm')
        SFQuotient_basis.__init__(self, R, k,'dk')
        lift = self._module_morphism(self.lift_on_basis, codomain=self._ambient,
                                     triangular='upper')
        lift.register_as_coercion()
        (~lift).register_as_coercion()

    def lift_on_basis(self, mu):
        return self._ambient(mu.from_kbounded_to_grassmannian(self.k).
                             stanley_symmetric_function())
///
}}}

{{{id=13|
SF = SymmetricFunctions(QQ); SF.inject_shorthands()
mm = SFQuotient_basis_classical(QQ, 3, 'm') # m basis of quotient
pp = SFQuotient_basis_classical(QQ, 3, 'p') # p basis of quotient
dk3 = Dual_ks(QQ, 3) # dual k-Schur basis of quotient
///
}}}

{{{id=3|
P53 = Partitions(5, max_part=3)
for mu in P53:  # Expand dual k-Schur functions into power sums
    print p(dk3(mu))
///
}}}

{{{id=48|
for mu in P53:  # Expand dual k-Schurs into power sums of the quotient
    print pp(dk3(mu))
///
}}}

{{{id=4|
for mu in P53:
    print dk3(p(mu))  # Expand power sums into dual k-Schurs
///
}}}

{{{id=49|
for mu in P53:
    print dk3(pp(mu))  # Expand power sums of quotient into dual k-Schurs
///
}}}

{{{id=10|
for mu in P53:
    print m(dk3(mu))  # Expand dual k-Schurs into monomials
///
}}}

{{{id=45|
for mu in P53:
    print dk3(m(mu))  # Expand monomials into dual k-Schurs
///
}}}

{{{id=11|
for mu in P53:
    print pp(p(m(mm(dk3(mu)))))
///
}}}

{{{id=14|
for mu in Partitions(5):
    print dk3(s(mu))
///
}}}