Yokonuma-Hecke Algebras - Algebras

Skip to content
Back to top
View this page
Edit this page

# Yokonuma-Hecke Algebras

AUTHORS:

- Travis Scrimshaw (2015-11): initial version

- Travis Scrimshaw (2025-03): general type version

class sage.algebras.yokonuma_hecke_algebra.YokonumaHeckeAlgebra(d, W, q, R, indices, category=None)

  Bases: `CombinatorialFreeModule`

  Abstract base class for Yokonuma-Hecke algebras that implements common features.

  Todo

  Factor out the near-common features.

  cartan_type()

    Return the Cartan type of `self`.

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(4, ['F',4])
        sage: Y.cartan_type()
        ['F', 4]

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(4), ['F',Integer(4)])
        >>> Y.cartan_type()
        ['F', 4]

  g(i=None)

    Return the generator(s) \(g_i\).

    INPUT:

    - `i` – (default: `None`) the generator \(g_i\) or if `None`, then the family of all generators \(g_i\)

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(8, 3)
        sage: Y.g(1)
        g[1]
        sage: list(Y.g())
        [g[1], g[2]]

        sage: Y = algebras.YokonumaHecke(8, ['G',2])
        sage: Y.g(1)
        g[1]
        sage: Y.g()
        Finite family {1: g[1], 2: g[2]}

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(8), Integer(3))
        >>> Y.g(Integer(1))
        g[1]
        >>> list(Y.g())
        [g[1], g[2]]

        >>> Y = algebras.YokonumaHecke(Integer(8), ['G',Integer(2)])
        >>> Y.g(Integer(1))
        g[1]
        >>> Y.g()
        Finite family {1: g[1], 2: g[2]}

  gens()

    Return the generators of `self`.

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(5, 3)
        sage: Y.gens()
        (g[1], g[2], t1, t2, t3)

        sage: Y = algebras.YokonumaHecke(5, ['B',2])
        sage: Y.gens()
        (g[1], g[2], h1, h2)

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(5), Integer(3))
        >>> Y.gens()
        (g[1], g[2], t1, t2, t3)

        >>> Y = algebras.YokonumaHecke(Integer(5), ['B',Integer(2)])
        >>> Y.gens()
        (g[1], g[2], h1, h2)

  index_set()

    Return the index set of `self`, which is the index set of the Cartan type of `self`.

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(4, ['F',4])
        sage: Y.index_set() == Y.cartan_type().index_set()
        True

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(4), ['F',Integer(4)])
        >>> Y.index_set() == Y.cartan_type().index_set()
        True

  q()

    Return the parameter \(q\) of `self`.

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(4, ['F',4])
        sage: Y.q()
        q
        sage: Y.q().parent() is Y.base_ring()
        True

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(4), ['F',Integer(4)])
        >>> Y.q()
        q
        >>> Y.q().parent() is Y.base_ring()
        True

