Ariki-Koike Algebras

The Ariki-Koike algebras were introduced by Ariki and Koike [AK1994] as a natural generalization of the Iwahori-Hecke algebras of types \(A\) and \(B\) (see IwahoriHeckeAlgebra). Soon afterwards, Broué and Malle defined analogues of the Hecke algebras for all complex reflection groups

Fix nonnegative integers \(r\) an \(n\). The Ariki-Koike algebras are deformations of the group algebra of the complex reflection group \(G(r, 1, n) = \ZZ / r\ZZ \wr \mathfrak{S}_n\). If \(R\) is a ring containing a Hecke parameter \(q\) and cyclotomic parameters \(u_0, \ldots, u_{r-1}\) then the Ariki-Koike algebra \(H_n(q, u_1, \ldots, u_r)\) is the unital associative \(r\)-algebra with generators \(T_0, T_1, \ldots, T_{n-1}\) an relations:

\[\begin{split}\begin{aligned} \prod_{i=0}^{r-1} (T_0 - u_i) & = 0, \\ T_i^2 & = (q - 1) T_i + q && \text{for } 1 \leq i < n, \\ T_0 T_1 T_0 T_1 & = T_1 T_0 T_1 T_0, \\ T_i T_j & = T_j T_i && \text{if } |i - j| \geq 2, \\ T_i T_{i+1} T_i & = T_{i+1} T_i T_{i+1} && \text{for } 1 \leq i < n. \end{aligned}\end{split}\]

AUTHORS:

  • Travis Scrimshaw (2016-04): initial version

  • Andrew Mathas (2016-07): improved multiplication code

REFERENCES:

class sage.algebras.hecke_algebras.ariki_koike_algebra.ArikiKoikeAlgebra(r, n, q, u, R)[source]

Bases: Parent, UniqueRepresentation

The Ariki-Koike algebra \(H_{r,n}(q, u)\).

Let \(R\) be an unital integral domain. Let \(q, u_0, \ldots, u_{r-1} \in R\) such that \(q^{-1} \in R\). The Ariki-Koike algebra is the unital associative algebra \(H_{r,n}(q, u)\) generated by \(T_0, \ldots, T_{n-1}\) that satisfies the following relations:

\[\begin{split}\begin{aligned} \prod_{i=0}^{r-1} (T_0 - u_i) & = 0, \\ T_i^2 & = (q - 1) T_i + q && \text{for } 1 \leq i < n, \\ T_0 T_1 T_0 T_1 & = T_1 T_0 T_1 T_0, \\ T_i T_j & = T_j T_i && \text{if } |i - j| \geq 2, \\ T_i T_{i+1} T_i & = T_{i+1} T_i T_{i+1} && \text{for } 1 \leq i < n. \end{aligned}\end{split}\]

The parameter \(q\) is called the Hecke parameter and the parameters \(u_0, \ldots, u_{r-1}\) are called the cyclotomic parameters. Thus, the Ariki-Koike algebra is a deformation of the group algebra of the complex reflection group \(G(r, 1, n) = \ZZ / r\ZZ \wr \mathfrak{S}_n\).

Next, we define Jucys-Murphy elements

\[L_i = q^{-i+1} T_{i-1} \cdots T_1 T_0 T_1 \cdots T_{i-1}\]

for \(1 \leq i \leq n\).

Note

These element differ by a power of \(q\) from the corresponding elements in [AK1994]. However, these elements are more commonly used because they lead to nicer representation theoretic formulas.

Ariki and Koike [AK1994] showed that \(H_{r,n}(q, u)\) is a free \(R\)-module with a basis given by

\[\{ L_1^{c_i} \cdots L_n^{c_n} T_w \mid w \in S_n, 0 \leq c_i < r \}.\]

In particular, we have \(\dim H_{r,n}(q,u) = r^n n! = |G(r, 1, n)|\). Moreover, we have \(L_i L_j = L_i L_j\) for all \(1 \leq i, j \leq n\).

The Ariki-Koike algebra \(H_{r,n}(q, u)\) can be considered as a quotient of the group algebra of the braid group for \(G(r, 1, n)\) by the ideal generated by \(\prod_{i=0}^{r-1} (T_0 - u_i)\) and \((T_i - q)(T_i + 1)\). Furthermore, \(H_{r,n}(q, u)\) can be constructed as a quotient of the extended affine Hecke algebra of type \(A_{n-1}^{(1)}\) by \(\prod_{i=0}^{r-1} (X_1 - u_i)\).

Since the Ariki-Koike algebra is a quotient of the group algebra of the braid group of \(G(r, 1, n)\), we can recover the group algebra of \(G(r, 1, n)\) as follows. Consider \(u = (1, \zeta_r, \ldots, \zeta_r^{r-1})\), where \(\zeta_r\) is a primitive \(r\)-th root of unity, then we have

