#13372: add functionality for duals of algebras, coalgebras, hopf algebras, etc.
-------------------------------------------------+--------------------------
Reporter: saliola | Owner: AlexGhitza
Type: enhancement | Status: new
Priority: major | Milestone: sage-5.3
Component: algebra | Resolution:
Keywords: duality, categories, algebras | Work issues:
Report Upstream: N/A | Reviewers:
Authors: | Merged in:
Dependencies: | Stopgaps:
-------------------------------------------------+--------------------------
Description changed by saliola:
Old description:
> In this [https://groups.google.com/d/topic/sage-combinat-
> devel/LdKONcGfGhU/discussion discussion], we came up with a rough draft
> of an interface for the method returning the dual of an object. Here is a
> summary by way of docstrings for the methods:
> {{{
> def dual(self, category=None):
> r"""
> The dual of ``self``.
>
> By default, the dual is computed in the category
> ``self.category()``. If the user specifies a category, the dual will
> be computed in that category.
>
> INPUT:
>
> - ``category`` -- category (default: the category of ``self``).
>
> OUTPUT:
>
> - The dual of ``self``.
>
> EXAMPLES:
>
> The Hopf algebra of symmetric functions is a self-dual Hopf
> algebra::
>
> sage: Sym = SymmetricFunctions(QQ); Sym
> Symmetric Functions over Rational Field
> sage: Sym.dual()
> Symmetric Functions over Rational Field
> sage: Sym.dual() is Sym
> True
>
> If we view ``Sym`` as an algebra, then its dual is a co-algebra::
>
> sage: C = Sym.dual(category=Algebras(QQ)).category()
> Category of duals of algebras over Rational Field
> sage: C.super_categories()
> [Category of coalgebras over Rational Field,
> Category of duals of vector spaces over Rational Field]
>
> The Schur basis for symmetric functions is self-dual and the
> homogeneous symmetric functions are dual to the monomial
> symmetric functions::
>
> sage: s = Sym.schur()
> sage: s.dual() is s
> True
> sage: h = Sym.homogeneous()
> sage: m = Sym.monomial()
> sage: h.dual() is m
> True
>
> Note that in the above, ``s`` (as well as ``h`` and ``m``) are Hopf
> algebras with basis. Hence, their duals are also Hopf algebras with
> basis.
>
> The Hopf algebra of quasi-symmetric functions is dual, as a Hopf
> algebra, to the Hopf algebra of non-commutative symmetric
> functions::
>
> sage: NCSF = NonCommutativeSymmetricFunctions(QQ)
> sage: NCSF.dual()
> Quasisymmetric functions over the Rational Field
>
> ::
> sage: QSym = QuasiSymmetricFunctions(QQ)
> sage: QSym.dual()
> Non-Commutative Symmetric Functions over the Rational Field
>
> """
> return NotImplemented
>
> def duality_pairing(self, x, y):
> r"""
> The duality pairing between elements of NSym and elements of QSym.
>
> INPUT:
>
> - ``x`` -- an element of ``self``
> - ``y`` -- an element in the dual basis of ``self``
>
> OUTPUT:
>
> - The result of pairing the element ``x`` of ``self`` with the
> element ``y`` of the dual of ``self``.
>
> EXAMPLES:
>
> The Schur basis of symmetric functions is self-dual::
>
> sage: Sym = SymmetricFunctions(QQ)
> sage: s = Sym(QQ).schur()
> sage: s.dual() is s
> True
> sage: s.duality_pairing(s[2,1,1], s[2,1,1])
> 1
> sage: s.duality_pairing(s[2,1], s[3])
> 0
>
> The fundamental basis of quasi-symmetric functions is dual to the
> ribbon basis of non-commutative symmetric functions::
>
> sage: R = NonCommutativeSymmetricFunctions(QQ).Ribbon()
> sage: F = QuasiSymmetricFunctions(QQ).Fundamental()
> sage: R.duality_pairing(R[1,1,2], F[1,1,2])
> 1
> sage: R.duality_pairing(R[1,2,1], F[1,1,2])
> 0
> sage: F.duality_pairing(F[1,2,1], R[1,1,2])
> 0
>
> """
> return NotImplemented
> }}}
> A rudimentary implementation for {{{duality_matrix}}} can be found at
> #8899, but see also the scalar product code for symmetric functions.
>
> I think a bunch of the code for duality for symmetric functions can be
> refactored. See
> [http://www.sagemath.org/doc/reference/sage/combinat/sf/dual.html
> sage.combinat.sf.dual]
New description:
In this [https://groups.google.com/d/topic/sage-combinat-
devel/LdKONcGfGhU/discussion discussion], we came up with a rough draft of
an interface for the method returning the dual of an object. Here is a
summary by way of docstrings for the methods:
{{{
def dual(self, category=None):
r"""
The dual of ``self``.
By default, the dual is computed in the category
``self.category()``. If the user specifies a category, the dual will
be computed in that category.
INPUT:
- ``category`` -- category (default: the category of ``self``).
OUTPUT:
- The dual of ``self``.
EXAMPLES:
The Hopf algebra of symmetric functions is a self-dual Hopf
algebra::
sage: Sym = SymmetricFunctions(QQ); Sym
Symmetric Functions over Rational Field
sage: Sym.dual()
Symmetric Functions over Rational Field
sage: Sym.dual() is Sym
True
If we view ``Sym`` as an algebra, then its dual is a co-algebra::
sage: C = Sym.dual(category=Algebras(QQ)).category()
Category of duals of algebras over Rational Field
sage: C.super_categories()
[Category of coalgebras over Rational Field,
Category of duals of vector spaces over Rational Field]
The Schur basis for symmetric functions is self-dual and the
homogeneous symmetric functions are dual to the monomial
symmetric functions::
sage: s = Sym.schur()
sage: s.dual() is s
True
sage: h = Sym.homogeneous()
sage: m = Sym.monomial()
sage: h.dual() is m
True
Note that in the above, ``s`` (as well as ``h`` and ``m``) are Hopf
algebras with basis. Hence, their duals are also Hopf algebras with
basis.
The Hopf algebra of quasi-symmetric functions is dual, as a Hopf
algebra, to the Hopf algebra of non-commutative symmetric
functions::
sage: NCSF = NonCommutativeSymmetricFunctions(QQ)
sage: NCSF.dual()
Quasisymmetric functions over the Rational Field
::
sage: QSym = QuasiSymmetricFunctions(QQ)
sage: QSym.dual()
Non-Commutative Symmetric Functions over the Rational Field
"""
return NotImplemented
}}}
}}}
def duality_pairing(self, x, y):
r"""
The duality pairing between elements of NSym and elements of QSym.
INPUT:
- ``x`` -- an element of ``self``
- ``y`` -- an element in the dual basis of ``self``
OUTPUT:
- The result of pairing the element ``x`` of ``self`` with the
element ``y`` of the dual of ``self``.
EXAMPLES:
The Schur basis of symmetric functions is self-dual::
sage: Sym = SymmetricFunctions(QQ)
sage: s = Sym(QQ).schur()
sage: s.dual() is s
True
sage: s.duality_pairing(s[2,1,1], s[2,1,1])
1
sage: s.duality_pairing(s[2,1], s[3])
0
The fundamental basis of quasi-symmetric functions is dual to the
ribbon basis of non-commutative symmetric functions::
sage: R = NonCommutativeSymmetricFunctions(QQ).Ribbon()
sage: F = QuasiSymmetricFunctions(QQ).Fundamental()
sage: R.duality_pairing(R[1,1,2], F[1,1,2])
1
sage: R.duality_pairing(R[1,2,1], F[1,1,2])
0
sage: F.duality_pairing(F[1,2,1], R[1,1,2])
0
"""
return NotImplemented
}}}
A rudimentary implementation for {{{duality_pairing}}} can be found at
#8899, but see also the scalar product code for symmetric functions.
I think a bunch of the code for duality for symmetric functions can be
refactored. See
[http://www.sagemath.org/doc/reference/sage/combinat/sf/dual.html
sage.combinat.sf.dual].
--
--
Ticket URL: <http://trac.sagemath.org/sage_trac/ticket/13372#comment:2>
Sage <http://www.sagemath.org>
Sage: Creating a Viable Open Source Alternative to Magma, Maple, Mathematica,
and MATLAB
--
You received this message because you are subscribed to the Google Groups
"sage-trac" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/sage-trac?hl=en.
