Loop Crystals¶

class sage.categories.loop_crystals.KirillovReshetikhinCrystals(s=None)

Category of Kirillov-Reshetikhin crystals.

class ElementMethods
energy_function()

Return the energy function of self.

Let $$B$$ be a KR crystal. Let $$b^{\sharp}$$ denote the unique element such that $$\varphi(b^{\sharp}) = \ell \Lambda_0$$ with $$\ell = \min \{ \langle c, \varphi(b) \mid b \in B \}$$. Let $$u_B$$ denote the maximal element of $$B$$. The energy of $$b \in B$$ is given by

$D(b) = H(b \otimes b^{\sharp}) - H(u_B \otimes b^{\sharp}),$

where $$H$$ is the local energy function.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['D',4,1], 2,1)
sage: for x in K.classically_highest_weight_vectors():
....:    x, x.energy_function()
([], 1)
([, ], 0)

sage: K = crystals.KirillovReshetikhin(['D',4,3], 1,2)
sage: for x in K.classically_highest_weight_vectors():
....:    x, x.energy_function()
([], 2)
([], 1)
([[1, 1]], 0)
lusztig_involution()

Return the result of the classical Lusztig involution on self.

EXAMPLES:

sage: KRT = crystals.KirillovReshetikhin(['D',4,1], 2, 3, model='KR')
sage: mg = KRT.module_generators
sage: mg.lusztig_involution()
[[-2, -2, 1], [-1, -1, 2]]
sage: elt = mg.f_string([2,1,3,2]); elt
[[3, -2, 1], [4, -1, 2]]
sage: elt.lusztig_involution()
[[-4, -2, 1], [-3, -1, 2]]
class ParentMethods
R_matrix(K)

Return the combinatorial $$R$$-matrix of self to K.

The combinatorial $$R$$-matrix is the affine crystal isomorphism $$R : L \otimes K \to K \otimes L$$ which maps $$u_{L} \otimes u_K$$ to $$u_K \otimes u_{L}$$, where $$u_K$$ is the unique element in $$K = B^{r,s}$$ of weight $$s\Lambda_r - s c \Lambda_0$$ (see maximal_vector()).

INPUT:

• self – a crystal $$L$$
• K – a Kirillov-Reshetikhin crystal of the same type as $$L$$

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1],1,1)
sage: L = crystals.KirillovReshetikhin(['A',2,1],1,2)
sage: f = K.R_matrix(L)
sage: [[b,f(b)] for b in crystals.TensorProduct(K,L)]
[[[[], [[1, 1]]], [[[1, 1]], []]],
[[[], [[1, 2]]], [[[1, 1]], []]],
[[[], [[2, 2]]], [[[1, 2]], []]],
[[[], [[1, 3]]], [[[1, 1]], []]],
[[[], [[2, 3]]], [[[1, 2]], []]],
[[[], [[3, 3]]], [[[1, 3]], []]],
[[[], [[1, 1]]], [[[1, 2]], []]],
[[[], [[1, 2]]], [[[2, 2]], []]],
[[[], [[2, 2]]], [[[2, 2]], []]],
[[[], [[1, 3]]], [[[2, 3]], []]],
[[[], [[2, 3]]], [[[2, 2]], []]],
[[[], [[3, 3]]], [[[2, 3]], []]],
[[[], [[1, 1]]], [[[1, 3]], []]],
[[[], [[1, 2]]], [[[1, 3]], []]],
[[[], [[2, 2]]], [[[2, 3]], []]],
[[[], [[1, 3]]], [[[3, 3]], []]],
[[[], [[2, 3]]], [[[3, 3]], []]],
[[[], [[3, 3]]], [[[3, 3]], []]]]

sage: K = crystals.KirillovReshetikhin(['D',4,1],1,1)
sage: L = crystals.KirillovReshetikhin(['D',4,1],2,1)
sage: f = K.R_matrix(L)
sage: T = crystals.TensorProduct(K,L)
sage: b = T( K(rows=[]), L(rows=[]) )
sage: f(b)
[[, [-2]], []]