\[R G(r, 1, n) = H_{r,n}(1, u).\]

INPUT:

  • r – the maximum power of \(L_i\)

  • n – the rank \(S_n\)

  • q – (optional) an invertible element in a commutative ring; the default is \(q \in R[q,q^{-1}]\), where \(R\) is the ring containing the variables u

  • u – (optional) the variables \(u_1, \ldots, u_r\); the default is the generators of \(\ZZ[u_1, \ldots, u_r]\)

  • R – (optional) a commutative ring containing q and u; the default is the parent of \(q\) and \(u_1, \ldots, u_r\)

  • use_fraction_field – (default: False) whether to use the fraction field or not

EXAMPLES:

We start by constructing an Ariki-Koike algebra where the values \(q, u\) are generic and do some computations:

sage: H = algebras.ArikiKoike(3, 4)

>>> from sage.all import *
>>> H = algebras.ArikiKoike(Integer(3), Integer(4))

H = algebras.ArikiKoike(3, 4)

Next, we do some computations using the \(LT\) basis:

sage: LT = H.LT()
sage: LT.inject_variables()
Defining L1, L2, L3, L4, T1, T2, T3
sage: T1 * T2 * T1 * T2
q*T[2,1] - (1-q)*T[2,1,2]
sage: T1 * L1 * T2 * L3 * T1 * T2
-(q-q^2)*L2*L3*T[2] + q*L1*L2*T[2,1] - (1-q)*L1*L2*T[2,1,2]
sage: L1^3
u0*u1*u2 + ((-u0*u1-u0*u2-u1*u2))*L1 + ((u0+u1+u2))*L1^2
sage: L3 * L2 * L1
L1*L2*L3
sage: u = LT.u()
sage: q = LT.q()
sage: (q + 2*u[0]) * (T1 * T2) * L3
(-2*u0+(2*u0-1)*q+q^2)*L3*T[1] + (-2*u0+(2*u0-1)*q+q^2)*L2*T[2]
 + (2*u0+q)*L1*T[1,2]

>>> from sage.all import *
>>> LT = H.LT()
>>> LT.inject_variables()
Defining L1, L2, L3, L4, T1, T2, T3
>>> T1 * T2 * T1 * T2
q*T[2,1] - (1-q)*T[2,1,2]
>>> T1 * L1 * T2 * L3 * T1 * T2
-(q-q^2)*L2*L3*T[2] + q*L1*L2*T[2,1] - (1-q)*L1*L2*T[2,1,2]
>>> L1**Integer(3)
u0*u1*u2 + ((-u0*u1-u0*u2-u1*u2))*L1 + ((u0+u1+u2))*L1^2
>>> L3 * L2 * L1
L1*L2*L3
>>> u = LT.u()
>>> q = LT.q()
>>> (q + Integer(2)*u[Integer(0)]) * (T1 * T2) * L3
(-2*u0+(2*u0-1)*q+q^2)*L3*T[1] + (-2*u0+(2*u0-1)*q+q^2)*L2*T[2]
 + (2*u0+q)*L1*T[1,2]

LT = H.LT()
LT.inject_variables()
T1 * T2 * T1 * T2
T1 * L1 * T2 * L3 * T1 * T2
L1^3
L3 * L2 * L1
u = LT.u()
q = LT.q()
(q + 2*u[0]) * (T1 * T2) * L3

We check the defining relations:

sage: prod(L1 - val for val in u) == H.zero()
True
sage: L1 * T1 * L1 * T1 == T1 * L1 * T1 * L1
True
sage: T1 * T2 * T1 == T2 * T1 * T2
True
sage: T2 * T3 * T2 == T3 * T2 * T3
True
sage: L2 == q^-1 * T1 * L1 * T1
True
sage: L3 == q^-2 * T2 * T1 * L1 * T1 * T2
True

>>> from sage.all import *
>>> prod(L1 - val for val in u) == H.zero()
True
>>> L1 * T1 * L1 * T1 == T1 * L1 * T1 * L1
True
>>> T1 * T2 * T1 == T2 * T1 * T2
True
>>> T2 * T3 * T2 == T3 * T2 * T3
True
>>> L2 == q**-Integer(1) * T1 * L1 * T1
True
>>> L3 == q**-Integer(2) * T2 * T1 * L1 * T1 * T2
True

prod(L1 - val for val in u) == H.zero()
L1 * T1 * L1 * T1 == T1 * L1 * T1 * L1
T1 * T2 * T1 == T2 * T1 * T2
T2 * T3 * T2 == T3 * T2 * T3
L2 == q^-1 * T1 * L1 * T1
L3 == q^-2 * T2 * T1 * L1 * T1 * T2

We construct an Ariki-Koike algebra with \(u = (1, \zeta_3, \zeta_3^2)\), where \(\zeta_3\) is a primitive third root of unity:

sage: # needs sage.rings.number_field
sage: F = CyclotomicField(3)
sage: zeta3 = F.gen()
sage: R.<q> = LaurentPolynomialRing(F)
sage: H = algebras.ArikiKoike(3, 4, q=q, u=[1, zeta3, zeta3^2], R=R)
sage: H.LT().inject_variables()
Defining L1, L2, L3, L4, T1, T2, T3
sage: L1^3
1
sage: L2^3
1 - (q^-1-1)*T[1] - (q^-1-1)*L1*L2^2*T[1] - (q^-1-1)*L1^2*L2*T[1]

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> F = CyclotomicField(Integer(3))
>>> zeta3 = F.gen()
>>> R = LaurentPolynomialRing(F, names=('q',)); (q,) = R._first_ngens(1)
>>> H = algebras.ArikiKoike(Integer(3), Integer(4), q=q, u=[Integer(1), zeta3, zeta3**Integer(2)], R=R)
>>> H.LT().inject_variables()
Defining L1, L2, L3, L4, T1, T2, T3
>>> L1**Integer(3)
1
>>> L2**Integer(3)
1 - (q^-1-1)*T[1] - (q^-1-1)*L1*L2^2*T[1] - (q^-1-1)*L1^2*L2*T[1]

# needs sage.rings.number_field
F = CyclotomicField(3)
zeta3 = F.gen()
R.<q> = LaurentPolynomialRing(F)
H = algebras.ArikiKoike(3, 4, q=q, u=[1, zeta3, zeta3^2], R=R)
H.LT().inject_variables()
L1^3
L2^3

Next, we additionally take \(q = 1\) to obtain the group algebra of \(G(r, 1, n)\):

sage: # needs sage.rings.number_field
sage: F = CyclotomicField(3)
sage: zeta3 = F.gen()
sage: H = algebras.ArikiKoike(3, 4, q=1, u=[1, zeta3, zeta3^2], R=F)
sage: LT = H.LT()
sage: LT.inject_variables()
Defining L1, L2, L3, L4, T1, T2, T3
sage: A = ColoredPermutations(3, 4).algebra(F)
sage: s1, s2, s3, s0 = list(A.algebra_generators())
sage: all(L^3 == LT.one() for L in LT.L())
True
sage: J = [s0, s3*s0*s3, s2*s3*s0*s3*s2, s1*s2*s3*s0*s3*s2*s1]
sage: all(Ji^3 == A.one() for Ji in J)
True

>>> from sage.all import *
>>> # needs sage.rings.number_field
>>> F = CyclotomicField(Integer(3))
>>> zeta3 = F.gen()
>>> H = algebras.ArikiKoike(Integer(3), Integer(4), q=Integer(1), u=[Integer(1), zeta3, zeta3**Integer(2)], R=F)
>>> LT = H.LT()
>>> LT.inject_variables()
Defining L1, L2, L3, L4, T1, T2, T3
>>> A = ColoredPermutations(Integer(3), Integer(4)).algebra(F)
>>> s1, s2, s3, s0 = list(A.algebra_generators())
>>> all(L**Integer(3) == LT.one() for L in LT.L())
True
>>> J = [s0, s3*s0*s3, s2*s3*s0*s3*s2, s1*s2*s3*s0*s3*s2*s1]
>>> all(Ji**Integer(3) == A.one() for Ji in J)
True

# needs sage.rings.number_field
F = CyclotomicField(3)
zeta3 = F.gen()
H = algebras.ArikiKoike(3, 4, q=1, u=[1, zeta3, zeta3^2], R=F)
LT = H.LT()
LT.inject_variables()
A = ColoredPermutations(3, 4).algebra(F)
s1, s2, s3, s0 = list(A.algebra_generators())
all(L^3 == LT.one() for L in LT.L())
J = [s0, s3*s0*s3, s2*s3*s0*s3*s2, s1*s2*s3*s0*s3*s2*s1]
all(Ji^3 == A.one() for Ji in J)
class LT(algebra)[source]

Bases: _Basis

The basis of the Ariki-Koike algebra given by monomials of the form \(L T\), where \(L\) is product of Jucys-Murphy elements and \(T\) is a product of \(\{ T_i | 0 < i < n \}\).

This was the basis defined in [AK1994] except using the renormalized Jucys-Murphy elements.

class Element[source]

Bases: IndexedFreeModuleElement

L(i=None)[source]

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

INPUT:

  • i – (default: None) the generator \(L_i\) or if None, then the list of all generators \(L_i\)

EXAMPLES:

sage: LT = algebras.ArikiKoike(8, 3).LT()
sage: LT.L(2)
L2
sage: LT.L()
[L1, L2, L3]

sage: LT = algebras.ArikiKoike(1, 3).LT()
sage: LT.L(2)
u + (-u*q^-1+u)*T[1]
sage: LT.L()
[u,
 u + (-u*q^-1+u)*T[1],
 u + (-u*q^-1+u)*T[2] + (-u*q^-2+u*q^-1)*T[2,1,2]]

