passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/algebras/associated_graded.py

@@ -0,0 +1,345 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.modules
+r"""
+Associated Graded Algebras To Filtered Algebras
+
+AUTHORS:
+
+- Travis Scrimshaw (2014-10-08): Initial version
+"""
+
+# ****************************************************************************
+#  Copyright (C) 2014 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.misc.cachefunc import cached_method
+from copy import copy
+
+from sage.categories.modules_with_basis import ModulesWithBasis
+from sage.sets.family import Family
+from sage.combinat.free_module import CombinatorialFreeModule
+
+
+class AssociatedGradedAlgebra(CombinatorialFreeModule):
+    r"""
+    The associated graded algebra/module `\operatorname{gr} A`
+    of a filtered algebra/module with basis `A`.
+
+    Let `A` be a filtered module over a commutative ring `R`.
+    Let `(F_i)_{i \in I}` be the filtration of `A`, with `I` being
+    a totally ordered set. Define
+
+    .. MATH::
+
+        G_i = F_i / \sum_{j < i} F_j
+
+    for every `i \in I`, and then
+
+    .. MATH::
+
+        \operatorname{gr} A = \bigoplus_{i \in I} G_i.
+
+    There are canonical projections `p_i : F_i \to G_i` for
+    every `i \in I`. Moreover `\operatorname{gr} A` is naturally a
+    graded `R`-module with `G_i` being the `i`-th graded component.
+    This graded `R`-module is known as the *associated graded module*
+    (or, for short, just *graded module*) of `A`.
+
+    Now, assume that `A` (endowed with the filtration
+    `(F_i)_{i \in I}`) is not just a filtered `R`-module, but also
+    a filtered `R`-algebra.
+    Let `u \in G_i` and `v \in G_j`, and let `u' \in F_i` and
+    `v' \in F_j` be lifts of `u` and `v`, respectively (so that
+    `u = p_i(u')` and `v = p_j(v')`). Then, we define a
+    multiplication `*` on `\operatorname{gr} A` (not to be mistaken
+    for the multiplication of the original algebra `A`) by
+
+    .. MATH::
+
+        u * v = p_{i+j} (u' v').
+
+    The *associated graded algebra* (or, for short, just
+    *graded algebra*) of `A` is the graded algebra
+    `\operatorname{gr} A` (endowed with this multiplication).
+
+    Now, assume that `A` is a filtered `R`-algebra with basis.
+    Let `(b_x)_{x \in X}` be the basis of `A`,
+    and consider the partition `X = \bigsqcup_{i \in I} X_i` of
+    the set `X`, which is part of the data of a filtered
+    algebra with basis. We know (see
+    :class:`~sage.categories.filtered_modules_with_basis.FilteredModulesWithBasis`)
+    that `A` (being a filtered `R`-module with basis) is canonically
+    (when the basis is considered to be part of the data)
+    isomorphic to `\operatorname{gr} A` as an `R`-module. Therefore
+    the `k`-th graded component `G_k` can be identified with
+    the span of `(b_x)_{x \in X_k}`, or equivalently the
+    `k`-th homogeneous component of `A`. Suppose
+    that `u' v' = \sum_{k \leq i+j} m_k` where `m_k \in G_k` (which
+    has been identified with the `k`-th homogeneous component of `A`).
+    Then `u * v = m_{i+j}`. We also note that the choice of
+    identification of `G_k` with the `k`-th homogeneous component
+    of `A` depends on the given basis.
+
+    The basis `(b_x)_{x \in X}` of `A` gives rise to a basis
+    of `\operatorname{gr} A`. This latter basis is still indexed
+    by the elements of `X`, and consists of the images of the
+    `b_x` under the `R`-module isomorphism from `A` to
+    `\operatorname{gr} A`. It makes `\operatorname{gr} A` into
+    a graded `R`-algebra with basis.
+
+    In this class, the `R`-module isomorphism from `A` to
+    `\operatorname{gr} A` is implemented as
+    :meth:`to_graded_conversion` and also as the default
+    conversion from `A` to `\operatorname{gr} A`. Its
+    inverse map is implemented as
+    :meth:`from_graded_conversion`.
+    The projection `p_i : F_i \to G_i` is implemented as
+    :meth:`projection` ``(i)``.
+
+    INPUT:
+
+    - ``A`` -- a filtered module (or algebra) with basis
+
+    OUTPUT:
+
+    The associated graded module of `A`, if `A` is just a filtered
+    `R`-module.
+    The associated graded algebra of `A`, if `A` is a filtered
+    `R`-algebra.
+
+    EXAMPLES:
+
+    Associated graded module of a filtered module::
+
+        sage: A = Modules(QQ).WithBasis().Filtered().example()
+        sage: grA = A.graded_algebra()
+        sage: grA.category()
+        Category of graded vector spaces with basis over Rational Field
+        sage: x = A.basis()[Partition([3,2,1])]
+        sage: grA(x)
+        Bbar[[3, 2, 1]]
+
+    Associated graded algebra of a filtered algebra::
+
+        sage: A = Algebras(QQ).WithBasis().Filtered().example()
+        sage: grA = A.graded_algebra()
+        sage: grA.category()
+        Category of graded algebras with basis over Rational Field
+        sage: x,y,z = [grA.algebra_generators()[s] for s in ['x','y','z']]
+        sage: x
+        bar(U['x'])
+        sage: y * x + z
+        bar(U['x']*U['y']) + bar(U['z'])
+        sage: A(y) * A(x) + A(z)
+        U['x']*U['y']
+
+    We note that the conversion between ``A`` and ``grA`` is
+    the canonical ``QQ``-module isomorphism stemming from the
+    fact that the underlying ``QQ``-modules of ``A`` and
+    ``grA`` are isomorphic::
+
+        sage: grA(A.an_element())
+        bar(U['x']^2*U['y']^2*U['z']^3) + 2*bar(U['x']) + 3*bar(U['y']) + bar(1)
+        sage: elt = A.an_element() + A.algebra_generators()['x'] + 2
+        sage: grelt = grA(elt); grelt
+        bar(U['x']^2*U['y']^2*U['z']^3) + 3*bar(U['x']) + 3*bar(U['y']) + 3*bar(1)
+        sage: A(grelt) == elt
+        True
+
+    .. TODO::
+
+        The algebra ``A`` must currently be an instance of (a subclass of)
+        :class:`CombinatorialFreeModule`. This should work with any
+        filtered algebra with a basis.
+
+    .. TODO::
+
+        Implement a version of associated graded algebra for
+        filtered algebras without a distinguished basis.
+
+    REFERENCES:
+
+    - :wikipedia:`Filtered_algebra#Associated_graded_algebra`
+    """
+    def __init__(self, A, category=None):
+        """
+        Initialize ``self``.
+
+        EXAMPLES::
+
+            sage: A = Algebras(QQ).WithBasis().Filtered().example()
+            sage: grA = A.graded_algebra()
+            sage: TestSuite(grA).run(elements=[prod(grA.algebra_generators())])
+        """
+        if A not in ModulesWithBasis(A.base_ring().category()).Filtered():
+            raise ValueError("the base algebra must be filtered and with basis")
+        self._A = A
+
+        base_ring = A.base_ring()
+        base_one = base_ring.one()
+
+        category = A.category().Graded().or_subcategory(category)
+        try:
+            opts = copy(A.print_options())
+            if not opts['prefix'] and not opts['bracket']:
+                opts['bracket'] = '('
+            opts['prefix'] = opts['prefix'] + 'bar'
+        except AttributeError:
+            opts = {'prefix': 'Abar'}
+
+        CombinatorialFreeModule.__init__(self, base_ring, A.basis().keys(),
+                                         category=category, **opts)
+
+        # Setup the conversion back
+        phi = self.module_morphism(diagonal=lambda x: base_one, codomain=A)
+        self._A.register_conversion(phi)
+
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: A = Algebras(QQ).WithBasis().Filtered().example()
+            sage: A.graded_algebra()
+            Graded Algebra of An example of a filtered algebra with basis:
+             the universal enveloping algebra of Lie algebra of RR^3
+             with cross product over Rational Field
+        """
+        from sage.categories.algebras_with_basis import AlgebrasWithBasis
+        if self in AlgebrasWithBasis:
+            return "Graded Algebra of {}".format(self._A)
+        return "Graded Module of {}".format(self._A)
+
+    def _latex_(self):
+        r"""
+        Return a latex representation of ``self``.
+
+        EXAMPLES::
+
+            sage: A = Algebras(QQ).WithBasis().Filtered().example()
+            sage: latex(A.graded_algebra())
+            \operatorname{gr} ...
+        """
+        from sage.misc.latex import latex
+        return "\\operatorname{gr} " + latex(self._A)
+
+    def _element_constructor_(self, x):
+        r"""
+        Construct an element of ``self`` from ``x``.
+
+        If ``self`` `= \operatorname{gr} A` for a filtered algebra
+        `A` with basis, and if ``x`` is an element of `A`, then
+        this returns the image of `x` under the canonical `R`-module
+        isomorphism `A \to \operatorname{gr} A`. (In this case,
+        this is equivalent to calling
+        ``self.to_graded_conversion()(x)``.)
+
+        EXAMPLES::
+
+            sage: A = Algebras(QQ).WithBasis().Filtered().example()
+            sage: grA = A.graded_algebra()
+            sage: grA(A.an_element())
+            bar(U['x']^2*U['y']^2*U['z']^3)
+             + 2*bar(U['x']) + 3*bar(U['y']) + bar(1)
+            sage: grA(A.an_element() + A.algebra_generators()['x'] + 2)
+            bar(U['x']^2*U['y']^2*U['z']^3)
+             + 3*bar(U['x']) + 3*bar(U['y']) + 3*bar(1)
+        """
+        if isinstance(x, CombinatorialFreeModule.Element):
+            if x.parent() is self._A:
+                return self._from_dict(dict(x))
+        return super()._element_constructor_(x)
+
+    def gen(self, *args, **kwds):
+        """
+        Return a generator of ``self``.
+
+        EXAMPLES::
+
+            sage: A = Algebras(QQ).WithBasis().Filtered().example()
+            sage: grA = A.graded_algebra()
+            sage: grA.gen('x')
+            bar(U['x'])
+        """
+        try:
+            x = self._A.gen(*args, **kwds)
+        except AttributeError:
+            x = self._A.algebra_generators()[args[0]]
+        return self(x)
+
+    @cached_method
+    def algebra_generators(self):
+        """
+        Return the algebra generators of ``self``.
+
+        This assumes that the algebra generators of `A` provided by
+        its ``algebra_generators`` method are homogeneous.
+
+        EXAMPLES::
+
+            sage: A = Algebras(QQ).WithBasis().Filtered().example()
+            sage: grA = A.graded_algebra()
+            sage: grA.algebra_generators()
+            Finite family {'x': bar(U['x']), 'y': bar(U['y']), 'z': bar(U['z'])}
+        """
+        G = self._A.algebra_generators()
+        return Family(G.keys(), lambda x: self(G[x]), name='generator')
+
+    def degree_on_basis(self, x):
+        """
+        Return the degree of the basis element indexed by ``x``.
+
+        EXAMPLES::
+
+            sage: A = Algebras(QQ).WithBasis().Filtered().example()
+            sage: grA = A.graded_algebra()
+            sage: all(A.degree_on_basis(x) == grA.degree_on_basis(x)
+            ....:     for g in grA.algebra_generators() for x in g.support())
+            True
+        """
+        return self._A.degree_on_basis(x)
+
+    @cached_method
+    def one_basis(self):
+        r"""
+        Return the basis index of the element `1` of
+        `\operatorname{gr} A`.
+
+        This assumes that the unity `1` of `A` belongs to `F_0`.
+
+        EXAMPLES::
+
+            sage: A = Algebras(QQ).WithBasis().Filtered().example()
+            sage: grA = A.graded_algebra()
+            sage: grA.one_basis()
+            1
+        """
+        return self._A.one_basis()
+
+    def product_on_basis(self, x, y):
+        """
+        Return the product on basis elements given by the
+        indices ``x`` and ``y``.
+
+        EXAMPLES::
+
+            sage: A = Algebras(QQ).WithBasis().Filtered().example()
+            sage: grA = A.graded_algebra()
+            sage: G = grA.algebra_generators()
+            sage: x,y,z = G['x'], G['y'], G['z']
+            sage: x * y # indirect doctest
+            bar(U['x']*U['y'])
+            sage: y * x
+            bar(U['x']*U['y'])
+            sage: z * y * x
+            bar(U['x']*U['y']*U['z'])
+        """
+        ret = self._A.product_on_basis(x, y)
+        deg = self._A.degree_on_basis(x) + self._A.degree_on_basis(y)
+        return self.sum_of_terms([(i,c) for i,c in ret
+                                     if self._A.degree_on_basis(i) == deg],
+                                 distinct=True)

sage/algebras/cellular_basis.py

@@ -0,0 +1,350 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.graphs sage.modules
+r"""
+Cellular Basis
+==============
+
+Cellular algebras are a class of algebras introduced by Graham and Lehrer
+[GrLe1996]_. The :class:`CellularBasis` class provides a general framework for
+implementing cellular algebras and their cell modules and simple modules.
+
+Let `R` be a commutative ring. A `R`-algebra `A` is a *cellular algebra*
+if it has a *cell datum*, which is a tuple `(\Lambda, i, M, C)`,
+where `\Lambda` is finite poset with order `\ge`, if `\mu \in \Lambda`
+then `T(\mu)` is a finite set and
+
+.. MATH::
+
+    C \colon \coprod_{\mu \in \Lambda} T(\mu) \times T(\mu)
+      \longrightarrow A; (\mu,s,t) \mapsto c^\mu_{st}
+      \text{ is an injective map}
+
+such that the following holds:
+
+* The set `\{c^\mu_{st}\mid \mu\in\Lambda, s,t\in T(\mu)\}` is a basis of `A`.
+* If `a \in A` and `\mu\in\Lambda, s,t \in T(\mu)` then:
+
+  .. MATH::
+
+      a c^\mu_{st} = \sum_{u\in T(\mu)} r_a(s,u) c^\mu_{ut} \pmod{A^{>\mu}},
+
+  where `A^{>\mu}` is spanned by
+
+  .. MATH::
+
+      `\{c^\nu_{ab} | \nu > \mu\text{ and } a,b \in T(\nu)\}`.
+
+  Moreover, the scalar `r_a(s,u)` depends only on `a`, `s` and
+  `u` and, in particular, is independent of `t`.
+
+* The map `\iota \colon A \longrightarrow A; c^\mu_{st} \mapsto c^\mu_{ts}`
+  is an algebra anti-isomorphism.
+
+A *cellular  basis* for `A` is any basis of the form
+`\{c^\mu_{st} \mid \mu \in \Lambda, s,t \in T(\mu) \}`.
+
+Note that the scalars `r_a(s,u) \in R` depend only if `a`, `s` and `u` and,
+in particular, they do not depend on `t`. It follows from the definition of
+a cell datum that `A^{>\mu}` is a two-sided ideal of `A`. More importantly,
+if `\mu \in \Lambda` then the
+:class:`~sage.modules.with_basis.cell_module.CellModule` `C^\mu` is the
+free `R`-module with basis `\{c^\mu_s \mid \mu \in \Lambda, s \in T(\mu)\}`
+and with `A`-action:
+
+.. MATH::
+
+    a c^\mu_{s} = \sum_{u \in T(\mu)} r_a(s,u) c^\mu_{u},
+
+where the scalars `r_a(s,u)` are those appearing in the definition of the cell
+datum. It follows from the cellular basis axioms that `C^\mu` comes
+equipped with a bilinear form `\langle\ ,\ \rangle` that is determined by:
+
+.. MATH::
+
+    c^\mu_{st} c^\mu_u = \langle c^\mu_{s}, c^\mu_t \rangle c^\mu_u.
+
+The *radical* of `C^\mu` is the `A`-submodule
+`\operatorname{rad} C^\mu = \{x \in C^\mu | \langle x,y \rangle = 0 \}`.
+Hence, `D^\mu = C^\mu / \operatorname{rad} C^\mu` is also an `A`-module.
+It is not difficult to show that `\{ D^\mu \mid D^\mu \neq 0 \}` is a
+complete set of pairwise non-isomorphic `A`-modules. Hence, a cell datum for
+`A` gives an explicit construction of the irreducible `A`-modules. The module
+:meth:`~sage.modules.with_basis.cell_module.CellModule.simple_module()`
+`D^\mu` is either zero or absolutely irreducible.
+
+EXAMPLES:
+
+We compute a cellular basis and do some basic computations::
+
+    sage: S = SymmetricGroupAlgebra(QQ, 3)
+    sage: C = S.cellular_basis()
+    sage: C
+    Cellular basis of Symmetric group algebra of order 3
+     over Rational Field
+
+.. SEEALSO::
+
+    :class:`~sage.modules.with_basis.cell_module.CellModule`
+
+AUTHOR:
+
+- Travis Scrimshaw (2015-11-5): Initial version
+
+REFERENCES:
+
+- [GrLe1996]_
+- [KX1998]_
+- [Mat1999]_
+- :wikipedia:`Cellular_algebra`
+- http://webusers.imj-prg.fr/~bernhard.keller/ictp2006/lecturenotes/xi.pdf
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2015-2018 Travis Scrimshaw <tcscrims at gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+try:
+    from typing import Self  # type: ignore (Python >= 3.11)
+except ImportError:
+    from typing_extensions import Self  # type: ignore (Python 3.10)
+
+from sage.categories.algebras import Algebras
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.misc.cachefunc import cached_method
+
+
+class CellularBasis(CombinatorialFreeModule):
+    r"""
+    The cellular basis of a cellular algebra, in the sense of
+    Graham and Lehrer [GrLe1996]_.
+
+    INPUT:
+
+    - ``A`` -- the cellular algebra
+
+    EXAMPLES:
+
+    We compute a cellular basis and do some basic computations::
+
+        sage: S = SymmetricGroupAlgebra(QQ, 3)
+        sage: C = S.cellular_basis()
+        sage: C
+        Cellular basis of Symmetric group algebra of order 3
+         over Rational Field
+        sage: len(C.basis())
+        6
+        sage: len(S.basis())
+        6
+        sage: a,b,c,d,e,f = C.basis()
+        sage: f
+        C([3], [[1, 2, 3]], [[1, 2, 3]])
+        sage: c
+        C([2, 1], [[1, 3], [2]], [[1, 2], [3]])
+        sage: d
+        C([2, 1], [[1, 2], [3]], [[1, 3], [2]])
+        sage: f * f
+        C([3], [[1, 2, 3]], [[1, 2, 3]])
+        sage: f * c
+        0
+        sage: d * c
+        C([2, 1], [[1, 2], [3]], [[1, 2], [3]])
+        sage: c * d
+        C([2, 1], [[1, 3], [2]], [[1, 3], [2]])
+        sage: S(f)
+        1/6*[1, 2, 3] + 1/6*[1, 3, 2] + 1/6*[2, 1, 3] + 1/6*[2, 3, 1]
+         + 1/6*[3, 1, 2] + 1/6*[3, 2, 1]
+        sage: S(d)
+        1/4*[1, 3, 2] - 1/4*[2, 3, 1] + 1/4*[3, 1, 2] - 1/4*[3, 2, 1]
+        sage: B = list(S.basis())
+        sage: B[2]
+        [2, 1, 3]
+        sage: C(B[2])
+        -C([1, 1, 1], [[1], [2], [3]], [[1], [2], [3]])
+         + C([2, 1], [[1, 2], [3]], [[1, 2], [3]])
+         - C([2, 1], [[1, 3], [2]], [[1, 3], [2]])
+         + C([3], [[1, 2, 3]], [[1, 2, 3]])
+    """
+    def __init__(self, A, to_algebra=None, from_algebra=None, **kwargs):
+        r"""
+        Initialize ``self``.
+
+        EXAMPLES::
+
+            sage: S = SymmetricGroupAlgebra(QQ, 3)
+            sage: C = S.cellular_basis()
+            sage: TestSuite(C).run()
+        """
+        self._algebra = A
+        I = [(la, s, t) for la in A.cell_poset()
+             for s in A.cell_module_indices(la)
+             for t in A.cell_module_indices(la)]
+
+        # TODO: Use instead A.category().Realizations() so
+        #   operations are defined by coercion?
+        prefix = kwargs.pop('prefix', 'C')
+        cat = Algebras(A.category().base_ring()).FiniteDimensional().WithBasis().Cellular()
+        CombinatorialFreeModule.__init__(self, A.base_ring(), I,
+                                         prefix=prefix, bracket=False,
+                                         category=cat, **kwargs)
+
+        # Register coercions
+        if from_algebra is None:
+            from_algebra = A._to_cellular_element
+        if to_algebra is None:
+            to_algebra = A._from_cellular_index
+        if from_algebra is not NotImplemented:
+            to_cellular = A.module_morphism(from_algebra, codomain=self,
+                                            category=cat)
+        if to_algebra is NotImplemented:
+            from_cellular = ~to_cellular
+        else:
+            from_cellular = self.module_morphism(to_algebra, codomain=A,
+                                                 category=cat)
+            if from_algebra is NotImplemented:
+                to_cellular = ~from_cellular
+        to_cellular.register_as_coercion()
+        from_cellular.register_as_coercion()
+
+    def _repr_(self):
+        r"""
+        String representation of ``self``.
+
+        EXAMPLES::
+
+            sage: S = SymmetricGroupAlgebra(QQ, 3)
+            sage: S.cellular_basis()
+            Cellular basis of Symmetric group algebra of order 3 over Rational Field
+        """
+        return "Cellular basis of {}".format(self._algebra)
+
+    def _latex_term(self, x):
+        r"""
+        Return a latex representation of the term indexed by ``x``.
+
+        EXAMPLES::
+
+            sage: S = SymmetricGroupAlgebra(QQ, 3)
+            sage: C = S.cellular_basis()
+            sage: s = Tableau([[1,2],[3]])
+            sage: C._latex_term((Partition([2,1]), s, s))
+            'C^{...}_{\\left(...\\right)}'
+        """
+        from sage.misc.latex import latex
+        la = x[0]
+        m = (x[1], x[2])
+        # m contains "non-LaTeXed" strings, use string representation
+        sla = latex(la)
+        if sla.find('\\text{\\textt') != -1:
+            sla = str(la)
+        sm = latex(m)
+        if sm.find('\\text{\\textt') != -1:
+            sm = str(m)
+        return "C^{%s}_{%s}" % (sla, sm)
+
+    def cellular_basis_of(self):
+        """
+        Return the defining algebra of ``self``.
+
+        EXAMPLES::
+
+            sage: S = SymmetricGroupAlgebra(QQ, 3)
+            sage: C = S.cellular_basis()
+            sage: C.cellular_basis_of() is S
+            True
+        """
+        return self._algebra
+
+    def cell_poset(self):
+        """
+        Return the cell poset of ``self``.
+
+        EXAMPLES::
+
+            sage: S = SymmetricGroupAlgebra(QQ, 3)
+            sage: C = S.cellular_basis()
+            sage: C.cell_poset()
+            Finite poset containing 3 elements
+        """
+        return self._algebra.cell_poset()
+
+    def cell_module_indices(self, la):
+        r"""
+        Return the indices of the cell module of ``self``
+        indexed by ``la`` .
+
+        This is the finite set `M(\lambda)`.
+
+        EXAMPLES::
+
+            sage: S = SymmetricGroupAlgebra(QQ, 3)
+            sage: C = S.cellular_basis()
+            sage: C.cell_module_indices([2,1])
+            Standard tableaux of shape [2, 1]
+        """
+        return self._algebra.cell_module_indices(la)
+
+    def cellular_basis(self) -> Self:
+        """
+        Return the cellular basis of ``self``, which is ``self``.
+
+        EXAMPLES::
+
+            sage: S = SymmetricGroupAlgebra(QQ, 3)
+            sage: C = S.cellular_basis()
+            sage: C.cellular_basis() is C
+            True
+        """
+        return self
+
+    @cached_method
+    def one(self):
+        """
+        Return the element `1` in ``self``.
+
+        EXAMPLES::
+
+            sage: S = SymmetricGroupAlgebra(QQ, 3)
+            sage: C = S.cellular_basis()
+            sage: C.one()
+            C([1, 1, 1], [[1], [2], [3]], [[1], [2], [3]])
+             + C([2, 1], [[1, 2], [3]], [[1, 2], [3]])
+             + C([2, 1], [[1, 3], [2]], [[1, 3], [2]])
+             + C([3], [[1, 2, 3]], [[1, 2, 3]])
+        """
+        return self(self._algebra.one())
+
+    @cached_method
+    def product_on_basis(self, x, y):
+        """
+        Return the product of basis indices by ``x`` and ``y``.
+
+        EXAMPLES::
+
+            sage: S = SymmetricGroupAlgebra(QQ, 3)
+            sage: C = S.cellular_basis()
+            sage: la = Partition([2,1])
+            sage: s = StandardTableau([[1,2],[3]])
+            sage: t = StandardTableau([[1,3],[2]])
+            sage: C.product_on_basis((la, s, t), (la, s, t))
+            0
+
+        TESTS::
+
+            sage: C5.<z5> = CyclotomicField(5)
+            sage: TL = TemperleyLiebAlgebra(2, z5 + ~z5, C5)
+            sage: m = TL.cell_module(0)
+            sage: c = m.basis().keys()[0]
+            sage: B = TL.cellular_basis()
+            sage: B.product_on_basis((0, c, c), (0, c, c))
+            (-z5^3-z5^2-1)*C(0, {{1, 2}}, {{1, 2}})
+
+            sage: p = TL(B.monomial((0,c,c))) * TL(B.monomial((0,c,c)))
+        """
+        A = self._algebra
+        return self(A(self.monomial(x)) * A(self.monomial(y)))