Alternatively, one can compute the combinatorial $$R$$-matrix using the isomorphism method of digraphs:

sage: K1 = crystals.KirillovReshetikhin(['A',2,1],1,1)
sage: K2 = crystals.KirillovReshetikhin(['A',2,1],2,1)
sage: T1 = crystals.TensorProduct(K1,K2)
sage: T2 = crystals.TensorProduct(K2,K1)
sage: T1.digraph().is_isomorphic(T2.digraph(), edge_labels=True, certificate=True) #todo: not implemented (see #10904 and #10549)
(True, {[[], [, ]]: [[, ], []], [[], [, ]]: [[, ], []],
[[], [, ]]: [[, ], []], [[], [, ]]: [[, ], []], [[],
[, ]]: [[, ], []], [[], [, ]]: [[, ], []], [[],
[, ]]: [[, ], []], [[], [, ]]: [[, ], []], [[], [, ]]: [[, ], []]})
affinization()

Return the corresponding affinization crystal of self.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1], 1, 1)
sage: K.affinization()
Affinization of Kirillov-Reshetikhin crystal of type ['A', 2, 1] with (r,s)=(1,1)

sage: K = crystals.KirillovReshetikhin(['A',2,1], 1, 1, model='KR')
sage: K.affinization()
Affinization of Kirillov-Reshetikhin tableaux of type ['A', 2, 1] and shape (1, 1)
b_sharp()

Return the element $$b^{\sharp}$$ of self.

Let $$B$$ be a KR crystal. The element $$b^{\sharp}$$ is the unique element such that $$\varphi(b^{\sharp}) = \ell \Lambda_0$$ with $$\ell = \min \{ \langle c, \varphi(b) \rangle \mid b \in B \}$$.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',6,2], 2,1)
sage: K.b_sharp()
[]
sage: K.b_sharp().Phi()
Lambda

sage: K = crystals.KirillovReshetikhin(['C',3,1], 1,3)
sage: K.b_sharp()
[[-1]]
sage: K.b_sharp().Phi()
2*Lambda

sage: K = crystals.KirillovReshetikhin(['D',6,2], 2,2)
sage: K.b_sharp() # long time
[]
sage: K.b_sharp().Phi() # long time
2*Lambda
cardinality()

Return the cardinality of self.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['E',6,1], 1,1)
sage: K.cardinality()
27
sage: K = crystals.KirillovReshetikhin(['C',6,1], 4,3)
sage: K.cardinality()
4736732
classical_decomposition()

Return the classical decomposition of self.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',3,1], 2,2)
sage: K.classical_decomposition()
The crystal of tableaux of type ['A', 3] and shape(s) [[2, 2]]
classically_highest_weight_vectors()

Return the classically highest weight elements of self.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['E',6,1],1,1)
sage: K.classically_highest_weight_vectors()
([(1,)],)
is_perfect(ell=None)

Check if self is a perfect crystal of level ell.

A crystal $$\mathcal{B}$$ is perfect of level $$\ell$$ if:

1. $$\mathcal{B}$$ is isomorphic to the crystal graph of a finite-dimensional $$U_q'(\mathfrak{g})$$-module.
2. $$\mathcal{B} \otimes \mathcal{B}$$ is connected.
3. There exists a $$\lambda\in X$$, such that $$\mathrm{wt}(\mathcal{B}) \subset \lambda + \sum_{i\in I} \ZZ_{\le 0} \alpha_i$$ and there is a unique element in $$\mathcal{B}$$ of classical weight $$\lambda$$.
4. For all $$b \in \mathcal{B}$$, $$\mathrm{level}(\varepsilon (b)) \geq \ell$$.
5. For all $$\Lambda$$ dominant weights of level $$\ell$$, there exist unique elements $$b_{\Lambda}, b^{\Lambda} \in \mathcal{B}$$, such that $$\varepsilon(b_{\Lambda}) = \Lambda = \varphi(b^{\Lambda})$$.

Points (1)-(3) are known to hold. This method checks points (4) and (5).