>>> from sage.all import *
>>> LT = algebras.ArikiKoike(Integer(8), Integer(3)).LT()
>>> LT.L(Integer(2))
L2
>>> LT.L()
[L1, L2, L3]

>>> LT = algebras.ArikiKoike(Integer(1), Integer(3)).LT()
>>> LT.L(Integer(2))
u + (-u*q^-1+u)*T[1]
>>> LT.L()
[u,
 u + (-u*q^-1+u)*T[1],
 u + (-u*q^-1+u)*T[2] + (-u*q^-2+u*q^-1)*T[2,1,2]]

LT = algebras.ArikiKoike(8, 3).LT()
LT.L(2)
LT.L()
LT = algebras.ArikiKoike(1, 3).LT()
LT.L(2)
LT.L()
T(i=None)[source]

Return the generator(s) \(T_i\) of self.

INPUT:

  • i – (default: None) the generator \(T_i\) or if None, then the list of all generators \(T_i\)

EXAMPLES:

sage: LT = algebras.ArikiKoike(8, 3).LT()
sage: LT.T(1)
T[1]
sage: LT.T()
[L1, T[1], T[2]]
sage: LT.T(0)
L1

>>> from sage.all import *
>>> LT = algebras.ArikiKoike(Integer(8), Integer(3)).LT()
>>> LT.T(Integer(1))
T[1]
>>> LT.T()
[L1, T[1], T[2]]
>>> LT.T(Integer(0))
L1

LT = algebras.ArikiKoike(8, 3).LT()
LT.T(1)
LT.T()
LT.T(0)
algebra_generators()[source]

Return the algebra generators of self.

EXAMPLES:

sage: LT = algebras.ArikiKoike(5, 3).LT()
sage: dict(LT.algebra_generators())
{'L1': L1, 'L2': L2, 'L3': L3, 'T1': T[1], 'T2': T[2]}

sage: LT = algebras.ArikiKoike(1, 4).LT()
sage: dict(LT.algebra_generators())
{'T1': T[1], 'T2': T[2], 'T3': T[3]}

>>> from sage.all import *
>>> LT = algebras.ArikiKoike(Integer(5), Integer(3)).LT()
>>> dict(LT.algebra_generators())
{'L1': L1, 'L2': L2, 'L3': L3, 'T1': T[1], 'T2': T[2]}

>>> LT = algebras.ArikiKoike(Integer(1), Integer(4)).LT()
>>> dict(LT.algebra_generators())
{'T1': T[1], 'T2': T[2], 'T3': T[3]}

LT = algebras.ArikiKoike(5, 3).LT()
dict(LT.algebra_generators())
LT = algebras.ArikiKoike(1, 4).LT()
dict(LT.algebra_generators())
inverse_T(i)[source]

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

From the quadratic relation, we have

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

EXAMPLES:

sage: LT = algebras.ArikiKoike(3, 4).LT()
sage: [LT.inverse_T(i) for i in range(1, 4)]
[(q^-1-1) + (q^-1)*T[1],
 (q^-1-1) + (q^-1)*T[2],
 (q^-1-1) + (q^-1)*T[3]]

>>> from sage.all import *
>>> LT = algebras.ArikiKoike(Integer(3), Integer(4)).LT()
>>> [LT.inverse_T(i) for i in range(Integer(1), Integer(4))]
[(q^-1-1) + (q^-1)*T[1],
 (q^-1-1) + (q^-1)*T[2],
 (q^-1-1) + (q^-1)*T[3]]

LT = algebras.ArikiKoike(3, 4).LT()
[LT.inverse_T(i) for i in range(1, 4)]
product_on_basis(m1, m2)[source]

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

EXAMPLES:

sage: LT = algebras.ArikiKoike(6, 3).LT()
sage: m = ((1, 0, 2), Permutations(3)([2,1,3]))
sage: LT.product_on_basis(m, m)
q*L1*L2*L3^4

sage: LT = algebras.ArikiKoike(4, 3).LT()
sage: L1,L2,L3,T1,T2 = LT.algebra_generators()
sage: L1 * T1 * L1^2 * T1
q*L1*L2^2 + (1-q)*L1^2*L2*T[1]
sage: L1^2 * T1 * L1^2 * T1
q*L1^2*L2^2 + (1-q)*L1^3*L2*T[1]
sage: L1^3 * T1 * L1^2 * T1
(-u0*u1*u2*u3+u0*u1*u2*u3*q)*L2*T[1]
 + ((u0*u1*u2+u0*u1*u3+u0*u2*u3+u1*u2*u3)+(-u0*u1*u2-u0*u1*u3-u0*u2*u3-u1*u2*u3)*q)*L1*L2*T[1]
 + ((-u0*u1-u0*u2-u1*u2-u0*u3-u1*u3-u2*u3)+(u0*u1+u0*u2+u1*u2+u0*u3+u1*u3+u2*u3)*q)*L1^2*L2*T[1]
 + ((u0+u1+u2+u3)+(-u0-u1-u2-u3)*q)*L1^3*L2*T[1] + q*L1^3*L2^2

