passagemath-combinat 10.6.31rc3__cp314-cp314-musllinux_1_2_x86_64.whl

sage/algebras/askey_wilson.py

@@ -0,0 +1,935 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+"""
+Askey-Wilson Algebras
+
+AUTHORS:
+
+- Travis Scrimshaw (2018-08): initial version
+"""
+
+# ****************************************************************************
+#  Copyright (C) 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/
+# ****************************************************************************
+
+from sage.misc.cachefunc import cached_method
+from sage.categories.algebras import Algebras
+from sage.categories.cartesian_product import cartesian_product
+from sage.categories.rings import Rings
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.modules.with_basis.morphism import ModuleMorphismByLinearity
+from sage.sets.family import Family
+from sage.rings.polynomial.laurent_polynomial_ring import LaurentPolynomialRing
+from sage.sets.non_negative_integers import NonNegativeIntegers
+
+
+class AskeyWilsonAlgebra(CombinatorialFreeModule):
+    r"""
+    The (universal) Askey-Wilson algebra.
+
+    Let `R` be a commutative ring. The *universal Askey-Wilson* algebra
+    is an associative unital algebra `\Delta_q` over `R[q,q^-1]` given
+    by the generators `A, B, C, \alpha, \beta, \gamma` that satisfy the
+    following relations:
+
+    .. MATH::
+
+        \begin{aligned}
+        (q-q^{-1}) \alpha &= (q^2-q^{-2}) A + qBC - q^{-1}CB, \\
+        (q-q^{-1}) \beta  &= (q^2-q^{-2}) B + qCA - q^{-1}AC, \\
+        (q-q^{-1}) \gamma &= (q^2-q^{-2}) C + qAB - q^{-1}BA.
+        \end{aligned}
+
+    The universal Askey-Wilson contains a
+    :meth:`Casimir element <casimir_element>` `\Omega`, and the elements
+    `\alpha`, `\beta`, `\gamma`, `\Omega` generate the center of `\Delta_q`,
+    which is isomorphic to the polynomial ring
+    `(R[q,q^-1])[\alpha,\beta,\gamma,\Omega]` (assuming `q` is not a root
+    of unity). Furthermore, the relations imply that `\Delta_q` has a basis
+    given by monomials `A^i B^j C^k \alpha^r \beta^s \gamma^t`, where
+    `i, j, k, r, s, t \in \ZZ_{\geq 0}`.
+
+    The universal Askey-Wilson algebra also admits a faithful action
+    of `PSL_2(\ZZ)` given by the automorphisms `\rho`
+    (:meth:`permutation_automorphism`):
+
+    .. MATH::
+
+        A \mapsto B \mapsto C \mapsto A,
+        \qquad
+        \alpha \mapsto \beta \mapsto \gamma \mapsto \alpha.
+
+    and `\sigma` (:meth:`reflection_automorphism`):
+
+    .. MATH::
+
+        A \mapsto B \mapsto A,
+        C \mapsto C + \frac{AB - BA}{q-q^{-1}},
+        \qquad
+        \alpha \mapsto \beta \mapsto \alpha,
+        \gamma \mapsto \gamma.
+
+    Note that `\rho^3 = \sigma^2 = 1` and
+
+    .. MATH::
+
+        \sigma(C) = C - q AB - (1+q^2) C + q \gamma
+                  = C - q AB - q^2 C + q \gamma.
+
+    The Askey-Wilson `AW_q(a,b,c)` algebra is a specialization of the
+    universal Askey-Wilson algebra by `\alpha = a`, \beta = b`,
+    `\gamma = c`, where `a,b,c \in R`. `AW_q(a,b,c)` was first introduced
+    by [Zhedanov1991]_ to describe the Askey-Wilson polynomials. The
+    Askey-Wilson algebra has a central extension of `\Delta_q`.
+
+    INPUT:
+
+    - ``R`` -- a commutative ring
+    - ``q`` -- (optional) the parameter `q`; must be invertible in ``R``
+
+    If ``q`` is not specified, then ``R`` is taken to be the base
+    ring of a Laurent polynomial ring with variable `q`. Otherwise
+    the element ``q`` must be an element of ``R``.
+
+    .. NOTE::
+
+        No check is performed to ensure ``q`` is not a root of unity,
+        which may lead to violations of the results in [Terwilliger2011]_.
+
+    EXAMPLES:
+
+    We create the universal Askey-Wilson algebra and check
+    the defining relations::
+
+        sage: AW = algebras.AskeyWilson(QQ)
+        sage: AW.inject_variables()
+        Defining A, B, C, a, b, g
+        sage: q = AW.q()
+        sage: (q^2-q^-2)*A + q*B*C - q^-1*C*B == (q-q^-1)*a
+        True
+        sage: (q^2-q^-2)*B + q*C*A - q^-1*A*C == (q-q^-1)*b
+        True
+        sage: (q^2-q^-2)*C + q*A*B - q^-1*B*A == (q-q^-1)*g
+        True
+
+    Next, we perform some computations::
+
+        sage: C * A
+        (q^-2)*A*C + (q^-3-q)*B - (q^-2-1)*b
+        sage: B^2 * g^2 * A
+        q^4*A*B^2*g^2 - (q^-1-q^7)*B*C*g^2 + (1-q^4)*B*g^3
+         + (1-2*q^4+q^8)*A*g^2 - (q-q^3-q^5+q^7)*a*g^2
+        sage: (B^3 - A) * (C^2 + q*A*B)
+        q^7*A*B^4 + B^3*C^2 - (q^2-q^14)*B^3*C + (q-q^7)*B^3*g - q*A^2*B
+         + (3*q^3-4*q^7+q^19)*A*B^2 - A*C^2 - (1-q^6-q^8+q^14)*B^2*a
+         - (q^-2-3*q^6+3*q^14-q^22)*B*C
+         + (q^-1+q-3*q^3-q^5+2*q^7-q^9+q^13+q^15-q^19)*B*g
+         + (2*q^-1-6*q^3+5*q^7-2*q^19+q^23)*A
+         - (2-2*q^2-4*q^4+4*q^6+q^8-q^10+q^12-q^14+q^16-q^18-q^20+q^22)*a
+
+    We check the elements `\alpha`, `\beta`, and `\gamma`
+    are in the center::
+
+        sage: all(x * gen == gen * x for gen in AW.algebra_generators() for x in [a,b,g])
+        True
+
+    We verify that the :meth:`Casimir element <casimir_element>`
+    is in the center::
+
+        sage: Omega = AW.casimir_element()
+        sage: all(x * Omega == Omega * x for x in [A,B,C])
+        True
+
+        sage: x = AW.an_element()
+        sage: O2 = Omega^2
+        sage: x * O2 == O2 * x
+        True
+
+    We prove Lemma 2.1 in [Terwilliger2011]_::
+
+        sage: (q^2-q^-2) * C == (q-q^-1) * g - (q*A*B - q^-1*B*A)
+        True
+        sage: (q-q^-1) * (q^2-q^-2) * a == (B^2*A - (q^2+q^-2)*B*A*B + A*B^2
+        ....:                               + (q^2-q^-2)^2*A + (q-q^-1)^2*B*g)
+        True
+        sage: (q-q^-1) * (q^2-q^-2) * b == (A^2*B - (q^2+q^-2)*A*B*A + B*A^2
+        ....:                               + (q^2-q^-2)^2*B + (q-q^-1)^2*A*g)
+        True
+
+    We prove Theorem 2.2 in [Terwilliger2011]_::
+
+        sage: q3 = q^-2 + 1 + q^2
+        sage: A^3*B - q3*A^2*B*A + q3*A*B*A^2 - B*A^3 == -(q^2-q^-2)^2 * (A*B - B*A)
+        True
+        sage: B^3*A - q3*B^2*A*B + q3*B*A*B^2 - A*B^3 == -(q^2-q^-2)^2 * (B*A - A*B)
+        True
+        sage: (A^2*B^2 - B^2*A^2 + (q^2+q^-2)*(B*A*B*A-A*B*A*B)
+        ....:  == -(q^1-q^-1)^2 * (A*B - B*A) * g)
+        True
+
+    We construct an Askey-Wilson algebra over `\GF{5}` at `q=2`::
+
+        sage: AW = algebras.AskeyWilson(GF(5), q=2)
+        sage: A,B,C,a,b,g = AW.algebra_generators()
+        sage: q = AW.q()
+        sage: Omega = AW.casimir_element()
+
+        sage: B * A
+        4*A*B + 2*g
+        sage: C * A
+        4*A*C + 2*b
+        sage: C * B
+        4*B*C + 2*a
+        sage: Omega^2
+        A^2*B^2*C^2 + A^3*B*C + A*B^3*C + A*B*C^3 + A^4 + 4*A^3*a
+         + 2*A^2*B^2 + A^2*B*b + 2*A^2*C^2 + 4*A^2*C*g + 4*A^2*a^2
+         + 4*A*B^2*a + 4*A*C^2*a + B^4 + B^3*b + 2*B^2*C^2 + 4*B^2*C*g
+         + 4*B^2*b^2 + B*C^2*b + C^4 + 4*C^3*g + 4*C^2*g^2 + 2*a*b*g
+
+        sage: (q^2-q^-2)*A + q*B*C - q^-1*C*B == (q-q^-1)*a
+        True
+        sage: (q^2-q^-2)*B + q*C*A - q^-1*A*C == (q-q^-1)*b
+        True
+        sage: (q^2-q^-2)*C + q*A*B - q^-1*B*A == (q-q^-1)*g
+        True
+        sage: all(x * Omega == Omega * x for x in [A,B,C])
+        True
+
+    REFERENCES:
+
+    - [Terwilliger2011]_
+    """
+    @staticmethod
+    def __classcall_private__(cls, R, q=None):
+        r"""
+        Normalize input to ensure a unique representation.
+
+        TESTS::
+
+            sage: R.<q> = LaurentPolynomialRing(QQ)
+            sage: AW1 = algebras.AskeyWilson(QQ)
+            sage: AW2 = algebras.AskeyWilson(R, q)
+            sage: AW1 is AW2
+            True
+
+            sage: AW = algebras.AskeyWilson(ZZ, 0)
+            Traceback (most recent call last):
+            ...
+            ValueError: q cannot be 0
+
+            sage: AW = algebras.AskeyWilson(ZZ, 3)
+            Traceback (most recent call last):
+            ...
+            ValueError: q=3 is not invertible in Integer Ring
+        """
+        if q is None:
+            R = LaurentPolynomialRing(R, 'q')
+            q = R.gen()
+        else:
+            q = R(q)
+        if q == 0:
+            raise ValueError("q cannot be 0")
+        if 1 / q not in R:
+            raise ValueError("q={} is not invertible in {}".format(q, R))
+        if R not in Rings().Commutative():
+            raise ValueError("{} is not a commutative ring".format(R))
+        return super().__classcall__(cls, R, q)
+
+    def __init__(self, R, q) -> None:
+        r"""
+        Initialize ``self``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: TestSuite(AW).run()  # long time
+        """
+        self._q = q
+        cat = Algebras(Rings().Commutative()).WithBasis()
+        indices = cartesian_product([NonNegativeIntegers()]*6)
+        CombinatorialFreeModule.__init__(self, R, indices, prefix='AW',
+                                         sorting_key=_basis_key,
+                                         sorting_reverse=True,
+                                         category=cat)
+        self._assign_names('A,B,C,a,b,g')
+
+    def _repr_term(self, t) -> str:
+        r"""
+        Return a string representation of the basis element indexed by ``t``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: AW._repr_term((0,0,0,0,0,0))
+            '1'
+            sage: AW._repr_term((5,1,2,3,7,2))
+            'A^5*B*C^2*a^3*b^7*g^2'
+            sage: AW._repr_term((0,1,0,3,7,2))
+            'B*a^3*b^7*g^2'
+        """
+        def exp(l, e):
+            if e == 0:
+                return ''
+            if e == 1:
+                return '*' + l
+            return '*' + l + '^{}'.format(e)
+        ret = ''.join(exp(l, e) for l, e in zip('ABCabg', t))
+        if not ret:
+            return '1'
+        if ret[0] == '*':
+            ret = ret[1:]
+        return ret
+
+    def _latex_term(self, t) -> str:
+        r"""
+        Return a latex representation of the basis element indexed by ``t``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: AW._latex_term((0,0,0,0,0,0))
+            '1'
+            sage: AW._latex_term((5,1,2,3,7,2))
+            'A^{5}BC^{2}\\alpha^{3}\\beta^{7}\\gamma^{2}'
+            sage: AW._latex_term((0,1,0,3,7,2))
+            'B\\alpha^{3}\\beta^{7}\\gamma^{2}'
+        """
+        if sum(t) == 0:
+            return '1'
+
+        def exp(l, e):
+            if e == 0:
+                return ''
+            if e == 1:
+                return l
+            return l + '^{{{}}}'.format(e)
+        var_names = ['A', 'B', 'C', '\\alpha', '\\beta', '\\gamma']
+        return ''.join(exp(l, e) for l, e in zip(var_names, t))
+
+    def _repr_(self):
+        r"""
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: algebras.AskeyWilson(QQ)
+            Askey-Wilon algebra with q=q over
+             Univariate Laurent Polynomial Ring in q over Rational Field
+        """
+        return "Askey-Wilon algebra with q={} over {}".format(self._q, self.base_ring())
+
+    @cached_method
+    def algebra_generators(self):
+        r"""
+        Return the algebra generators of ``self``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: G = AW.algebra_generators()
+            sage: G['A']
+            A
+            sage: G['a']
+            a
+            sage: list(G)
+            [A, B, C, a, b, g]
+        """
+        A = self.variable_names()
+
+        def build_monomial(g):
+            exp = [0] * 6
+            exp[A.index(g)] = 1
+            return self.monomial(self._indices(exp))
+        return Family(A, build_monomial)
+
+    @cached_method
+    def gens(self) -> tuple:
+        r"""
+        Return the generators of ``self``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: AW.gens()
+            (A, B, C, a, b, g)
+        """
+        return tuple(self.algebra_generators())
+
+    @cached_method
+    def one_basis(self):
+        r"""
+        Return the index of the basis element `1` of ``self``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: AW.one_basis()
+            (0, 0, 0, 0, 0, 0)
+        """
+        return self._indices([0]*6)
+
+    def q(self):
+        r"""
+        Return the parameter `q` of ``self``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: q = AW.q()
+            sage: q
+            q
+            sage: q.parent()
+            Univariate Laurent Polynomial Ring in q over Rational Field
+        """
+        return self._q
+
+    @cached_method
+    def _an_element_(self):
+        r"""
+        Return an element of ``self``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: AW.an_element()
+            (q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A
+        """
+        q = self._q
+        I = self._indices
+        R = self.base_ring()
+        elt = {I((1,0,0,0,0,0)): R(1),
+               I((1,0,2,0,1,0)): R.an_element(),
+               I((0,1,0,2,0,1)): q**2 * R(3),
+               I((0,0,0,1,1,3)): q**-3 + R(3) + R(2)*q + q**2}
+        return self.element_class(self, elt)
+
+    def some_elements(self):
+        r"""
+        Return some elements of ``self``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: AW.some_elements()
+            (A, B, C, a, b, g, 1,
+             (q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A,
+             q*A*B*C + q^2*A^2 - q*A*a + (q^-2)*B^2 - (q^-1)*B*b + q^2*C^2 - q*C*g)
+        """
+        return self.gens() + (self.one(), self.an_element(), self.casimir_element())
+
+    @cached_method
+    def casimir_element(self):
+        r"""
+        Return the Casimir element of ``self``.
+
+        The Casimir element of the Askey-Wilson algebra `\Delta_q` is
+
+        .. MATH::
+
+            \Omega = q ABC + q^2 A^2 + q^{-2} B^2 + q^2 C^2
+                     - q A\alpha - q^{-1} B\beta - q C\gamma.
+
+        The center `Z(\Delta_q)` is generated by `\alpha`, `\beta`,
+        `\gamma`, and `\Omega`.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: AW.casimir_element()
+            q*A*B*C + q^2*A^2 - q*A*a + (q^-2)*B^2 - (q^-1)*B*b + q^2*C^2 - q*C*g
+
+        We check that the Casimir element is in the center::
+
+            sage: Omega = AW.casimir_element()
+            sage: all(Omega * gen == gen * Omega for gen in AW.algebra_generators())
+            True
+        """
+        q = self._q
+        I = self._indices
+        d = {I((1, 1, 1, 0, 0, 0)): q,       # q ABC
+             I((2, 0, 0, 0, 0, 0)): q**2,    # q^2 A^2
+             I((0, 2, 0, 0, 0, 0)): q**-2,   # q^-2 B^2
+             I((0, 0, 2, 0, 0, 0)): q**2,    # q^2 C^2
+             I((1, 0, 0, 1, 0, 0)): -q,      # -q A\alpha
+             I((0, 1, 0, 0, 1, 0)): -q**-1,  # -q^-1 B\beta
+             I((0, 0, 1, 0, 0, 1)): -q}      # -q C\gamma
+        return self.element_class(self, d)
+
+    @cached_method
+    def product_on_basis(self, x, y):
+        """
+        Return the product of the basis elements indexed by ``x`` and ``y``.
+
+        INPUT:
+
+        - ``x``, ``y`` -- tuple of length 6
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: AW.product_on_basis((0,0,0,0,0,0), (3,5,2,0,12,3))
+            A^3*B^5*C^2*b^12*g^3
+            sage: AW.product_on_basis((0,0,0,5,3,5), (3,5,2,0,12,3))
+            A^3*B^5*C^2*a^5*b^15*g^8
+            sage: AW.product_on_basis((7,0,0,5,3,5), (0,5,2,0,12,3))
+            A^7*B^5*C^2*a^5*b^15*g^8
+            sage: AW.product_on_basis((7,3,0,5,3,5), (0,2,2,0,12,3))
+            A^7*B^5*C^2*a^5*b^15*g^8
+            sage: AW.product_on_basis((0,1,0,5,3,5), (2,0,0,0,5,3))
+            q^4*A^2*B*a^5*b^8*g^8 - (q^-3-q^5)*A*C*a^5*b^8*g^8
+             + (1-q^4)*A*a^5*b^8*g^9 - (q^-4-2+q^4)*B*a^5*b^8*g^8
+             + (q^-3-q^-1-q+q^3)*a^5*b^9*g^8
+            sage: AW.product_on_basis((0,2,1,0,2,0), (1,1,0,2,1,0))
+            q^4*A*B^3*C*a^2*b^3 - (q^5-q^9)*A^2*B^2*a^2*b^3
+             + (q^2-q^4)*A*B^2*a^3*b^3 + (q^-3-q)*B^4*a^2*b^3
+             - (q^-2-1)*B^3*a^2*b^4 - (q-q^9)*B^2*C^2*a^2*b^3
+             + (1-q^4)*B^2*C*a^2*b^3*g + (q^-4+2-5*q^4+2*q^12)*A*B*C*a^2*b^3
+             - (q^-1+q-2*q^3-2*q^5+q^7+q^9)*A*B*a^2*b^3*g
+             - (q^-3-q^3-2*q^5+q^7+q^9)*B*C*a^3*b^3
+             + (q^-2-1-q^2+q^4)*B*a^3*b^3*g
+             - (q^-3-2*q+2*q^9-q^13)*A^2*a^2*b^3
+             + (2*q^-2-2-3*q^2+3*q^4+q^10-q^12)*A*a^3*b^3
+             + (q^-7-2*q^-3+2*q^5-q^9)*B^2*a^2*b^3
+             - (q^-6-q^-4-q^-2+1-q^2+q^4+q^6-q^8)*B*a^2*b^4
+             - (q^-7-q^-3-2*q+2*q^5+q^9-q^13)*C^2*a^2*b^3
+             + (q^-6-3-2*q^2+5*q^4-q^8+q^10-q^12)*C*a^2*b^3*g
+             - (q^-1-2*q+2*q^5-q^7)*a^4*b^3
+             - (q^-3-q^-1-2*q+2*q^3+q^5-q^7)*a^2*b^3*g^2
+        """
+        I = self._indices
+        # Commute the central parts to the right
+        lhs = list(x[:3])
+        rhs = list(y)
+        for i in range(3, 6):
+            rhs[i] += x[i]
+
+        # No ABC variables on the RHS to move past
+        if sum(rhs[:3]) == 0:
+            return self.monomial(I(lhs + rhs[3:]))
+
+        # We recurse using the PBW-type basis property:
+        #   that YX = XY + lower order terms (see Theorem 4.1 in Terwilliger).
+        q = self._q
+        if lhs[2] > 0:  # lhs has a C
+            if rhs[0] > 0:  # rhs has an A to commute with C
+                lhs[2] -= 1
+                rhs[0] -= 1
+                rel = {I((1, 0, 1, 0, 0, 0)): q**-2,         # q^2 AC
+                       I((0, 1, 0, 0, 0, 0)): q**-3 - q**1,  # q^-1(q^-2-q^2) B
+                       I((0, 0, 0, 0, 1, 0)): 1 - q**-2}     # -q^-1(q^-1-q) b
+                rel = self.element_class(self, rel)
+                return self.monomial(I(lhs+[0]*3)) * (rel * self.monomial(I(rhs)))
+            elif rhs[1] > 0:  # rhs has a B to commute with C
+                lhs[2] -= 1
+                rhs[1] -= 1
+                rel = {I((0, 1, 1, 0, 0, 0)): q**2,           # q^2 BC
+                       I((1, 0, 0, 0, 0, 0)): q**3 - q**-1,  # q(q^2-q^-2) A
+                       I((0, 0, 0, 1, 0, 0)): -q**2 + 1}     # -q(q-q^-1) a
+                rel = self.element_class(self, rel)
+                return self.monomial(I(lhs+[0]*3)) * (rel * self.monomial(I(rhs)))
+            else:  # nothing to commute as rhs has no A nor B
+                rhs[2] += lhs[2]
+                rhs[1] = lhs[1]
+                rhs[0] = lhs[0]
+                return self.monomial(I(rhs))
+
+        elif lhs[1] > 0:  # lhs has a B
+            if rhs[0] > 0:  # rhs has an A to commute with B
+                lhs[1] -= 1
+                rhs[0] -= 1
+                rel = {I((1, 1, 0, 0, 0, 0)): q**2,          # q^2 AB
+                       I((0, 0, 1, 0, 0, 0)): q**3 - q**-1,  # q(q^2-q^-2) C
+                       I((0, 0, 0, 0, 0, 1)): -q**2 + 1}     # -q(q-q^-1) g
+                rel = self.element_class(self, rel)
+                return self.monomial(I(lhs+[0]*3)) * (rel * self.monomial(I(rhs)))
+            else:  # nothing to commute as rhs has no A
+                rhs[1] += lhs[1]
+                rhs[0] = lhs[0]
+                return self.monomial(I(rhs))
+
+        elif lhs[0] > 0:  # lhs has an A
+            rhs[0] += lhs[0]
+            return self.monomial(I(rhs))
+
+        # otherwise, lhs is just 1
+        return self.monomial(I(rhs))
+
+    def permutation_automorphism(self):
+        r"""
+        Return the permutation automorphism `\rho` of ``self``.
+
+        We define the automorphism `\rho` by
+
+        .. MATH::
+
+            A \mapsto B \mapsto C \mapsto A,
+            \qquad
+            \alpha \mapsto \beta \mapsto \gamma \mapsto \alpha.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: rho = AW.permutation_automorphism()
+            sage: [rho(gen) for gen in AW.algebra_generators()]
+            [B, C, A, b, g, a]
+
+            sage: AW.an_element()
+            (q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A
+            sage: rho(AW.an_element())
+            (q^-3+3+2*q+q^2)*a^3*b*g + q^5*A^2*B*g + 3*q^2*C*a*b^2
+             - (q^-2-q^6)*A*C*g + (q-q^5)*A*g^2 - (q^-3-2*q+q^5)*B*g
+             + (q^-2-1-q^2+q^4)*b*g + B
+
+            sage: r3 = rho * rho * rho
+            sage: [r3(gen) for gen in AW.algebra_generators()]
+            [A, B, C, a, b, g]
+            sage: r3(AW.an_element()) == AW.an_element()
+            True
+        """
+        A,B,C,a,b,g = self.gens()
+        return AlgebraMorphism(self, [B,C,A,b,g,a], codomain=self)
+
+    rho = permutation_automorphism
+
+    def reflection_automorphism(self):
+        r"""
+        Return the reflection automorphism `\sigma` of ``self``.
+
+        We define the automorphism `\sigma` by
+
+        .. MATH::
+
+            A \mapsto B \mapsto A,
+            \qquad
+            C \mapsto C + \frac{AB - BA}{q-q^{-1}}
+            = C - qAB - (1+q^2) C + q \gamma,
+
+        .. MATH::
+
+            \alpha \mapsto \beta \mapsto \alpha,
+            \gamma \mapsto \gamma.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: sigma = AW.reflection_automorphism()
+            sage: [sigma(gen) for gen in AW.algebra_generators()]
+            [B, A, -q*A*B - q^2*C + q*g, b, a, g]
+
+            sage: AW.an_element()
+            (q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A
+            sage: sigma(AW.an_element())
+            q^9*A^2*B^3*a + (q^10+q^14)*A*B^2*C*a - (q^7+q^9)*A*B^2*a*g
+             + (q^-3+3+2*q+q^2)*a*b*g^3 + (q-3*q^9+q^13+q^17)*A^2*B*a
+             - (q^2-q^6-q^8+q^14)*A*B*a^2 + 3*q^2*A*b^2*g + (q^5-q^9)*B^3*a
+             - (q^6-q^8)*B^2*a*b + q^13*B*C^2*a - 2*q^10*B*C*a*g + q^7*B*a*g^2
+             + (q^2-2*q^10+q^18)*A*C*a - (q-q^7-2*q^9+2*q^11-q^15+q^17)*A*a*g
+             - (q^3-q^7-q^9+q^13)*C*a^2 + (q^2-q^6-2*q^8+2*q^10)*a^2*g
+             + (q-3*q^5+3*q^9-q^13)*B*a - (q^2-q^4-2*q^6+2*q^8+q^10-q^12)*a*b + B
+
+            sage: s2 = sigma * sigma
+            sage: [s2(gen) for gen in AW.algebra_generators()]
+            [A, B, C, a, b, g]
+            sage: s2(AW.an_element()) == AW.an_element()
+            True
+        """
+        A,B,C,a,b,g = self.gens()
+        q = self._q
+        # Note that sage: (A*B-B*A) / (q-q^-1) == -q*A*B - (1+q^2)*C + q*g
+        Cp = C - q*A*B - (1+q**2)*C + q*g
+        return AlgebraMorphism(self, [B,A,Cp,b,a,g], codomain=self)
+
+    sigma = reflection_automorphism
+
+    def loop_representation(self):
+        r"""
+        Return the map `\pi` from ``self`` to `2 \times 2` matrices
+        over `R[\lambda,\lambda^{-1}]`, where `F` is the fraction field
+        of the base ring of ``self``.
+
+        Let `AW` be the Askey-Wilson algebra over `R`, and let `F` be
+        the fraction field of `R`. Let `M` be the space of `2 \times 2`
+        matrices over `F[\lambda, \lambda^{-1}]`. Consider the following
+        elements of `M`:
+
+        .. MATH::
+
+            \mathcal{A} = \begin{pmatrix}
+                \lambda & 1 - \lambda^{-1} \\ 0 & \lambda^{-1}
+            \end{pmatrix},
+            \qquad
+            \mathcal{B} = \begin{pmatrix}
+                \lambda^{-1} & 0 \\ \lambda - 1 & \lambda
+            \end{pmatrix},
+            \qquad
+            \mathcal{C} = \begin{pmatrix}
+                1 & \lambda - 1 \\ 1 - \lambda^{-1} & \lambda + \lambda^{-1} - 1
+            \end{pmatrix}.
+
+        From Lemma 3.11 of [Terwilliger2011]_, we define a
+        representation `\pi: AW \to M` by
+
+        .. MATH::
+
+            A \mapsto q \mathcal{A} + q^{-1} \mathcal{A}^{-1},
+            \qquad
+            B \mapsto q \mathcal{B} + q^{-1} \mathcal{B}^{-1},
+            \qquad
+            C \mapsto q \mathcal{C} + q^{-1} \mathcal{C}^{-1},
+
+        .. MATH::
+
+            \alpha, \beta, \gamma \mapsto \nu I,
+
+        where `\nu = (q^2 + q^-2)(\lambda + \lambda^{-1})
+        + (\lambda + \lambda^{-1})^2`.
+
+        We call this representation the *loop representation* as
+        it is a representation using the loop group
+        `SL_2(F[\lambda,\lambda^{-1}])`.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: q = AW.q()
+            sage: pi = AW.loop_representation()
+            sage: A,B,C,a,b,g = [pi(gen) for gen in AW.algebra_generators()]
+            sage: A
+            [                1/q*lambda^-1 + q*lambda ((-q^2 + 1)/q)*lambda^-1 + ((q^2 - 1)/q)]
+            [                                       0                 q*lambda^-1 + 1/q*lambda]
+            sage: B
+            [             q*lambda^-1 + 1/q*lambda                                     0]
+            [((-q^2 + 1)/q) + ((q^2 - 1)/q)*lambda              1/q*lambda^-1 + q*lambda]
+            sage: C
+            [1/q*lambda^-1 + ((q^2 - 1)/q) + 1/q*lambda      ((q^2 - 1)/q) + ((-q^2 + 1)/q)*lambda]
+            [  ((q^2 - 1)/q)*lambda^-1 + ((-q^2 + 1)/q)    q*lambda^-1 + ((-q^2 + 1)/q) + q*lambda]
+            sage: a
+            [lambda^-2 + ((q^4 + 1)/q^2)*lambda^-1 + 2 + ((q^4 + 1)/q^2)*lambda + lambda^2                                                                             0]
+            [                                                                            0 lambda^-2 + ((q^4 + 1)/q^2)*lambda^-1 + 2 + ((q^4 + 1)/q^2)*lambda + lambda^2]
+            sage: a == b
+            True
+            sage: a == g
+            True
+
+            sage: AW.an_element()
+            (q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A
+            sage: x = pi(AW.an_element())
+            sage: y = (q^-3+3+2*q+q^2)*a*b*g^3 + q*A*C^2*b + 3*q^2*B*a^2*g + A
+            sage: x == y
+            True
+
+        We check the defining relations of the Askey-Wilson algebra::
+
+            sage: A + (q*B*C - q^-1*C*B) / (q^2 - q^-2) == a / (q + q^-1)
+            True
+            sage: B + (q*C*A - q^-1*A*C) / (q^2 - q^-2) == b / (q + q^-1)
+            True
+            sage: C + (q*A*B - q^-1*B*A) / (q^2 - q^-2) == g / (q + q^-1)
+            True
+
+        We check Lemma 3.12 in [Terwilliger2011]_::
+
+            sage: M = pi.codomain()
+            sage: la = M.base_ring().gen()
+            sage: p = M([[0,-1],[1,1]])
+            sage: s = M([[0,1],[la,0]])
+            sage: rho = AW.rho()
+            sage: sigma = AW.sigma()
+            sage: all(p*pi(gen)*~p == pi(rho(gen)) for gen in AW.algebra_generators())
+            True
+            sage: all(s*pi(gen)*~s == pi(sigma(gen)) for gen in AW.algebra_generators())
+            True
+        """
+        from sage.matrix.matrix_space import MatrixSpace
+        q = self._q
+        base = LaurentPolynomialRing(self.base_ring().fraction_field(), 'lambda')
+        la = base.gen()
+        inv = ~la
+        M = MatrixSpace(base, 2)
+        A = M([[la,1-inv],[0,inv]])
+        Ai = M([[inv,inv-1],[0,la]])
+        B = M([[inv,0],[la-1,la]])
+        Bi = M([[la,0],[1-la,inv]])
+        C = M([[1,1-la],[inv-1,la+inv-1]])
+        Ci = M([[la+inv-1,la-1],[1-inv,1]])
+        mu = la + inv
+        nu = (self._q**2 + self._q**-2) * mu + mu**2
+        nuI = M(nu)
+        # After #29374 is fixed, the category can become
+        # Algebras(Rings().Commutative()) as it was before #29399.
+        category = Rings()
+        return AlgebraMorphism(self, [q*A + q**-1*Ai, q*B + q**-1*Bi, q*C + q**-1*Ci,
+                                      nuI, nuI, nuI],
+                               codomain=M, category=category)
+
+    pi = loop_representation
+
+
+def _basis_key(t):
+    """
+    Return a key for the basis element of the Askey-Wilson algebra
+    indexed by ``t``.
+
+    EXAMPLES::
+
+        sage: from sage.algebras.askey_wilson import _basis_key
+        sage: I = algebras.AskeyWilson(QQ).indices()
+        sage: _basis_key(I((0,2,3,1,2,5)))
+        (13, (0, 2, 3, 1, 2, 5))
+    """
+    return (sum(t), t.value)
+
+
+class AlgebraMorphism(ModuleMorphismByLinearity):
+    """
+    An algebra morphism of the Askey-Wilson algebra defined by
+    the images of the generators.
+    """
+    def __init__(self, domain, on_generators, position=0, codomain=None,
+                 category=None):
+        """
+        Given a map on the multiplicative basis of a free algebra, this method
+        returns the algebra morphism that is the linear extension of its image
+        on generators.
+
+        INPUT:
+
+        - ``domain`` -- an Askey-Wilson algebra
+        - ``on_generators`` -- list of length 6 corresponding to
+          the images of the generators
+        - ``codomain`` -- (optional) the codomain
+        - ``position`` -- integer (default: 0)
+        - ``category`` -- (optional) category
+
+        OUTPUT: module morphism
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: sigma = AW.sigma()
+            sage: TestSuite(sigma).run()
+        """
+        if category is None:
+            category = Algebras(Rings().Commutative()).WithBasis()
+        self._on_generators = tuple(on_generators)
+        ModuleMorphismByLinearity.__init__(self, domain=domain, codomain=codomain,
+                                           position=position, category=category)
+
+    def __eq__(self, other):
+        """
+        Check equality.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.askey_wilson import AlgebraMorphism
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: rho = AW.rho()
+            sage: sigma = AW.sigma()
+            sage: id = AlgebraMorphism(AW, AW.gens(), codomain=AW)
+            sage: sigma * sigma == id
+            True
+            sage: id == rho * rho * rho
+            True
+        """
+        return (self.__class__ is other.__class__ and self.parent() == other.parent()
+                and self._zero == other._zero
+                and self._on_generators == other._on_generators
+                and self._position == other._position
+                and self._is_module_with_basis_over_same_base_ring
+                    == other._is_module_with_basis_over_same_base_ring)
+
+    def _on_basis(self, c):
+        r"""
+        Compute the image of this morphism on the basis element
+        indexed by ``c``.
+
+        INPUT:
+
+        - ``c`` -- tuple of length 6
+
+        OUTPUT: element of the codomain
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: AW.inject_variables()
+            Defining A, B, C, a, b, g
+            sage: rho = AW.rho()
+            sage: sigma = AW.sigma()
+            sage: rho._on_basis((2,1,1,2,0,5))
+            q^2*A*B^2*C*a^5*b^2 + (q^-3-q)*B^3*a^5*b^2 - (q^-2-1)*B^2*a^5*b^3
+             - (q^-3-q^5)*B*C^2*a^5*b^2 + (q^-2-q^2)*B*C*a^5*b^2*g
+             + (q^-2-2*q^2+q^6)*A*C*a^5*b^2 - (q^-1-q-q^3+q^5)*C*a^6*b^2
+
+            sage: sigma._on_basis((2,1,1,2,0,5))
+            -q^9*A^2*B^3*b^2*g^5 + (q^2-q^10-q^14)*A*B^2*C*b^2*g^5
+             - (q^3-q^7-q^9)*A*B^2*b^2*g^6
+             - (2*q-q^5-3*q^9+q^13+q^17)*A^2*B*b^2*g^5
+             + (1-q^6-q^8+q^14)*A*B*a*b^2*g^5 + (q^-3-q-q^5+q^9)*B^3*b^2*g^5
+             - (q^-2-1-q^6+q^8)*B^2*b^3*g^5 + (q^5-q^13)*B*C^2*b^2*g^5
+             - (q^2+q^6-2*q^10)*B*C*b^2*g^6 + (q^3-q^7)*B*b^2*g^7
+             + (q^-6-4*q^2+2*q^6+2*q^10-q^18)*A*C*b^2*g^5
+             - (q^-3+q^-1-3*q-2*q^3+q^5+2*q^7+2*q^9-2*q^11+q^15-q^17)*A*b^2*g^6
+             - (q^-3-2*q-q^3+q^5+q^7+q^9-q^13)*C*a*b^2*g^5
+             + (q^-2-1-q^2-q^4+2*q^6+2*q^8-2*q^10)*a*b^2*g^6
+             + (q^-7-3*q^-3+2*q+2*q^5-3*q^9+q^13)*B*b^2*g^5
+             - (q^-6-q^-4-2*q^-2+2+2*q^6-2*q^8-q^10+q^12)*b^3*g^5
+
+            sage: rho(B*A)
+            q^2*B*C - (q^-1-q^3)*A + (1-q^2)*a
+            sage: rho(A*B)
+            B*C
+            sage: rho(A*B*C)
+            A*B*C + (q^-3-q)*B^2 - (q^-2-1)*B*b - (q^-3-q)*C^2 + (q^-2-1)*C*g
+            sage: rho(B*C*A)
+            A*B*C - (q^-3-q)*A^2 + (q^-2-1)*A*a + (q^-3-q)*B^2 - (q^-2-1)*B*b
+            sage: rho(C*A*B)
+            A*B*C
+
+            sage: rho(C^2*a*b^6*g^2)
+            A^2*a^2*b*g^6
+
+            sage: sigma(C^2)
+            q^4*A^2*B^2 + (q^3+q^7)*A*B*C - (q^2+q^4)*A*B*g
+             - (q^4-q^8)*A^2 + (q^5-q^7)*A*a + (1-q^4)*B^2
+             - (q-q^3)*B*b + q^4*C^2 - 2*q^3*C*g + q^2*g^2
+            sage: sigma(A*B)
+            q^2*A*B - (q^-1-q^3)*C + (1-q^2)*g
+            sage: sigma(C + 3*g*A*B)
+            3*q^2*A*B*g - q*A*B - (3*q^-1-3*q^3)*C*g
+             + (3-3*q^2)*g^2 - q^2*C + q*g
+        """
+        return self.codomain().prod(self._on_generators[i]**exp
+                                    for i, exp in enumerate(c))
+
+    def _composition_(self, right, homset):
+        """
+        Return the composition of ``self`` and ``right`` in ``homset``.
+
+        EXAMPLES::
+
+            sage: AW = algebras.AskeyWilson(QQ)
+            sage: rho = AW.rho()
+            sage: sigma = AW.sigma()
+            sage: s2 = sigma * sigma
+            sage: s2._on_generators
+            (A, B, C, a, b, g)
+            sage: sr = sigma * rho
+            sage: sr._on_generators
+            (C, B, -q*B*C - q^2*A + q*a, g, b, a)
+            sage: rs = rho * sigma
+            sage: rs._on_generators
+            (A, -q*A*B - q^2*C + q*g, B, a, g, b)
+        """
+        if isinstance(right, AlgebraMorphism):
+            cat = homset.homset_category()
+            return AlgebraMorphism(homset.domain(),
+                                   [right(g) for g in self._on_generators],
+                                   codomain=homset.codomain(), category=cat)
+        return super()._composition_(right, homset)