If self is the Kirillov-Reshetikhin crystal $$B^{r,s}$$, then it was proven for non-exceptional types in [FOS2010] that it is perfect if and only if $$s/c_r$$ is an integer (where $$c_r$$ is a constant related to the type of the crystal).

It is conjectured this is true for all affine types.

INPUT:

• ell – (default: $$s / c_r$$) integer; the level

REFERENCES:

[FOS2010]

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1], 1, 1)
sage: K.is_perfect()
True

sage: K = crystals.KirillovReshetikhin(['C',2,1], 1, 1)
sage: K.is_perfect()
False

sage: K = crystals.KirillovReshetikhin(['C',2,1], 1, 2)
sage: K.is_perfect()
True

sage: K = crystals.KirillovReshetikhin(['E',6,1], 1,3)
sage: K.is_perfect()
True

Todo

Implement a version for tensor products of KR crystals.

level()

Return the level of self when self is a perfect crystal.

is_perfect()

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1], 1, 1)
sage: K.level()
1
sage: K = crystals.KirillovReshetikhin(['C',2,1], 1, 2)
sage: K.level()
1
sage: K = crystals.KirillovReshetikhin(['D',4,1], 1, 3)
sage: K.level()
3

sage: K = crystals.KirillovReshetikhin(['C',2,1], 1, 1)
sage: K.level()
Traceback (most recent call last):
...
ValueError: this crystal is not perfect
local_energy_function(B)

Return the local energy function of self and B.

See LocalEnergyFunction for a definition.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',6,2], 2,1)
sage: Kp = crystals.KirillovReshetikhin(['A',6,2], 1,1)
sage: H = K.local_energy_function(Kp); H
Local energy function of
Kirillov-Reshetikhin crystal of type ['BC', 3, 2] with (r,s)=(2,1)
tensor
Kirillov-Reshetikhin crystal of type ['BC', 3, 2] with (r,s)=(1,1)
maximal_vector()

Return the unique element of classical weight $$s \Lambda_r$$ in self.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['C',2,1],1,2)
sage: K.maximal_vector()
[[1, 1]]
sage: K = crystals.KirillovReshetikhin(['E',6,1],1,1)
sage: K.maximal_vector()
[(1,)]

sage: K = crystals.KirillovReshetikhin(['D',4,1],2,1)
sage: K.maximal_vector()
[, ]
module_generator()

Return the unique module generator of classical weight $$s \Lambda_r$$ of the Kirillov-Reshetikhin crystal $$B^{r,s}$$.

EXAMPLES:

sage: La = RootSystem(['G',2,1]).weight_space().fundamental_weights()
sage: K = crystals.ProjectedLevelZeroLSPaths(La)
sage: K.module_generator()
(-Lambda + Lambda,)
q_dimension(q=None, prec=None, use_product=False)

Return the $$q$$-dimension of self.

The $$q$$-dimension of a KR crystal is defined as the $$q$$-dimension of the underlying classical crystal.

EXAMPLES:

sage: KRC = crystals.KirillovReshetikhin(['A',2,1], 2,2)
sage: KRC.q_dimension()
q^4 + q^3 + 2*q^2 + q + 1
sage: KRC = crystals.KirillovReshetikhin(['D',4,1], 2,1)
sage: KRC.q_dimension()
q^10 + q^9 + 3*q^8 + 3*q^7 + 4*q^6 + 4*q^5 + 4*q^4 + 3*q^3 + 3*q^2 + q + 2
r()

Return the value $$r$$ in self written as $$B^{r,s}$$.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',3,1], 2,4)
sage: K.r()
2
s()

Return the value $$s$$ in self written as $$B^{r,s}$$.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',3,1], 2,4)
sage: K.s()
4
class TensorProducts(category, *args)

The category of tensor products of Kirillov-Reshetikhin crystals.

class ElementMethods

Return the affine grading of self.

The affine grading is calculated by finding a path from self to a ground state path (using the helper method e_string_to_ground_state()) and counting the number of affine Kashiwara operators $$e_0$$ applied on the way.

OUTPUT: an integer

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1],1,1)
sage: T = crystals.TensorProduct(K,K)
sage: t = T.module_generators
1