sage: L1^2 * T1 * L1^3 * T1
(-u0*u1*u2*u3+u0*u1*u2*u3*q)*L2*T[1]
 + ((u0*u1*u2+u0*u1*u3+u0*u2*u3+u1*u2*u3)+(-u0*u1*u2-u0*u1*u3-u0*u2*u3-u1*u2*u3)*q)*L1*L2*T[1]
 + ((-u0*u1-u0*u2-u1*u2-u0*u3-u1*u3-u2*u3)+(u0*u1+u0*u2+u1*u2+u0*u3+u1*u3+u2*u3)*q)*L1^2*L2*T[1]
 + q*L1^2*L2^3
 + ((u0+u1+u2+u3)+(-u0-u1-u2-u3)*q)*L1^3*L2*T[1]
 + (1-q)*L1^3*L2^2*T[1]

sage: L1^2 * T1*T2*T1 * L2 * L3 * T2
(q-2*q^2+q^3)*L1^2*L2*L3 - (1-2*q+2*q^2-q^3)*L1^2*L2*L3*T[2]
 - (q-q^2)*L1^3*L3*T[1] + (1-2*q+q^2)*L1^3*L3*T[1,2]
 + q*L1^3*L2*T[2,1] - (1-q)*L1^3*L2*T[2,1,2]

sage: LT = algebras.ArikiKoike(2, 3).LT()
sage: L3 = LT.L(3)
sage: x = LT.an_element()
sage: (x * L3) * L3 == x * (L3 * L3)
True

>>> from sage.all import *
>>> LT = algebras.ArikiKoike(Integer(6), Integer(3)).LT()
>>> m = ((Integer(1), Integer(0), Integer(2)), Permutations(Integer(3))([Integer(2),Integer(1),Integer(3)]))
>>> LT.product_on_basis(m, m)
q*L1*L2*L3^4

>>> LT = algebras.ArikiKoike(Integer(4), Integer(3)).LT()
>>> L1,L2,L3,T1,T2 = LT.algebra_generators()
>>> L1 * T1 * L1**Integer(2) * T1
q*L1*L2^2 + (1-q)*L1^2*L2*T[1]
>>> L1**Integer(2) * T1 * L1**Integer(2) * T1
q*L1^2*L2^2 + (1-q)*L1^3*L2*T[1]
>>> L1**Integer(3) * T1 * L1**Integer(2) * T1
(-u0*u1*u2*u3+u0*u1*u2*u3*q)*L2*T[1]
 + ((u0*u1*u2+u0*u1*u3+u0*u2*u3+u1*u2*u3)+(-u0*u1*u2-u0*u1*u3-u0*u2*u3-u1*u2*u3)*q)*L1*L2*T[1]
 + ((-u0*u1-u0*u2-u1*u2-u0*u3-u1*u3-u2*u3)+(u0*u1+u0*u2+u1*u2+u0*u3+u1*u3+u2*u3)*q)*L1^2*L2*T[1]
 + ((u0+u1+u2+u3)+(-u0-u1-u2-u3)*q)*L1^3*L2*T[1] + q*L1^3*L2^2

>>> L1**Integer(2) * T1 * L1**Integer(3) * T1
(-u0*u1*u2*u3+u0*u1*u2*u3*q)*L2*T[1]
 + ((u0*u1*u2+u0*u1*u3+u0*u2*u3+u1*u2*u3)+(-u0*u1*u2-u0*u1*u3-u0*u2*u3-u1*u2*u3)*q)*L1*L2*T[1]
 + ((-u0*u1-u0*u2-u1*u2-u0*u3-u1*u3-u2*u3)+(u0*u1+u0*u2+u1*u2+u0*u3+u1*u3+u2*u3)*q)*L1^2*L2*T[1]
 + q*L1^2*L2^3
 + ((u0+u1+u2+u3)+(-u0-u1-u2-u3)*q)*L1^3*L2*T[1]
 + (1-q)*L1^3*L2^2*T[1]

>>> L1**Integer(2) * T1*T2*T1 * L2 * L3 * T2
(q-2*q^2+q^3)*L1^2*L2*L3 - (1-2*q+2*q^2-q^3)*L1^2*L2*L3*T[2]
 - (q-q^2)*L1^3*L3*T[1] + (1-2*q+q^2)*L1^3*L3*T[1,2]
 + q*L1^3*L2*T[2,1] - (1-q)*L1^3*L2*T[2,1,2]

