passagemath-combinat 10.6.42__cp314-cp314t-win_amd64.whl

sage/combinat/sf/orthogonal.py

@@ -0,0 +1,246 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs lrcalc_python sage.combinat sage.modules
+"""
+Orthogonal symmetric functions
+
+AUTHORS:
+
+- Travis Scrimshaw (2013-11-10): Initial version
+"""
+# ****************************************************************************
+#       Copyright (C) 2013 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.combinat.partition import Partitions
+from sage.libs.lrcalc import lrcalc
+from sage.misc.cachefunc import cached_method
+
+from . import sfa
+
+
+class SymmetricFunctionAlgebra_orthogonal(sfa.SymmetricFunctionAlgebra_generic):
+    r"""
+    The orthogonal symmetric function basis (or orthogonal basis, to be short).
+
+    The orthogonal basis `\{ o_{\lambda} \}` where `\lambda` is taken over
+    all partitions is defined by the following change of basis with the
+    Schur functions:
+
+    .. MATH::
+
+        s_{\lambda} = \sum_{\mu} \left( \sum_{\nu \in H} c^{\lambda}_{\mu\nu}
+        \right) o_{\mu}
+
+    where `H` is the set of all partitions with even-width rows and
+    `c^{\lambda}_{\mu\nu}` is the usual Littlewood-Richardson (LR)
+    coefficients. By the properties of LR coefficients, this can be shown to
+    be a upper unitriangular change of basis.
+
+    .. NOTE::
+
+        This is only a filtered basis, not a `\ZZ`-graded basis. However this
+        does respect the induced `(\ZZ/2\ZZ)`-grading.
+
+    INPUT:
+
+    - ``Sym`` -- an instance of the ring of the symmetric functions
+
+    REFERENCES:
+
+    - [ChariKleber2000]_
+    - [KoikeTerada1987]_
+    - [ShimozonoZabrocki2006]_
+
+    EXAMPLES:
+
+    Here are the first few orthogonal symmetric functions, in various bases::
+
+        sage: Sym = SymmetricFunctions(QQ)
+        sage: o = Sym.o()
+        sage: e = Sym.e()
+        sage: h = Sym.h()
+        sage: p = Sym.p()
+        sage: s = Sym.s()
+        sage: m = Sym.m()
+
+        sage: p(o([1]))
+        p[1]
+        sage: m(o([1]))
+        m[1]
+        sage: e(o([1]))
+        e[1]
+        sage: h(o([1]))
+        h[1]
+        sage: s(o([1]))
+        s[1]
+
+        sage: p(o([2]))
+        -p[] + 1/2*p[1, 1] + 1/2*p[2]
+        sage: m(o([2]))
+        -m[] + m[1, 1] + m[2]
+        sage: e(o([2]))
+        -e[] + e[1, 1] - e[2]
+        sage: h(o([2]))
+        -h[] + h[2]
+        sage: s(o([2]))
+        -s[] + s[2]
+
+        sage: p(o([3]))
+        -p[1] + 1/6*p[1, 1, 1] + 1/2*p[2, 1] + 1/3*p[3]
+        sage: m(o([3]))
+        -m[1] + m[1, 1, 1] + m[2, 1] + m[3]
+        sage: e(o([3]))
+        -e[1] + e[1, 1, 1] - 2*e[2, 1] + e[3]
+        sage: h(o([3]))
+        -h[1] + h[3]
+        sage: s(o([3]))
+        -s[1] + s[3]
+
+        sage: Sym = SymmetricFunctions(ZZ)
+        sage: o = Sym.o()
+        sage: e = Sym.e()
+        sage: h = Sym.h()
+        sage: s = Sym.s()
+        sage: m = Sym.m()
+        sage: p = Sym.p()
+        sage: m(o([4]))
+        -m[1, 1] + m[1, 1, 1, 1] - m[2] + m[2, 1, 1] + m[2, 2] + m[3, 1] + m[4]
+        sage: e(o([4]))
+        -e[1, 1] + e[1, 1, 1, 1] + e[2] - 3*e[2, 1, 1] + e[2, 2] + 2*e[3, 1] - e[4]
+        sage: h(o([4]))
+        -h[2] + h[4]
+        sage: s(o([4]))
+        -s[2] + s[4]
+
+    Some examples of conversions the other way::
+
+        sage: o(h[3])
+        o[1] + o[3]
+        sage: o(e[3])
+        o[1, 1, 1]
+        sage: o(m[2,1])
+        o[1] - 2*o[1, 1, 1] + o[2, 1]
+        sage: o(p[3])
+        o[1, 1, 1] - o[2, 1] + o[3]
+
+    Some multiplication::
+
+        sage: o([2]) * o([1,1])
+        o[1, 1] + o[2] + o[2, 1, 1] + o[3, 1]
+        sage: o([2,1,1]) * o([2])
+        o[1, 1] + o[1, 1, 1, 1] + 2*o[2, 1, 1] + o[2, 2] + o[2, 2, 1, 1]
+         + o[3, 1] + o[3, 1, 1, 1] + o[3, 2, 1] + o[4, 1, 1]
+        sage: o([1,1]) * o([2,1])
+        o[1] + o[1, 1, 1] + 2*o[2, 1] + o[2, 1, 1, 1] + o[2, 2, 1]
+         + o[3] + o[3, 1, 1] + o[3, 2]
+
+    Examples of the Hopf algebra structure::
+
+        sage: o([1]).antipode()
+        -o[1]
+        sage: o([2]).antipode()
+        -o[] + o[1, 1]
+        sage: o([1]).coproduct()
+        o[] # o[1] + o[1] # o[]
+        sage: o([2]).coproduct()
+        o[] # o[] + o[] # o[2] + o[1] # o[1] + o[2] # o[]
+        sage: o([1]).counit()
+        0
+        sage: o.one().counit()
+        1
+    """
+
+    def __init__(self, Sym):
+        """
+        Initialize ``self``.
+
+        TESTS::
+
+            sage: o = SymmetricFunctions(QQ).o()
+            sage: TestSuite(o).run()
+        """
+        sfa.SymmetricFunctionAlgebra_generic.__init__(self, Sym, "orthogonal",
+                                                      'o', graded=False)
+
+        # We make a strong reference since we use it for our computations
+        #   and so we can define the coercion below (only codomains have
+        #   strong references)
+        self._s = Sym.schur()
+
+        # Setup the coercions
+        M = self._s.module_morphism(self._s_to_o_on_basis, codomain=self,
+                                    triangular='upper', unitriangular=True)
+        M.register_as_coercion()
+        Mi = self.module_morphism(self._o_to_s_on_basis, codomain=self._s,
+                                  triangular='upper', unitriangular=True)
+        Mi.register_as_coercion()
+
+    @cached_method
+    def _o_to_s_on_basis(self, lam):
+        r"""
+        Return the orthogonal symmetric function ``o[lam]`` expanded in
+        the Schur basis, where ``lam`` is a partition.
+
+        TESTS:
+
+        Check that this is the inverse::
+
+            sage: o = SymmetricFunctions(QQ).o()
+            sage: s = SymmetricFunctions(QQ).s()
+            sage: all(o(s(o[la])) == o[la] for i in range(5) for la in Partitions(i))
+            True
+            sage: all(s(o(s[la])) == s[la] for i in range(5) for la in Partitions(i))
+            True
+        """
+        R = self.base_ring()
+        n = sum(lam)
+        return self._s._from_dict({ mu: R.sum( (-1)**j * lrcalc.lrcoef_unsafe(lam, mu, nu)
+                                               for nu in Partitions(2*j)
+                                                   if all(nu.arm_length(i,i) == nu.leg_length(i,i)+1
+                                                          for i in range(nu.frobenius_rank()))
+                                             )
+                                    for j in range(n//2+1) # // 2 for horizontal dominoes
+                                    for mu in Partitions(n-2*j) })
+
+    @cached_method
+    def _s_to_o_on_basis(self, lam):
+        r"""
+        Return the Schur symmetric function ``s[lam]`` expanded in
+        the orthogonal basis, where ``lam`` is a partition.
+
+        INPUT:
+
+        - ``lam`` -- a partition
+
+        OUTPUT: the expansion of ``s[lam]`` in the orthogonal basis ``self``
+
+        EXAMPLES::
+
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: s = Sym.schur()
+            sage: o = Sym.orthogonal()
+            sage: o._s_to_o_on_basis(Partition([]))
+            o[]
+            sage: o._s_to_o_on_basis(Partition([4,2,1]))
+            o[1] + 2*o[2, 1] + o[2, 2, 1] + o[3]
+             + o[3, 1, 1] + o[3, 2] + o[4, 1] + o[4, 2, 1]
+            sage: s(o._s_to_o_on_basis(Partition([3,1]))) == s[3,1]
+            True
+        """
+        R = self.base_ring()
+        n = sum(lam)
+        return self._from_dict({ mu: R.sum( lrcalc.lrcoef_unsafe(lam, mu, [2*x for x in nu])
+                                            for nu in Partitions(j) )
+                                 for j in range(n//2+1) # // 2 for horizontal dominoes
+                                 for mu in Partitions(n-2*j) })

sage/combinat/sf/orthotriang.py

@@ -0,0 +1,355 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+"""
+Symmetric functions defined by orthogonality and triangularity
+
+One characterization of Schur functions is that they are upper
+triangularly related to the monomial symmetric functions and
+orthogonal with respect to the Hall scalar product. We can use the
+class SymmetricFunctionAlgebra_orthotriang to obtain the Schur
+functions from this definition.
+
+::
+
+    sage: from sage.combinat.sf.sfa import zee
+    sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+    sage: Sym = SymmetricFunctions(QQ)
+    sage: m = Sym.m()
+    sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur functions')
+    sage: s([2,1])^2
+    s[2, 2, 1, 1] + s[2, 2, 2] + s[3, 1, 1, 1] + 2*s[3, 2, 1] + s[3, 3] + s[4, 1, 1] + s[4, 2]
+
+::
+
+    sage: s2 = SymmetricFunctions(QQ).s()
+    sage: s2([2,1])^2                                                                   # needs lrcalc_python
+    s[2, 2, 1, 1] + s[2, 2, 2] + s[3, 1, 1, 1] + 2*s[3, 2, 1] + s[3, 3] + s[4, 1, 1] + s[4, 2]
+"""
+# ****************************************************************************
+#       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>
+#                     2012 Mike Zabrocki <mike.zabrocki@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.categories.homset import Hom
+from sage.categories.morphism import SetMorphism
+
+from . import sfa
+
+
+class SymmetricFunctionAlgebra_orthotriang(sfa.SymmetricFunctionAlgebra_generic):
+
+    class Element(sfa.SymmetricFunctionAlgebra_generic.Element):
+        pass
+
+    @staticmethod
+    def __classcall__(cls, Sym, base, scalar, prefix, basis_name, leading_coeff=None):
+        """
+        Normalize the arguments.
+
+        TESTS::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: m = Sym.m()
+            sage: B1 = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur')
+            sage: B2 = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur', None)
+            sage: B1 is B2
+            True
+        """
+        return super().__classcall__(cls, Sym, base, scalar, prefix, basis_name, leading_coeff)
+
+    def __init__(self, Sym, base, scalar, prefix, basis_name, leading_coeff):
+        r"""
+        Initialization of the symmetric function algebra defined via orthotriangular rules.
+
+        INPUT:
+
+        - ``self`` -- a basis determined by an orthotriangular definition
+        - ``Sym`` -- ring of symmetric functions
+        - ``base`` -- an instance of a basis of the ring of symmetric functions
+          (e.g. the Schur functions)
+        - ``scalar`` -- a function ``zee`` on partitions. The function
+          ``zee`` determines the scalar product on the power sum basis
+          with normalization `\langle p_{\mu}, p_{\mu} \rangle =
+          \mathrm{zee}(\mu)`.
+        - ``prefix`` -- the prefix used to display the basis
+        - ``basis_name`` -- the name used for the basis
+
+        .. NOTE::
+
+            The base ring is required to be a `\QQ`-algebra for this
+            method to be usable, since the scalar product is defined by
+            its values on the power sum basis.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: m = Sym.m()
+            sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur'); s
+            Symmetric Functions over Rational Field in the Schur basis
+
+        TESTS::
+
+            sage: # needs lrcalc_python
+            sage: TestSuite(s).run(elements=[s[1,1]+2*s[2], s[1]+3*s[1,1]])
+            sage: TestSuite(s).run(skip=["_test_associativity", "_test_prod"])  # long time (7s on sage.math, 2011)
+
+        Note: ``s.an_element()`` is of degree 4; so we skip
+        ``_test_associativity`` and ``_test_prod`` which involve
+        (currently?) expensive calculations up to degree 12.
+        """
+        self._sym = Sym
+        self._sf_base = base
+        self._scalar = scalar
+        self._leading_coeff = leading_coeff
+        sfa.SymmetricFunctionAlgebra_generic.__init__(self, Sym, prefix=prefix, basis_name=basis_name)
+
+        self._self_to_base_cache = {}
+        self._base_to_self_cache = {}
+        self.register_coercion(SetMorphism(Hom(base, self), self._base_to_self))
+        base.register_coercion(SetMorphism(Hom(self, base), self._self_to_base))
+
+    def construction(self):
+        """
+        Return a pair ``(F, R)``, where ``F`` is a
+        :class:`SymmetricFunctionsFunctor` and `R` is a ring, such
+        that ``F(R)`` returns ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: m = Sym.m()
+            sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur')
+            sage: s.construction()
+            (SymmetricFunctionsFunctor[Schur], Rational Field)
+        """
+        return OrthotriangBasisFunctor(self), self.base_ring()
+
+    def _base_to_self(self, x):
+        """
+        Coerce a symmetric function in base ``x`` into ``self``.
+
+        INPUT:
+
+        - ``self`` -- a basis determined by an orthotriangular definition
+        - ``x`` -- an element of the basis `base` to which ``self`` is triangularly related
+
+        OUTPUT: an element of ``self`` equivalent to ``x``
+
+        EXAMPLES::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: m = Sym.m()
+            sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur functions')
+            sage: s._base_to_self(m([2,1]))
+            -2*s[1, 1, 1] + s[2, 1]
+        """
+        return self._from_cache(x, self._base_cache, self._base_to_self_cache)
+
+    def _self_to_base(self, x):
+        """
+        Coerce a symmetric function in ``self`` into base ``x``.
+
+        INPUT:
+
+        - ``self`` -- a basis determined by an orthotriangular definition
+        - ``x`` -- an element of ``self`` as a basis of the ring of symmetric functions
+
+        OUTPUT: the element ``x`` expressed in the basis to which ``self`` is triangularly related
+
+        EXAMPLES::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: m = Sym.m()
+            sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur functions')
+            sage: s._self_to_base(s([2,1]))
+            2*m[1, 1, 1] + m[2, 1]
+        """
+        return self._sf_base._from_cache(x, self._base_cache, self._self_to_base_cache)
+
+    def _base_cache(self, n):
+        """
+        Compute the change of basis between ``self`` and base for the
+        homogeneous component of size ``n``
+
+        INPUT:
+
+        - ``self`` -- a basis determined by an orthotriangular definition
+        - ``n`` -- nonnegative integer
+
+        EXAMPLES::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: m = Sym.m()
+            sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur functions')
+            sage: s._base_cache(2)
+            sage: l = lambda c: [ (i[0],[j for j in sorted(i[1].items())]) for i in sorted(c.items())]
+            sage: l(s._base_to_self_cache[2])
+            [([1, 1], [([1, 1], 1)]), ([2], [([1, 1], -1), ([2], 1)])]
+            sage: l(s._self_to_base_cache[2])
+            [([1, 1], [([1, 1], 1)]), ([2], [([1, 1], 1), ([2], 1)])]
+        """
+        if n in self._self_to_base_cache:
+            return
+        else:
+            self._self_to_base_cache[n] = {}
+
+        self._gram_schmidt(n, self._sf_base, self._scalar,
+                           self._self_to_base_cache,
+                           leading_coeff=self._leading_coeff,
+                           upper_triangular=True)
+        self._invert_morphism(n, self.base_ring(), self._self_to_base_cache,
+                              self._base_to_self_cache,
+                              to_other_function=self._to_base)
+
+    def _to_base(self, part):
+        r"""
+        Return a function which takes in a partition `\mu` and returns the
+        coefficient of a partition in the expansion of ``self`` `(part)` in base.
+
+        INPUT:
+
+        - ``self`` -- a basis determined by an orthotriangular definition
+        - ``part`` -- a partition
+
+        .. NOTE::
+
+           We assume that self._gram_schmidt has been called before
+           self._to_base is called.
+
+        OUTPUT:
+
+        - a function which accepts a partition ``mu`` and returns the coefficients
+          in the expansion of ``self(part)`` in the triangularly related basis.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: m = Sym.m()
+            sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur functions')
+            sage: m(s([2,1]))
+            2*m[1, 1, 1] + m[2, 1]
+            sage: f = s._to_base(Partition([2,1]))
+            sage: [f(p) for p in Partitions(3)]
+            [0, 1, 2]
+        """
+        f = lambda mu: self._self_to_base_cache[part].get(mu, 0)
+        return f
+
+    def product(self, left, right):
+        """
+        Return ``left`` * ``right`` by converting both to the base and then
+        converting back to ``self``.
+
+        INPUT:
+
+        - ``self`` -- a basis determined by an orthotriangular definition
+        - ``left``, ``right`` -- elements in ``self``
+
+        OUTPUT: the expansion of the product of ``left`` and ``right`` in the basis ``self``
+
+        EXAMPLES::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: m = Sym.m()
+            sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur functions')
+            sage: s([1])*s([2,1]) #indirect doctest
+            s[2, 1, 1] + s[2, 2] + s[3, 1]
+        """
+        return self(self._sf_base(left) * self._sf_base(right))
+
+
+from sage.combinat.sf.sfa import SymmetricFunctionsFunctor
+
+
+class OrthotriangBasisFunctor(SymmetricFunctionsFunctor):
+    """
+    A constructor for algebras of symmetric functions constructed by
+    orthogonality and triangularity.
+
+    EXAMPLES::
+
+        sage: from sage.combinat.sf.sfa import zee
+        sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+        sage: Sym = SymmetricFunctions(QQ)
+        sage: m = Sym.m()
+        sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur')
+        sage: s.construction()
+        (SymmetricFunctionsFunctor[Schur], Rational Field)
+    """
+    def __init__(self, basis):
+        r"""
+        Initialize the functor.
+
+        INPUT:
+
+        - ``basis`` -- the basis of the symmetric function algebra
+
+        TESTS::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(QQ)
+            sage: m = Sym.m()
+            sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur')
+            sage: F, R = s.construction()
+            sage: TestSuite(F).run()
+        """
+        self._basis_name = basis.basis_name()
+        self._sf_base = basis._sf_base
+        self._scalar = basis._scalar
+        self._leading_coeff = basis._leading_coeff
+        self._prefix = basis._prefix
+        super().__init__(basis, self._basis_name)
+
+    def _apply_functor(self, R):
+        """
+        Apply the functor to an object of ``self``'s domain.
+
+        EXAMPLES::
+
+            sage: from sage.combinat.sf.sfa import zee
+            sage: from sage.combinat.sf.orthotriang import SymmetricFunctionAlgebra_orthotriang
+            sage: Sym = SymmetricFunctions(ZZ)
+            sage: m = Sym.m()
+            sage: s = SymmetricFunctionAlgebra_orthotriang(Sym, m, zee, 's', 'Schur functions')
+            sage: F, R = s.construction()  # indirect doctest
+            sage: F(QQbar)                                                              # needs sage.rings.number_field
+            Symmetric Functions over Algebraic Field in the Schur functions basis
+        """
+        from sage.combinat.sf.sf import SymmetricFunctions
+        return self._basis(SymmetricFunctions(R), self._sf_base.change_ring(R),
+                           self._scalar, self._prefix, self._basis_name,
+                           self._leading_coeff)
+
+
+# Backward compatibility for unpickling
+from sage.misc.persist import register_unpickle_override
+
+register_unpickle_override('sage.combinat.sf.orthotriang', 'SymmetricFunctionAlgebraElement_orthotriang', SymmetricFunctionAlgebra_orthotriang.Element)