sage: K = crystals.KirillovReshetikhin(['A',2,1],1,1)
sage: T = crystals.TensorProduct(K,K,K)
sage: hw = T.classically_highest_weight_vectors()
sage: for b in hw:
....:     print("{} {}".format(b, b.affine_grading()))
[[], [], []] 3
[[], [], []] 2
[[], [], []] 1
[[], [], []] 0

sage: K = crystals.KirillovReshetikhin(['C',2,1],1,1)
sage: T = crystals.TensorProduct(K,K,K)
sage: hw = T.classically_highest_weight_vectors()
sage: for b in hw:
....:     print("{} {}".format(b, b.affine_grading()))
[[], [], []] 2
[[], [], []] 1
[[[-1]], [], []] 1
[[], [], []] 1
[[[-2]], [], []] 0
[[], [[-1]], []] 0
e_string_to_ground_state()

Return a string of integers in the index set $$(i_1, \ldots, i_k)$$ such that $$e_{i_k} \cdots e_{i_1}$$ of self is the ground state.

This method calculates a path from self to a ground state path using Demazure arrows as defined in Lemma 7.3 in [ST2011].

OUTPUT: a tuple of integers $$(i_1, \ldots, i_k)$$

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1],1,1)
sage: T = crystals.TensorProduct(K,K)
sage: t = T.module_generators
sage: t.e_string_to_ground_state()
(0, 2)

sage: K = crystals.KirillovReshetikhin(['C',2,1],1,1)
sage: T = crystals.TensorProduct(K,K)
sage: t = T.module_generators; t
[[], []]
sage: t.e_string_to_ground_state()
(0,)
sage: x = t.e(0)
sage: x.e_string_to_ground_state()
()
sage: y = t.f_string([1,2,1,1,0]); y
[[], []]
sage: y.e_string_to_ground_state()
()
energy_function(algorithm=None)

Return the energy function of self.

ALGORITHM:

definition

Let $$T$$ be a tensor product of Kirillov-Reshetikhin crystals. Let $$R_i$$ and $$H_i$$ be the combinatorial $$R$$-matrix and local energy functions, respectively, acting on the $$i$$ and $$i+1$$ factors. Let $$D_B$$ be the energy function of a single Kirillov-Reshetikhin crystal. The energy function is given by

$D = \sum_{j > i} H_i R_{i+1} R_{i+2} \cdots R_{j-1} + \sum_j D_B R_1 R_2 \cdots R_{j-1},$

where $$D_B$$ acts on the rightmost factor.

If self is an element of $$T$$, a tensor product of perfect crystals of the same level, then use the affine grading to determine the energy. Specifically, let $$g$$ denote the affine grading of self and $$d$$ the affine grading of the maximal vector in $$T$$. Then the energy of self is given by $$d - g$$.

For more details, see Theorem 7.5 in [ST2011].

INPUT:

• algorithm – (default: None) use one of the following algorithms to determine the energy function:

• 'definition' - use the definition of the energy function;
• 'grading' - use the affine grading;

if not specified, then this uses 'grading' if all factors are perfect of the same level and otherwise this uses 'definition'

OUTPUT: an integer

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1], 1, 1)
sage: T = crystals.TensorProduct(K,K,K)
sage: hw = T.classically_highest_weight_vectors()
sage: for b in hw:
....:     print("{} {}".format(b, b.energy_function()))
[[], [], []] 0
[[], [], []] 1
[[], [], []] 2
[[], [], []] 3

sage: K = crystals.KirillovReshetikhin(['C',2,1], 1, 2)
sage: T = crystals.TensorProduct(K,K)
sage: hw = T.classically_highest_weight_vectors()
sage: for b in hw:
....:     print("{} {}".format(b, b.energy_function()))
[[], []] 4
[[[1, 1]], []] 3
[[], [[1, 1]]] 1
[[[1, 1]], [[1, 1]]] 0
[[[1, 2]], [[1, 1]]] 1
[[[2, 2]], [[1, 1]]] 2
[[[-1, -1]], [[1, 1]]] 2
[[[1, -1]], [[1, 1]]] 2
[[[2, -1]], [[1, 1]]] 2