>>> LT = algebras.ArikiKoike(Integer(2), Integer(3)).LT()
>>> L3 = LT.L(Integer(3))
>>> x = LT.an_element()
>>> (x * L3) * L3 == x * (L3 * L3)
True

LT = algebras.ArikiKoike(6, 3).LT()
m = ((1, 0, 2), Permutations(3)([2,1,3]))
LT.product_on_basis(m, m)
LT = algebras.ArikiKoike(4, 3).LT()
L1,L2,L3,T1,T2 = LT.algebra_generators()
L1 * T1 * L1^2 * T1
L1^2 * T1 * L1^2 * T1
L1^3 * T1 * L1^2 * T1
L1^2 * T1 * L1^3 * T1
L1^2 * T1*T2*T1 * L2 * L3 * T2
LT = algebras.ArikiKoike(2, 3).LT()
L3 = LT.L(3)
x = LT.an_element()
(x * L3) * L3 == x * (L3 * L3)
class T(algebra)[source]

Bases: _Basis

The basis of the Ariki-Koike algebra given by monomials of the generators \(\{ T_i | 0 \leq i < n \}\).

We use the choice of reduced expression given by [BM1997]:

\[T_{1,a_1} \cdots T_{n,a_n} T_w,\]

where \(T_{i,k} = T_{i-1} \cdots T_2 T_1 T_0^k\) (note that \(T_{1,k} = T_0^k\)) and \(w\) is a reduced expression of an element in \(\mathfrak{S}_n\).

L(i=None)[source]

Return the Jucys-Murphy element(s) \(L_i\).

The Jucys-Murphy element \(L_i\) is defined as

\[L_i = q^{-i+1} T_{i-1} \cdots T_1 T_0 T_1 \cdots T_{i-1} = q^{-1} T_{i-1} L_{i-1} T_{i-1}.\]

INPUT:

  • i – (default: None) the Jucys-Murphy element \(L_i\) or if None, then the list of all \(L_i\)

EXAMPLES:

sage: T = algebras.ArikiKoike(8, 3).T()
sage: T.L(2)
(q^-1)*T[1,0,1]
sage: T.L()
[T[0], (q^-1)*T[1,0,1], (q^-2)*T[2,1,0,1,2]]

sage: T0,T1,T2 = T.T()
sage: q = T.q()
sage: T.L(1) == T0
True
sage: T.L(2) == q^-1 * T1*T0*T1
True
sage: T.L(3) == q^-2 * T2*T1*T0*T1*T2
True

sage: T = algebras.ArikiKoike(1, 3).T()
sage: T.L(2)
u + (-u*q^-1+u)*T[1]
sage: T.L()
[u,
 u + (-u*q^-1+u)*T[1],
 u + (-u*q^-1+u)*T[2] + (-u*q^-2+u*q^-1)*T[2,1,2]]

>>> from sage.all import *
>>> T = algebras.ArikiKoike(Integer(8), Integer(3)).T()
>>> T.L(Integer(2))
(q^-1)*T[1,0,1]
>>> T.L()
[T[0], (q^-1)*T[1,0,1], (q^-2)*T[2,1,0,1,2]]

>>> T0,T1,T2 = T.T()
>>> q = T.q()
>>> T.L(Integer(1)) == T0
True
>>> T.L(Integer(2)) == q**-Integer(1) * T1*T0*T1
True
>>> T.L(Integer(3)) == q**-Integer(2) * T2*T1*T0*T1*T2
True

>>> T = algebras.ArikiKoike(Integer(1), Integer(3)).T()
>>> T.L(Integer(2))
u + (-u*q^-1+u)*T[1]
>>> T.L()
[u,
 u + (-u*q^-1+u)*T[1],
 u + (-u*q^-1+u)*T[2] + (-u*q^-2+u*q^-1)*T[2,1,2]]

T = algebras.ArikiKoike(8, 3).T()
T.L(2)
T.L()
T0,T1,T2 = T.T()
q = T.q()
T.L(1) == T0
T.L(2) == q^-1 * T1*T0*T1
T.L(3) == q^-2 * T2*T1*T0*T1*T2
T = algebras.ArikiKoike(1, 3).T()
T.L(2)
T.L()
T(i=None)[source]

Return the generator(s) \(T_i\) of self.

INPUT:

  • i – (default: None) the generator \(T_i\) or if None, then the list of all generators \(T_i\)

EXAMPLES:

sage: T = algebras.ArikiKoike(8, 3).T()
sage: T.T(1)
T[1]
sage: T.T()
[T[0], T[1], T[2]]

sage: T = algebras.ArikiKoike(1, 4).T()

>>> from sage.all import *
>>> T = algebras.ArikiKoike(Integer(8), Integer(3)).T()
>>> T.T(Integer(1))
T[1]
>>> T.T()
[T[0], T[1], T[2]]