class sage.algebras.yokonuma_hecke_algebra.YokonumaHeckeAlgebraGL(d, n, q, R)

  Bases: `YokonumaHeckeAlgebra`

  The Yokonuma-Hecke algebra \(Y_{d,n}(q)\) for \(GL_n(\GF{d})\).

  Let \(R\) be a commutative ring and \(q\) be a unit in \(R\). The Yokonuma-Hecke algebra \(Y_{d,n}(q)\) is the associative, unital \(R\)-algebra generated by \(t_1, t_2, \ldots, t_n, g_1, g_2, \ldots, g_{n-1}\) and subject to the relations:

  - \(g_i g_j = g_j g_i\) for all \(|i - j| > 1\),

  - \(g_i g_{i+1} g_i = g_{i+1} g_i g_{i+1}\),

  - \(t_i t_j = t_j t_i\),

  - \(t_j g_i = g_i t_{j s_i}\), and

  - \(t_j^d = 1\),

  where \(s_i\) is the simple transposition \((i, i+1)\), along with the quadratic relation

  \[g_i^2 = 1 + \frac{(q - q^{-1})}{d} \left( \sum_{s=0}^{d-1} t_i^s t_{i+1}^{-s} \right) g_i.\]

  Thus the Yokonuma-Hecke algebra can be considered a quotient of the framed braid group \((\ZZ / d\ZZ) \wr B_n\), where \(B_n\) is the classical braid group on \(n\) strands, by the quadratic relations. Moreover, all of the algebra generators are invertible. In particular, we have

  \[g_i^{-1} = g_i - (q - q^{-1}) e_i.\]

  When we specialize \(q = \pm 1\), we obtain the group algebra of the complex reflection group \(G(d, 1, n) = (\ZZ / d\ZZ) \wr S_n\). Moreover for \(d = 1\), the Yokonuma-Hecke algebra is equal to the `Iwahori-Hecke` of type \(A_{n-1}\).

  This was considered for more general Chevalley groups (Lie groups over finite fields); see `YokonumaHeckeAlgebraWeyl`.

  INPUT:

  - `d` – the maximum power of \(t\)

  - `n` – the number of generators or a Cartan type

  - `q` – (optional) an invertible element in a commutative ring; the default is \(q \in \QQ[q,q^{-1}]\)

  - `R` – (optional) a commutative ring containing `q`; the default is the parent of \(q\)

  EXAMPLES:

  We construct \(Y_{4,3}\) and do some computations:

  Sage

      sage: Y = algebras.YokonumaHecke(4, 3)
      sage: g1, g2, t1, t2, t3 = Y.algebra_generators()
      sage: g1 * g2
      g[1,2]
      sage: t1 * g1
      t1*g[1]
      sage: g2 * t2
      t3*g[2]
      sage: g2 * t3
      t2*g[2]
      sage: (g2 + t1) * (g1 + t2*t3)
      g[2,1] + t2*t3*g[2] + t1*g[1] + t1*t2*t3
      sage: g1 * g1
      1 - (1/4*q^-1-1/4*q)*g[1] - (1/4*q^-1-1/4*q)*t1*t2^3*g[1]
       - (1/4*q^-1-1/4*q)*t1^2*t2^2*g[1] - (1/4*q^-1-1/4*q)*t1^3*t2*g[1]
      sage: g2 * g1 * t1
      t3*g[2,1]

  Python

      >>> from sage.all import *
      >>> Y = algebras.YokonumaHecke(Integer(4), Integer(3))
      >>> g1, g2, t1, t2, t3 = Y.algebra_generators()
      >>> g1 * g2
      g[1,2]
      >>> t1 * g1
      t1*g[1]
      >>> g2 * t2
      t3*g[2]
      >>> g2 * t3
      t2*g[2]
      >>> (g2 + t1) * (g1 + t2*t3)
      g[2,1] + t2*t3*g[2] + t1*g[1] + t1*t2*t3
      >>> g1 * g1
      1 - (1/4*q^-1-1/4*q)*g[1] - (1/4*q^-1-1/4*q)*t1*t2^3*g[1]
       - (1/4*q^-1-1/4*q)*t1^2*t2^2*g[1] - (1/4*q^-1-1/4*q)*t1^3*t2*g[1]
      >>> g2 * g1 * t1
      t3*g[2,1]

  We construct the elements \(e_i\) and show that they are idempotents:

  Sage

      sage: e1 = Y.e(1); e1
      1/4 + 1/4*t1*t2^3 + 1/4*t1^2*t2^2 + 1/4*t1^3*t2
      sage: e1 * e1 == e1
      True
      sage: e2 = Y.e(2); e2
      1/4 + 1/4*t2*t3^3 + 1/4*t2^2*t3^2 + 1/4*t2^3*t3
      sage: e2 * e2 == e2
      True

  [Python]

      >>> from sage.all import *
      >>> e1 = Y.e(Integer(1)); e1
      1/4 + 1/4*t1*t2^3 + 1/4*t1^2*t2^2 + 1/4*t1^3*t2
      >>> e1 * e1 == e1
      True
      >>> e2 = Y.e(Integer(2)); e2
      1/4 + 1/4*t2*t3^3 + 1/4*t2^2*t3^2 + 1/4*t2^3*t3
      >>> e2 * e2 == e2
      True

  REFERENCES:

  - [CL2013]

  - [CPdA2014]

  - [ERH2015]

  - [JPdA15]

  class Element

    Bases: `IndexedFreeModuleElement`

  algebra_generators()

    Return the algebra generators of `self`.

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(5, 3)
        sage: dict(Y.algebra_generators())
        {'g1': g[1], 'g2': g[2], 't1': t1, 't2': t2, 't3': t3}

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(5), Integer(3))
        >>> dict(Y.algebra_generators())
        {'g1': g[1], 'g2': g[2], 't1': t1, 't2': t2, 't3': t3}

  e(i)

    Return the element \(e_i\).

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(4, 3)
        sage: Y.e(1)
        1/4 + 1/4*t1*t2^3 + 1/4*t1^2*t2^2 + 1/4*t1^3*t2
        sage: Y.e(2)
        1/4 + 1/4*t2*t3^3 + 1/4*t2^2*t3^2 + 1/4*t2^3*t3

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(4), Integer(3))
        >>> Y.e(Integer(1))
        1/4 + 1/4*t1*t2^3 + 1/4*t1^2*t2^2 + 1/4*t1^3*t2
        >>> Y.e(Integer(2))
        1/4 + 1/4*t2*t3^3 + 1/4*t2^2*t3^2 + 1/4*t2^3*t3

  inverse_g(i)

    Return the inverse of the generator \(g_i\).

    From the quadratic relation, we have

    \[g_i^{-1} = g_i - (q - q^{-1}) e_i.\]

    INPUT:

    - `i` – (default: `None`) the inverse generator \(g_i^{-1}\) or if `None`, then the family of all inverse generators \(g_i^{-1}\)

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(2, 4)
        sage: [2*Y.inverse_g(i) for i in range(1, 4)]
        [(q^-1-q) + 2*g[1] + (q^-1-q)*t1*t2,
         (q^-1-q) + 2*g[2] + (q^-1-q)*t2*t3,
         (q^-1-q) + 2*g[3] + (q^-1-q)*t3*t4]
        sage: all(Y.inverse_g(i) * Y.g(i) == Y.one() for i in range(1, 4))
        True
        sage: all(Y.g(i) * Y.inverse_g(i) == Y.one() for i in range(1, 4))
        True

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(2), Integer(4))
        >>> [Integer(2)*Y.inverse_g(i) for i in range(Integer(1), Integer(4))]
        [(q^-1-q) + 2*g[1] + (q^-1-q)*t1*t2,
         (q^-1-q) + 2*g[2] + (q^-1-q)*t2*t3,
         (q^-1-q) + 2*g[3] + (q^-1-q)*t3*t4]
        >>> all(Y.inverse_g(i) * Y.g(i) == Y.one() for i in range(Integer(1), Integer(4)))
        True
        >>> all(Y.g(i) * Y.inverse_g(i) == Y.one() for i in range(Integer(1), Integer(4)))
        True

  one_basis()

    Return the index of the basis element of \(1\).

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(5, 3)
        sage: Y.one_basis()
        ((0, 0, 0), [1, 2, 3])

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(5), Integer(3))
        >>> Y.one_basis()
        ((0, 0, 0), [1, 2, 3])

  product_on_basis(m1, m2)

    Return the product of the basis elements indexed by `m1` and `m2`.

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(4, 3)
        sage: m = ((1, 0, 2), Permutations(3)([2,1,3]))
        sage: 4 * Y.product_on_basis(m, m)
        -(q^-1-q)*t2^2*g[1] + 4*t1*t2 - (q^-1-q)*t1*t2*g[1]
         - (q^-1-q)*t1^2*g[1] - (q^-1-q)*t1^3*t2^3*g[1]

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(4), Integer(3))
        >>> m = ((Integer(1), Integer(0), Integer(2)), Permutations(Integer(3))([Integer(2),Integer(1),Integer(3)]))
        >>> Integer(4) * Y.product_on_basis(m, m)
        -(q^-1-q)*t2^2*g[1] + 4*t1*t2 - (q^-1-q)*t1*t2*g[1]
         - (q^-1-q)*t1^2*g[1] - (q^-1-q)*t1^3*t2^3*g[1]

    Check that we apply the permutation correctly on \(t_i\):

    Sage

        sage: Y = algebras.YokonumaHecke(4, 3)
        sage: g1, g2, t1, t2, t3 = Y.algebra_generators()
        sage: g21 = g2 * g1
        sage: g21 * t1
        t3*g[2,1]

    [Python]

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(4), Integer(3))
        >>> g1, g2, t1, t2, t3 = Y.algebra_generators()
        >>> g21 = g2 * g1
        >>> g21 * t1
        t3*g[2,1]

  t(i=None)

    Return the generator(s) \(t_i\).

    INPUT:

    - `i` – (default: `None`) the generator \(t_i\) or if `None`, then the family of all generators \(t_i\)

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(8, 3)
        sage: Y.t(2)
        t2
        sage: list(Y.t())
        [t1, t2, t3]

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(8), Integer(3))
        >>> Y.t(Integer(2))
        t2
        >>> list(Y.t())
        [t1, t2, t3]