sage: K = crystals.KirillovReshetikhin(['C',2,1], 1, 1)
sage: T = crystals.TensorProduct(K)
sage: t = T.module_generators
Traceback (most recent call last):
...
NotImplementedError: all crystals in the tensor product
need to be perfect of the same level
class ParentMethods
cardinality()

Return the cardinality of self.

EXAMPLES:

sage: RC = RiggedConfigurations(['A', 3, 1], [[3, 2], [1, 2]])
sage: RC.cardinality()
100
sage: len(RC.list())
100

sage: RC = RiggedConfigurations(['E', 7, 1], [[1,1]])
sage: RC.cardinality()
134
sage: len(RC.list())
134

sage: RC = RiggedConfigurations(['B', 3, 1], [[2,2],[1,2]])
sage: RC.cardinality()
5130
classically_highest_weight_vectors()

Return the classically highest weight elements of self.

This works by using a backtracking algorithm since if $$b_2 \otimes b_1$$ is classically highest weight then $$b_1$$ is classically highest weight.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1],1,1)
sage: T = crystals.TensorProduct(K,K,K)
sage: T.classically_highest_weight_vectors()
([[], [], []],
[[], [], []],
[[], [], []],
[[], [], []])
maximal_vector()

Return the maximal vector of self.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1],1,1)
sage: T = crystals.TensorProduct(K,K,K)
sage: T.maximal_vector()
[[], [], []]
one_dimensional_configuration_sum(q=None, group_components=True)

Compute the one-dimensional configuration sum of self.

INPUT:

• q – (default: None) a variable or None; if None, a variable $$q$$ is set in the code
• group_components – (default: True) boolean; if True, then the terms are grouped by classical component

The one-dimensional configuration sum is the sum of the weights of all elements in the crystal weighted by the energy function.

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['A',2,1],1,1)
sage: T = crystals.TensorProduct(K,K)
sage: T.one_dimensional_configuration_sum()
B[-2*Lambda + 2*Lambda] + (q+1)*B[-Lambda]
+ (q+1)*B[Lambda - Lambda] + B[2*Lambda]
+ B[-2*Lambda] + (q+1)*B[Lambda]
sage: R.<t> = ZZ[]
sage: T.one_dimensional_configuration_sum(t, False)
B[-2*Lambda + 2*Lambda] + (t+1)*B[-Lambda]
+ (t+1)*B[Lambda - Lambda] + B[2*Lambda]
+ B[-2*Lambda] + (t+1)*B[Lambda]

sage: R = RootSystem(['A',2,1])
sage: La = R.weight_space().basis()
sage: LS = crystals.ProjectedLevelZeroLSPaths(2*La)
sage: LS.one_dimensional_configuration_sum() == T.one_dimensional_configuration_sum() # long time
True
extra_super_categories()

EXAMPLES:

sage: from sage.categories.loop_crystals import KirillovReshetikhinCrystals
sage: KirillovReshetikhinCrystals().TensorProducts().extra_super_categories()
[Category of finite regular loop crystals]
super_categories()

EXAMPLES:

sage: from sage.categories.loop_crystals import KirillovReshetikhinCrystals
sage: KirillovReshetikhinCrystals().super_categories()
[Category of finite regular loop crystals]
class sage.categories.loop_crystals.LocalEnergyFunction(B, Bp, normalization=0)

Bases: sage.categories.map.Map

The local energy function.

Let $$B$$ and $$B'$$ be Kirillov-Reshetikhin crystals with maximal vectors $$u_B$$ and $$u_{B'}$$ respectively. The local energy function $$H : B \otimes B' \to \ZZ$$ is the function which satisfies