>>> T = algebras.ArikiKoike(Integer(1), Integer(4)).T()

T = algebras.ArikiKoike(8, 3).T()
T.T(1)
T.T()
T = algebras.ArikiKoike(1, 4).T()
algebra_generators()[source]

Return the algebra generators of self.

EXAMPLES:

sage: T = algebras.ArikiKoike(5, 3).T()
sage: dict(T.algebra_generators())
{0: T[0], 1: T[1], 2: T[2]}

sage: T = algebras.ArikiKoike(1, 4).T()
sage: dict(T.algebra_generators())
{1: T[1], 2: T[2], 3: T[3]}

>>> from sage.all import *
>>> T = algebras.ArikiKoike(Integer(5), Integer(3)).T()
>>> dict(T.algebra_generators())
{0: T[0], 1: T[1], 2: T[2]}

>>> T = algebras.ArikiKoike(Integer(1), Integer(4)).T()
>>> dict(T.algebra_generators())
{1: T[1], 2: T[2], 3: T[3]}

T = algebras.ArikiKoike(5, 3).T()
dict(T.algebra_generators())
T = algebras.ArikiKoike(1, 4).T()
dict(T.algebra_generators())
product_on_basis(m1, m2)[source]

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

EXAMPLES:

sage: T = algebras.ArikiKoike(2, 3).T()
sage: T0, T1, T2 = T.T()
sage: T.product_on_basis(T0.leading_support(), T1.leading_support())
T[0,1]
sage: T1 * T2
T[1,2]
sage: T2 * T1
T[2,1]
sage: T2 * (T2 * T1 * T0)
-(1-q)*T[2,1,0] + q*T[1,0]
sage: (T1 * T0 * T1 * T0) * T0
(-u0*u1)*T[1,0,1] + ((u0+u1))*T[0,1,0,1]
sage: (T0 * T1 * T0 * T1) * (T0 * T1)
(-u0*u1*q)*T[1,0] + (u0*u1-u0*u1*q)*T[1,0,1]
 + ((u0+u1)*q)*T[0,1,0] + ((-u0-u1)+(u0+u1)*q)*T[0,1,0,1]
sage: T1 * (T0 * T2 * T1 * T0)
T[1,0,2,1,0]
sage: (T1 * T2) * (T2 * T1 * T0)
-(1-q)*T[2,1,0,2] - (q-q^2)*T[1,0] + q^2*T[0]
sage: (T2*T1*T2) * (T2*T1*T0*T1*T2)
-(q-q^2)*T[2,1,0,1,2] + (1-2*q+q^2)*T[2,1,0,2,1,2]
 - (q-q^2)*T[1,0,2,1,2] + q^2*T[0,2,1,2]

>>> from sage.all import *
>>> T = algebras.ArikiKoike(Integer(2), Integer(3)).T()
>>> T0, T1, T2 = T.T()
>>> T.product_on_basis(T0.leading_support(), T1.leading_support())
T[0,1]
>>> T1 * T2
T[1,2]
>>> T2 * T1
T[2,1]
>>> T2 * (T2 * T1 * T0)
-(1-q)*T[2,1,0] + q*T[1,0]
>>> (T1 * T0 * T1 * T0) * T0
(-u0*u1)*T[1,0,1] + ((u0+u1))*T[0,1,0,1]
>>> (T0 * T1 * T0 * T1) * (T0 * T1)
(-u0*u1*q)*T[1,0] + (u0*u1-u0*u1*q)*T[1,0,1]
 + ((u0+u1)*q)*T[0,1,0] + ((-u0-u1)+(u0+u1)*q)*T[0,1,0,1]
>>> T1 * (T0 * T2 * T1 * T0)
T[1,0,2,1,0]
>>> (T1 * T2) * (T2 * T1 * T0)
-(1-q)*T[2,1,0,2] - (q-q^2)*T[1,0] + q^2*T[0]
>>> (T2*T1*T2) * (T2*T1*T0*T1*T2)
-(q-q^2)*T[2,1,0,1,2] + (1-2*q+q^2)*T[2,1,0,2,1,2]
 - (q-q^2)*T[1,0,2,1,2] + q^2*T[0,2,1,2]

T = algebras.ArikiKoike(2, 3).T()
T0, T1, T2 = T.T()
T.product_on_basis(T0.leading_support(), T1.leading_support())
T1 * T2
T2 * T1
T2 * (T2 * T1 * T0)
(T1 * T0 * T1 * T0) * T0
(T0 * T1 * T0 * T1) * (T0 * T1)
T1 * (T0 * T2 * T1 * T0)
(T1 * T2) * (T2 * T1 * T0)
(T2*T1*T2) * (T2*T1*T0*T1*T2)

We check some relations:

