def __init__(self, R):
"""
Initialize ``self``.
EXAMPLES::
sage: NCSymD1 = SymmetricFunctionsNonCommutingVariablesDual(FiniteField(23))
sage: NCSymD2 = SymmetricFunctionsNonCommutingVariablesDual(Integers(23))
sage: TestSuite(SymmetricFunctionsNonCommutingVariables(QQ).dual()).run()
"""
# change the line below to assert(R in Rings()) once MRO issues from #15536, #15475 are resolved
assert(R in Fields() or R in Rings()) # side effect of this statement assures MRO exists for R
self._base = R # Won't be needed once CategoryObject won't override base_ring
category = GradedHopfAlgebras(R) # TODO: .Commutative()
Parent.__init__(self, category=category.WithRealizations())
# Bases
w = self.w()
# Embedding of Sym in the homogeneous bases into DNCSym in the w basis
Sym = SymmetricFunctions(self.base_ring())
Sym_h_to_w = Sym.h().module_morphism(w.sum_of_partitions,
triangular='lower',
inverse_on_support=w._set_par_to_par,
codomain=w, category=category)
Sym_h_to_w.register_as_coercion()
self.to_symmetric_function = Sym_h_to_w.section()
def __init__(self, R):
"""
Initialize ``self``.
EXAMPLES::
sage: TestSuite(SymmetricFunctionsNonCommutingVariables(QQ).dual()).run()
"""
self._base = R # Won't be needed once CategoryObject won't override base_ring
category = GradedHopfAlgebras(R) # TODO: .Commutative()
Parent.__init__(self, category=category.WithRealizations())
# Bases
w = self.w()
# Embedding of Sym in the homogeneous bases into DNCSym in the w basis
Sym = SymmetricFunctions(self.base_ring())
Sym_h_to_w = Sym.h().module_morphism(
w.sum_of_partitions,
triangular='lower',
inverse_on_support=w._set_par_to_par,
codomain=w,
category=category)
Sym_h_to_w.register_as_coercion()
self.to_symmetric_function = Sym_h_to_w.section()
def __init__(self, Sym, k, t='t'):
r"""
The class modeling the abstract vector space of `k`-Schur functions; if `t=1` this
is actually an abstract ring. Another way to describe this space is as the subspace of
a ring of symmetric functions generated by the complete homogeneous symmetric functions
`h_i` for `1\le i \le k`.
TESTS::
sage: Sym = SymmetricFunctions(QQ)
sage: from sage.combinat.sf.new_kschur import KBoundedSubspace
sage: L3 = KBoundedSubspace(Sym,3,1)
sage: TestSuite(L3).run(skip=["_test_not_implemented_methods"])
sage: Sym.kBoundedSubspace(0,1)
Traceback (most recent call last):
...
ValueError: k must be a positive integer
sage: Sym = SymmetricFunctions(QQ['t'])
sage: TestSuite(Sym.kBoundedSubspace(1)).run(skip=["_test_not_implemented_methods"])
"""
if not isinstance(k, (int, Integer)) or (k < 1):
raise ValueError, "k must be a positive integer"
if not isinstance(Sym,SymmetricFunctions):
raise ValueError, "Sym must be an algebra of symmetric functions"
self.indices = ConstantFunction(Partitions_all_bounded(k))
R = Sym.base_ring()
# The following line is a work around for the fact that Parent defines
# self.base_ring as NotImplemented, hence it cannot be defined by the
# category framework.
self.base_ring = ConstantFunction(R)
self.ambient = ConstantFunction(Sym)
self.k = k
self.t = R(t)
category = GradedHopfAlgebras(R) if t == 1 else GradedCoalgebras(R)
Parent.__init__(self, category = category.Subobjects().WithRealizations())
ks = self.kschur()
# Coercions
if t == 1:
s = ks.ambient()
kh = self.khomogeneous(); h = kh.ambient()
h_to_s = s.coerce_map_from(h)
kh_to_ks = ks.retract * h_to_s * kh.lift
ks.register_coercion(kh_to_ks)
s_to_h = h.coerce_map_from(s)
ks_to_kh = kh.retract * s_to_h * ks.lift
kh.register_coercion(ks_to_kh)
# temporary workaround until handled by trac 125959
self.one = ConstantFunction(ks.one())
self.zero = ConstantFunction(ks.zero())
def __init__(self, R):
"""
The Hopf algebra of quasi-symmetric functions.
See ``QuasiSymmetricFunctions`` for full documentation.
EXAMPLES::
sage: QuasiSymmetricFunctions(QQ)
Quasisymmetric functions over the Rational Field
sage: TestSuite(QuasiSymmetricFunctions(QQ)).run()
"""
assert R in Rings()
self._base = R # Won't be needed once CategoryObject won't override base_ring
category = GradedHopfAlgebras(R) # TODO: .Commutative()
Parent.__init__(self, category=category.WithRealizations())
# Bases
Monomial = self.Monomial()
Fundamental = self.Fundamental()
dualImmaculate = self.dualImmaculate()
# Change of bases
Fundamental.module_morphism(Monomial.sum_of_finer_compositions,
codomain=Monomial,
category=category).register_as_coercion()
Monomial.module_morphism(
Fundamental.alternating_sum_of_finer_compositions,
codomain=Fundamental,
category=category).register_as_coercion()
#This changes dualImmaculate into Monomial
dualImmaculate.module_morphism(
dualImmaculate._to_Monomial_on_basis,
codomain=Monomial,
category=category).register_as_coercion()
#This changes Monomial into dualImmaculate
Monomial.module_morphism(dualImmaculate._from_Monomial_on_basis,
codomain=dualImmaculate,
category=category).register_as_coercion()
# Embedding of Sym into QSym in the monomial bases
Sym = SymmetricFunctions(self.base_ring())
Sym_m_to_M = Sym.m().module_morphism(
Monomial.sum_of_partition_rearrangements,
triangular='upper',
inverse_on_support=Monomial._comp_to_par,
codomain=Monomial,
category=category)
Sym_m_to_M.register_as_coercion()
self.to_symmetric_function = Sym_m_to_M.section()
def __init__(self, R):
r"""
Initialization of ``self``.
INPUT:
- ``R`` -- a ring
EXAMPLES::
sage: Sym = SymmetricFunctions(QQ)
TESTS::
sage: Sym1 = SymmetricFunctions(FiniteField(23))
sage: Sym2 = SymmetricFunctions(Integers(23))
sage: TestSuite(Sym).run()
"""
# change the line below to assert(R in Rings()) once MRO issues from #15536, #15475 are resolved
assert (R in Fields() or R in Rings()
) # side effect of this statement assures MRO exists for R
self._base = R # Won't be needed when CategoryObject won't override anymore base_ring
Parent.__init__(self,
category=GradedHopfAlgebras(R).WithRealizations())
def super_categories(self):
r"""
Return the super categories of bases of (the Hopf dual of) the
symmetric functions in non-commuting variables.
OUTPUT:
- a list of categories
TESTS::
sage: from sage.combinat.ncsym.bases import NCSymOrNCSymDualBases
sage: NCSym = SymmetricFunctionsNonCommutingVariables(QQ)
sage: NCSymOrNCSymDualBases(NCSym).super_categories()
[Category of realizations of Symmetric functions in
non-commuting variables over the Rational Field,
Category of graded hopf algebras with basis over Rational Field,
Join of Category of realizations of hopf algebras over Rational Field
and Category of graded algebras over Rational Field]
"""
R = self.base().base_ring()
from sage.categories.graded_hopf_algebras_with_basis import GradedHopfAlgebrasWithBasis
return [
self.base().Realizations(),
GradedHopfAlgebrasWithBasis(R),
GradedHopfAlgebras(R).Realizations()
]
def super_categories(self):
"""
EXAMPLES::
sage: GradedHopfAlgebrasWithBasis(QQ).WithRealizations().super_categories()
[Join of Category of hopf algebras over Rational Field
and Category of graded algebras over Rational Field]
TESTS::
sage: TestSuite(GradedHopfAlgebrasWithBasis(QQ).WithRealizations()).run()
"""
from sage.categories.graded_hopf_algebras import GradedHopfAlgebras
R = self.base_category().base_ring()
return [GradedHopfAlgebras(R)]
def super_categories(self):
r"""
TESTS::
sage: from sage.combinat.ncsf_qsym.generic_basis_code import BasesOfQSymOrNCSF
sage: QSym = QuasiSymmetricFunctions(QQ)
sage: BasesOfQSymOrNCSF(QSym).super_categories()
[Category of realizations of Quasisymmetric functions over the Rational Field,
Category of graded hopf algebras with basis over Rational Field,
Join of Category of graded hopf algebras over Rational Field and Category of realizations of hopf algebras over Rational Field]
"""
R = self.base().base_ring()
from sage.categories.graded_hopf_algebras_with_basis import GradedHopfAlgebrasWithBasis
from sage.categories.graded_hopf_algebras import GradedHopfAlgebras
return [self.base().Realizations(),
GradedHopfAlgebrasWithBasis(R),
GradedHopfAlgebras(R).Realizations()]