$\begin{split}H(e_0(b \otimes b')) = H(b \otimes b') + \begin{cases} 1 & \text{if } i = 0 \text{ and LL}, \\ -1 & \text{if } i = 0 \text{ and RR}, \\ 0 & \text{otherwise,} \end{cases}\end{split}$

where LL (resp. RR) denote $$e_0$$ acts on the left (resp. right) on both $$b \otimes b'$$ and $$R(b \otimes b')$$, and normalized by $$H(u_B \otimes u_{B'}) = 0$$.

INPUT:

• B – a Kirillov-Reshetikhin crystal
• Bp – a Kirillov-Reshetikhin crystal
• normalization – (default: 0) the normalization value

EXAMPLES:

sage: K = crystals.KirillovReshetikhin(['C',2,1], 1,2)
sage: K2 = crystals.KirillovReshetikhin(['C',2,1], 2,1)
sage: H = K.local_energy_function(K2)
sage: T = tensor([K, K2])
sage: hw = T.classically_highest_weight_vectors()
sage: for b in hw:
....:     b, H(b)
([[], [, ]], 1)
([[[1, 1]], [, ]], 0)
([[[2, -2]], [, ]], 1)
([[[1, -2]], [, ]], 1)

REFERENCES:

[KKMMNN1992]

class sage.categories.loop_crystals.LoopCrystals(s=None)

The category of $$U_q'(\mathfrak{g})$$-crystals, where $$\mathfrak{g}$$ is of affine type.

The category is called loop crystals as we can also consider them as crystals corresponding to the loop algebra $$\mathfrak{g}_0[t]$$, where $$\mathfrak{g}_0$$ is the corresponding classical type.

EXAMPLES:

sage: from sage.categories.loop_crystals import LoopCrystals
sage: C = LoopCrystals()
sage: C
Category of loop crystals
sage: C.super_categories()
[Category of crystals]
sage: C.example()
Kirillov-Reshetikhin crystal of type ['A', 3, 1] with (r,s)=(1,1)
class ParentMethods
digraph(subset=None, index_set=None)

Return the DiGraph associated to self.

INPUT:

• subset – (optional) a subset of vertices for which the digraph should be constructed
• index_set – (optional) the index set to draw arrows

EXAMPLES:

sage: C = crystals.KirillovReshetikhin(['D',4,1], 2, 1)
sage: G = C.digraph()
sage: G.latex_options()  # optional - dot2tex
LaTeX options for Digraph on 29 vertices:
{...'edge_options': <function ... at ...>...}
sage: view(G, tightpage=True)  # optional - dot2tex graphviz, not tested (opens external window)
weight_lattice_realization()

Return the weight lattice realization used to express weights of elements in self.

The default is to use the non-extended affine weight lattice.

EXAMPLES:

sage: C = crystals.Letters(['A', 5])
sage: C.weight_lattice_realization()
Ambient space of the Root system of type ['A', 5]
sage: K = crystals.KirillovReshetikhin(['A',2,1], 1, 1)
sage: K.weight_lattice_realization()
Weight lattice of the Root system of type ['A', 2, 1]
example(n=3)

Return an example of Kirillov-Reshetikhin crystals, as per Category.example().

EXAMPLES:

sage: from sage.categories.loop_crystals import LoopCrystals
sage: B = LoopCrystals().example(); B
Kirillov-Reshetikhin crystal of type ['A', 3, 1] with (r,s)=(1,1)
super_categories()

EXAMPLES:

sage: from sage.categories.loop_crystals import LoopCrystals
sage: LoopCrystals().super_categories()
[Category of crystals]
class sage.categories.loop_crystals.RegularLoopCrystals(s=None)

The category of regular $$U_q'(\mathfrak{g})$$-crystals, where $$\mathfrak{g}$$ is of affine type.

class ElementMethods
classical_weight()

Return the classical weight of self.

EXAMPLES:

sage: R = RootSystem(['A',2,1])
sage: La = R.weight_space().basis()
sage: LS = crystals.ProjectedLevelZeroLSPaths(2*La)
sage: hw = LS.classically_highest_weight_vectors()
sage: [(v.weight(), v.classical_weight()) for v in hw]
[(-2*Lambda + 2*Lambda, (2, 0, 0)),
(-Lambda + Lambda, (1, 1, 0))]
super_categories()

EXAMPLES:

sage: from sage.categories.loop_crystals import RegularLoopCrystals
sage: RegularLoopCrystals().super_categories()
[Category of regular crystals,
Category of loop crystals]