sage: T0 * T1 * T0 * T1 == T1 * T0 * T1 * T0
True
sage: T1 * T2 * T1 == T2 * T1 * T2
True
sage: (T1 * T0) * T0 == T1 * (T0 * T0)
True
sage: (T.L(1) * T.L(2)) * T.L(2) - T.L(1) * (T.L(2) * T.L(2))
0
sage: (T.L(2) * T.L(3)) * T.L(3) - T.L(2) * (T.L(3) * T.L(3))
0

>>> from sage.all import *
>>> T0 * T1 * T0 * T1 == T1 * T0 * T1 * T0
True
>>> T1 * T2 * T1 == T2 * T1 * T2
True
>>> (T1 * T0) * T0 == T1 * (T0 * T0)
True
>>> (T.L(Integer(1)) * T.L(Integer(2))) * T.L(Integer(2)) - T.L(Integer(1)) * (T.L(Integer(2)) * T.L(Integer(2)))
0
>>> (T.L(Integer(2)) * T.L(Integer(3))) * T.L(Integer(3)) - T.L(Integer(2)) * (T.L(Integer(3)) * T.L(Integer(3)))
0

T0 * T1 * T0 * T1 == T1 * T0 * T1 * T0
T1 * T2 * T1 == T2 * T1 * T2
(T1 * T0) * T0 == T1 * (T0 * T0)
(T.L(1) * T.L(2)) * T.L(2) - T.L(1) * (T.L(2) * T.L(2))
(T.L(2) * T.L(3)) * T.L(3) - T.L(2) * (T.L(3) * T.L(3))
a_realization()[source]

Return a realization of self.

EXAMPLES:

sage: H = algebras.ArikiKoike(5, 2)
sage: H.a_realization()
Ariki-Koike algebra of rank 5 and order 2
 with q=q and u=(u0, u1, u2, u3, u4) ... in the LT-basis

>>> from sage.all import *
>>> H = algebras.ArikiKoike(Integer(5), Integer(2))
>>> H.a_realization()
Ariki-Koike algebra of rank 5 and order 2
 with q=q and u=(u0, u1, u2, u3, u4) ... in the LT-basis

H = algebras.ArikiKoike(5, 2)
H.a_realization()
cyclotomic_parameters()[source]

Return the cyclotomic parameters \(u\) of self.

EXAMPLES:

sage: H = algebras.ArikiKoike(5, 3)
sage: H.cyclotomic_parameters()
(u0, u1, u2, u3, u4)

>>> from sage.all import *
>>> H = algebras.ArikiKoike(Integer(5), Integer(3))
>>> H.cyclotomic_parameters()
(u0, u1, u2, u3, u4)

H = algebras.ArikiKoike(5, 3)
H.cyclotomic_parameters()
hecke_parameter()[source]

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

EXAMPLES:

sage: H = algebras.ArikiKoike(5, 3)
sage: H.hecke_parameter()
q

>>> from sage.all import *
>>> H = algebras.ArikiKoike(Integer(5), Integer(3))
>>> H.hecke_parameter()
q

H = algebras.ArikiKoike(5, 3)
H.hecke_parameter()
q()[source]

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

EXAMPLES:

sage: H = algebras.ArikiKoike(5, 3)
sage: H.hecke_parameter()
q

>>> from sage.all import *
>>> H = algebras.ArikiKoike(Integer(5), Integer(3))
>>> H.hecke_parameter()
q

H = algebras.ArikiKoike(5, 3)
H.hecke_parameter()
specht_module(la)[source]

Return the Specht module of self corresponding to the shape la.

EXAMPLES:

sage: AK = algebras.ArikiKoike(4, 6)
sage: AK.specht_module([[2], [], [1,1,1], [1]])
Specht module of shape ([2], [], [1, 1, 1], [1]) for
 Ariki-Koike algebra of rank 4 and order 6 with q=q and u=(u0, u1, u2, u3)
 over ... over Integer Ring

>>> from sage.all import *
>>> AK = algebras.ArikiKoike(Integer(4), Integer(6))
>>> AK.specht_module([[Integer(2)], [], [Integer(1),Integer(1),Integer(1)], [Integer(1)]])
Specht module of shape ([2], [], [1, 1, 1], [1]) for
 Ariki-Koike algebra of rank 4 and order 6 with q=q and u=(u0, u1, u2, u3)
 over ... over Integer Ring

AK = algebras.ArikiKoike(4, 6)
AK.specht_module([[2], [], [1,1,1], [1]])
u()[source]

Return the cyclotomic parameters \(u\) of self.

EXAMPLES:

sage: H = algebras.ArikiKoike(5, 3)
sage: H.cyclotomic_parameters()
(u0, u1, u2, u3, u4)

>>> from sage.all import *
>>> H = algebras.ArikiKoike(Integer(5), Integer(3))
>>> H.cyclotomic_parameters()
(u0, u1, u2, u3, u4)

H = algebras.ArikiKoike(5, 3)
H.cyclotomic_parameters()