class sage.algebras.yokonuma_hecke_algebra.YokonumaHeckeAlgebraWeyl(d, ct, q, R)

  Bases: `YokonumaHeckeAlgebra`

  The Yokonuma-Hecke algebra associated to a Cartan type.

  Let \(R\) be a commutative ring and \(q\) be a unit in \(R\). Let \(W\) be the Weyl group acting on a root lattice \(Q\). The Yokonuma-Hecke algebra \(Y_{d,W}(q)\) is the associative, unital \(R\)-algebra generated by \(\{h_i, g_i \mid i \in I\}\), where \(I\) is the index set of simple roots of \(Q\), and subject to the relations:

  - \(g_i\) and \(g_j\) satisfy the braid relations of the corresponding simple reflections \(s_i\) and \(s_j\) in \(W\),

  - \(h_i h_j = h_j h_i\),

  - \(h_j g_i = g_i (s_i \cdot h_j)\) with considering \(h_j\) as the simple root \(\alpha_j \in Q\), and

  - \(h_j^d = 1\),

  along with the quadratic relation

  \[g_i^2 = 1 + (q - 1) e_i (1 + g_i), \qquad\qquad e_i := \frac{1}{d} \sum_{s=0}^{d-1} h_i^s.\]

  In particular, we can identify the subalgebra generated by \(\{h_i \mid i \in I\}\) with \((\ZZ / d \ZZ) \otimes_{\ZZ} Q\). The Yokonuma-Hecke algebra, when \(d = p^m - 1\) for a prime \(p\) and some \(m \geq 1\), can be identified with functions invariant under the left and right actions of the unipotent group \(U\) on \(G(\GF{d})\), the semisimple Chevalley (or Lie) group associated with \(W\). Moreover, all of the algebra generators are invertible. In particular, we have

  \[g_i^{-1} = g_i + (q^{-1} - 1) e_i (1 + g_i).\]

  For \(d = 1\), the Yokonuma-Hecke algebra is equal to the `Iwahori-Hecke` of \(W\).

  INPUT:

  - `d` – the maximum power of \(t\)

  - `ct` – the Cartan type

  - `q` – (optional) an invertible element in a commutative ring; the default is \(q \in \QQ[q,q^{-1}]\)

  - `R` – (optional) a commutative ring containing `q`; the default is the parent of \(q\)

  Warning

  For type \(A_n\), this returns the Yokonuma-Hecke algebra associated to the Lie (or Chevalley) group \(SL_n(\GF{d})\). For the Yokonuma-Hecke algebra corresponding to the (reductive) Lie group \(GL_n(\GF{d})\), use `YokonumaHeckeAlgebraGL`. Additionally, this uses a different quadratic relation.

  REFERENCES:

  - [Marin2018]

  class Element

    Bases: `IndexedFreeModuleElement`

  algebra_generators()

    Return the algebra generators of `self`.

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(5, ['G',2])
        sage: dict(Y.algebra_generators())
        {'g1': g[1], 'g2': g[2], 'h1': h1, 'h2': h2}

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(5), ['G',Integer(2)])
        >>> dict(Y.algebra_generators())
        {'g1': g[1], 'g2': g[2], 'h1': h1, 'h2': h2}

  e(i=None)

    Return the element(s) \(e_i\).

    INPUT:

    - `i` – (default: `None`) the element \(e_i\) or if `None`, then the family of all idempotents \(e_i\)

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(4, ['B',3])
        sage: Y.e(1)
        1/4 + 1/4*h1 + 1/4*h1^2 + 1/4*h1^3
        sage: Y.e(2)
        1/4 + 1/4*h2 + 1/4*h2^2 + 1/4*h2^3

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(4), ['B',Integer(3)])
        >>> Y.e(Integer(1))
        1/4 + 1/4*h1 + 1/4*h1^2 + 1/4*h1^3
        >>> Y.e(Integer(2))
        1/4 + 1/4*h2 + 1/4*h2^2 + 1/4*h2^3

    We verify that they are idempotents:

    Sage

        sage: all(Y.e(i)^2 == Y.e(i) for i in Y.index_set())
        True

    [Python]

        >>> from sage.all import *
        >>> all(Y.e(i)**Integer(2) == Y.e(i) for i in Y.index_set())
        True

    Another example:

    Sage

        sage: Y = algebras.YokonumaHecke(3, ['G',2])
        sage: e = Y.e()
        sage: all(e[i]^2 == e[i] for i in Y.index_set())
        True

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(3), ['G',Integer(2)])
        >>> e = Y.e()
        >>> all(e[i]**Integer(2) == e[i] for i in Y.index_set())
        True

  h(i=None)

    Return the generator(s) \(h_i\).

    INPUT:

    - `i` – (default: `None`) the generator \(h_i\) or if `None`, then the family of all generators \(h_i\)

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(8, ['B',3])
        sage: Y.h(2)
        h2
        sage: Y.h()
        Finite family {1: h1, 2: h2, 3: h3}

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(8), ['B',Integer(3)])
        >>> Y.h(Integer(2))
        h2
        >>> Y.h()
        Finite family {1: h1, 2: h2, 3: h3}

  inverse_g(i=None)

    Return the inverse of the generator(s) \(g_i\).

    From the quadratic relation, we have

    \[g_i^{-1} = g_i + (q^{-1} - 1) e_i (1 + g_i).\]

    INPUT:

    - `i` – (default: `None`) the inverse generator \(g_i^{-1}\) or if `None`, then the family of all inverse generators \(g_i^{-1}\)

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(2, ['B',3])
        sage: [2*Y.inverse_g(i) for i in Y.index_set()]
        [(q^-1+1)*g[1] + (q^-1-1) + (q^-1-1)*h1*g[1] + (q^-1-1)*h1,
         (q^-1-1) + (q^-1+1)*g[2] + (q^-1-1)*h2 + (q^-1-1)*h2*g[2],
         (q^-1-1) + (q^-1+1)*g[3] + (q^-1-1)*h3 + (q^-1-1)*h3*g[3]]
        sage: all(Y.inverse_g(i) * Y.g(i) == Y.one() for i in range(1, 4))
        True
        sage: all(Y.g(i) * Y.inverse_g(i) == Y.one() for i in range(1, 4))
        True

        sage: Y = algebras.YokonumaHecke(3, ['G',2])
        sage: ginv = Y.inverse_g()
        sage: all(Y.g(i) * ginv[i] == Y.one() for i in Y.index_set())
        True
        sage: all(ginv[i] * Y.g(i) == Y.one() for i in Y.index_set())
        True

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(2), ['B',Integer(3)])
        >>> [Integer(2)*Y.inverse_g(i) for i in Y.index_set()]
        [(q^-1+1)*g[1] + (q^-1-1) + (q^-1-1)*h1*g[1] + (q^-1-1)*h1,
         (q^-1-1) + (q^-1+1)*g[2] + (q^-1-1)*h2 + (q^-1-1)*h2*g[2],
         (q^-1-1) + (q^-1+1)*g[3] + (q^-1-1)*h3 + (q^-1-1)*h3*g[3]]
        >>> all(Y.inverse_g(i) * Y.g(i) == Y.one() for i in range(Integer(1), Integer(4)))
        True
        >>> all(Y.g(i) * Y.inverse_g(i) == Y.one() for i in range(Integer(1), Integer(4)))
        True

        >>> Y = algebras.YokonumaHecke(Integer(3), ['G',Integer(2)])
        >>> ginv = Y.inverse_g()
        >>> all(Y.g(i) * ginv[i] == Y.one() for i in Y.index_set())
        True
        >>> all(ginv[i] * Y.g(i) == Y.one() for i in Y.index_set())
        True

  one_basis()

    Return the index of the basis element of \(1\).

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(5, ['D',6])
        sage: Y.one_basis()
        (0, 1)

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(5), ['D',Integer(6)])
        >>> Y.one_basis()
        (0, 1)

  product_on_basis(m1, m2)

    Return the product of the basis elements indexed by `m1` and `m2`.

    EXAMPLES:

    Sage

        sage: Y = algebras.YokonumaHecke(4, ['C',3])
        sage: al = Y._Q.simple_root(1) + 2*Y._Q.simple_root(3)
        sage: w = Y._W.from_reduced_word([3,2,1,2]); w.length()
        4
        sage: Y.product_on_basis((Y._Q.zero(), w), (al, Y._W.one()))
        h2^3*h3*g[3,1,2,1]
        sage: Y.product_on_basis((al, w), (al, Y._W.one()))
        h1*h2^3*h3^3*g[3,1,2,1]
        sage: Y.product_on_basis((al, Y._W.one()), (al, w))
        h1^2*g[3,1,2,1]
        sage: 4 * Y.product_on_basis((al, w), (al, w))
        -(1-q)*h1*g[3,1,2,3,2,1] - (1-q)*h1*g[3,1,2,3,1,2,1]
         - (1-q)*h1*h2*h3*g[3,1,2,3,2,1] - (1-q)*h1*h2*h3*g[3,1,2,3,1,2,1]
         - (1-q)*h1*h2^2*h3^2*g[3,1,2,3,2,1] - (1-q)*h1*h2^2*h3^2*g[3,1,2,3,1,2,1]
         + (3+q)*h1*h2^3*h3^3*g[3,1,2,3,2,1] - (1-q)*h1*h2^3*h3^3*g[3,1,2,3,1,2,1]

    Python

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(4), ['C',Integer(3)])
        >>> al = Y._Q.simple_root(Integer(1)) + Integer(2)*Y._Q.simple_root(Integer(3))
        >>> w = Y._W.from_reduced_word([Integer(3),Integer(2),Integer(1),Integer(2)]); w.length()
        4
        >>> Y.product_on_basis((Y._Q.zero(), w), (al, Y._W.one()))
        h2^3*h3*g[3,1,2,1]
        >>> Y.product_on_basis((al, w), (al, Y._W.one()))
        h1*h2^3*h3^3*g[3,1,2,1]
        >>> Y.product_on_basis((al, Y._W.one()), (al, w))
        h1^2*g[3,1,2,1]
        >>> Integer(4) * Y.product_on_basis((al, w), (al, w))
        -(1-q)*h1*g[3,1,2,3,2,1] - (1-q)*h1*g[3,1,2,3,1,2,1]
         - (1-q)*h1*h2*h3*g[3,1,2,3,2,1] - (1-q)*h1*h2*h3*g[3,1,2,3,1,2,1]
         - (1-q)*h1*h2^2*h3^2*g[3,1,2,3,2,1] - (1-q)*h1*h2^2*h3^2*g[3,1,2,3,1,2,1]
         + (3+q)*h1*h2^3*h3^3*g[3,1,2,3,2,1] - (1-q)*h1*h2^3*h3^3*g[3,1,2,3,1,2,1]

    Check that we apply the permutation correctly on \(h_i\):

    Sage

        sage: Y = algebras.YokonumaHecke(4, ['B',3])
        sage: g1, g2, g3, h1, h2, h3 = Y.algebra_generators()
        sage: (g2 * g1) * h1
        h1^3*h2^3*g[2,1]
        sage: g2 * (g1 * h1)
        h1^3*h2^3*g[2,1]

    [Python]

        >>> from sage.all import *
        >>> Y = algebras.YokonumaHecke(Integer(4), ['B',Integer(3)])
        >>> g1, g2, g3, h1, h2, h3 = Y.algebra_generators()
        >>> (g2 * g1) * h1
        h1^3*h2^3*g[2,1]
        >>> g2 * (g1 * h1)
        h1^3*h2^3*g[2,1]