Tensor Products of Crystals¶

Main entry points:

TensorProductOfCrystals()

CrystalOfTableaux

class sage.combinat.crystals.tensor_product.CrystalOfTableaux(cartan_type, shapes)¶

Bases: sage.combinat.crystals.tensor_product.CrystalOfWords

A class for crystals of tableaux with integer valued shapes

INPUT:

cartan_type – a Cartan type

shape – a partition of length at most cartan_type.rank()

shapes – a list of such partitions

This constructs a classical crystal with the given Cartan type and highest weight(s) corresponding to the given shape(s).

If the type is $D_r$ , the shape is permitted to have a negative value in the $r$ -th position. Thus if shape=`[s_1,dots,s_r]` then $s_r$ may be negative but in any case $s_1 \ge \cdots \ge s_{r-1} \ge |s_r|$ . This crystal is related to that of shape $[s_1,\dots,|s_r|]$ by the outer automorphism of $SO(2r)$ .

If the type is $D_r$ or $B_r$ , the shape is permitted to be of length $r$ with all parts of half integer value. This corresponds to having one spin column at the beginning of the tableau. If several shapes are provided, they currently should all or none have this property.

Crystals of tableaux are constructed using an embedding into tensor products following Kashiwara and Nakashima [Kashiwara, Masaki; Nakashima, Toshiki, Crystal graphs for representations of the q-analogue of classical Lie algebras, J. Algebra 165 (1994), no. 2, 295-345.]. Sage’s tensor product rule for crystals differs from that of Kashiwara and Nakashima by reversing the order of the tensor factors. Sage produces the same crystals of tableaux as Kashiwara and Nakashima. With Sage’s convention, the tensor product of crystals is the same as the monoid operation on tableaux and hence the plactic monoid.

See also

sage.combinat.crystals.crystals for general help on crystals, and in particular plotting and LaTeX output.

EXAMPLES:

We create the crystal of tableaux for type $A_2$ , with highest weight given by the partition [2,1,1]:

sage: T = CrystalOfTableaux(['A',3], shape = [2,1,1])

Here is the list of its elements:

sage: T.list()
[[[1, 1], [2], [3]], [[1, 2], [2], [3]], [[1, 3], [2], [3]],
 [[1, 4], [2], [3]], [[1, 4], [2], [4]], [[1, 4], [3], [4]],
 [[2, 4], [3], [4]], [[1, 1], [2], [4]], [[1, 2], [2], [4]],
 [[1, 3], [2], [4]], [[1, 3], [3], [4]], [[2, 3], [3], [4]],
 [[1, 1], [3], [4]], [[1, 2], [3], [4]], [[2, 2], [3], [4]]]

Internally, a tableau of a given Cartan type is represented as a tensor product of letters of the same type. The order in which the tensor factors appear is by reading the columns of the tableaux left to right, top to bottom (in French notation). As an example:

sage: T = CrystalOfTableaux(['A',2], shape = [3,2])
sage: T.module_generators[0]
[[1, 1, 1], [2, 2]]
sage: T.module_generators[0]._list
[2, 1, 2, 1, 1]

To create a tableau, one can use:

sage: Tab = CrystalOfTableaux(['A',3], shape = [2,2])
sage: Tab(rows=[[1,2],[3,4]])
[[1, 2], [3, 4]]
sage: Tab(columns=[[3,1],[4,2]])
[[1, 2], [3, 4]]

FIXME:

do we want to specify the columns increasingly or decreasingly. That is, should this be Tab(columns = [[1,3],[2,4]])

make this fully consistent with Tableau()!

We illustrate the use of a shape with a negative last entry in type $D$ :

sage: T = CrystalOfTableaux(['D',4],shape=[1,1,1,-1])
sage: T.cardinality()
35
sage: TestSuite(T).run()

We illustrate the construction of crystals of spin tableaux when the partitions have half integer values in type $B$ and $D$ :

sage: T = CrystalOfTableaux(['B',3],shape=[3/2,1/2,1/2]); T
The crystal of tableaux of type ['B', 3] and shape(s) [[3/2, 1/2, 1/2]]
sage: T.cardinality()
48
sage: T.module_generators
[[+++, [[1]]]]
sage: TestSuite(T).run()

sage: T = CrystalOfTableaux(['D',3],shape=[3/2,1/2,-1/2]); T
The crystal of tableaux of type ['D', 3] and shape(s) [[3/2, 1/2, -1/2]]
sage: T.cardinality()
20
sage: T.module_generators
[[++-, [[1]]]]
sage: TestSuite(T).run()

TESTS:

Base cases:

sage: T = CrystalOfTableaux(['A',2], shape = [])
sage: T.list()
[[]]
sage: TestSuite(T).run()

sage: T = CrystalOfTableaux(['C',2], shape = [1])
sage: T.list()
[[[1]], [[2]], [[-2]], [[-1]]]
sage: TestSuite(T).run()

sage: T = CrystalOfTableaux(['A',2], shapes = [[],[1],[2]])
sage: T.list()
[[], [[1]], [[2]], [[3]], [[1, 1]], [[1, 2]], [[2, 2]], [[1, 3]], [[2, 3]], [[3, 3]]]
sage: T.module_generators
([], [[1]], [[1, 1]])

sage: T = CrystalOfTableaux(['B',2], shape=[3])
sage: T(rows=[[1,1,0]])
[[1, 1, 0]]

Input tests:

sage: T = CrystalOfTableaux(['A',3], shape = [2,2])
sage: C = T.letters
sage: Tab(rows    = [[1,2],[3,4]])._list == [C(3),C(1),C(4),C(2)]
True
sage: Tab(columns = [[3,1],[4,2]])._list == [C(3),C(1),C(4),C(2)]
True

For compatibility with TensorProductOfCrystals() we need to accept as input the internal list or sequence of elements:

sage: Tab(list    = [3,1,4,2])._list     == [C(3),C(1),C(4),C(2)]
True
sage: Tab(3,1,4,2)._list                 == [C(3),C(1),C(4),C(2)]
True

The next example checks whether a given tableau is in fact a valid type $C$ tableau or not:

sage: T = CrystalOfTableaux(['C',3], shape = [2,2,2])
sage: Tab = T(rows=[[1,3],[2,-3],[3,-1]])
sage: Tab in T.list()
True
sage: Tab = T(rows=[[2,3],[3,-3],[-3,-2]])
sage: Tab in T.list()
False

Element¶: alias of CrystalOfTableauxElement

cartan_type()¶

Returns the Cartan type of the associated crystal

EXAMPLES:

sage: T = CrystalOfTableaux(['A',3], shape = [2,2])
sage: T.cartan_type()
['A', 3]

module_generator(shape)¶

This yields the module generator (or highest weight element) of a classical crystal of given shape. The module generator is the unique tableau with equal shape and content.

EXAMPLE:

sage: T = CrystalOfTableaux(['D',3], shape = [1,1])
sage: T.module_generator([1,1])
[[1], [2]]

class sage.combinat.crystals.tensor_product.CrystalOfTableauxElement(parent, *args, **options)¶

Bases: sage.combinat.crystals.tensor_product.TensorProductOfCrystalsElement

There are several ways to input tableaux, by rows, by columns, as the list of column elements, or as a sequence of numbers in column reading.

EXAMPLES:

sage: T = CrystalOfTableaux(['A',3], shape = [2,2])
sage: t = T(rows=[[1,2],[3,4]])
sage: t
[[1, 2], [3, 4]]
sage: TestSuite(t).run()

sage: t = T(columns=[[3,1],[4,2]])
sage: t
[[1, 2], [3, 4]]
sage: TestSuite(t).run()

sage: t = T(list=[3,1,4,2])
sage: t
[[1, 2], [3, 4]]

sage: t = T(3,1,4,2)
sage: t
[[1, 2], [3, 4]]

Currently inputting the empty tableau as an empty sequence is broken due to a bug in the generic __call__ method (see trac ticket #8648)

EXAMPLES:

sage: T = CrystalOfTableaux(['A',3], shape=[])
sage: t = T()
sage: t._list
[0]

pp()¶

EXAMPLES:

sage: T = CrystalOfTableaux(['A',3], shape = [2,2])
sage: t = T(rows=[[1,2],[3,4]])
sage: t.pp()
1  2
3  4

promotion()¶

Promotion for type A crystals of tableaux of rectangular shape

Returns the result of applying promotion on this tableau.

This method only makes sense in type A with rectangular shapes.

EXAMPLES:

sage: C = CrystalOfTableaux(["A",3], shape = [3,3,3])
sage: t = C(Tableau([[1,1,1],[2,2,3],[3,4,4]]))
sage: t
[[1, 1, 1], [2, 2, 3], [3, 4, 4]]
sage: t.promotion()
[[1, 1, 2], [2, 2, 3], [3, 4, 4]]
sage: t.promotion().parent()
The crystal of tableaux of type ['A', 3] and shape(s) [[3, 3, 3]]

promotion_inverse()¶

Inverse promotion for type A crystals of tableaux of rectangular shape

Returns the result of applying inverse promotion on this tableau.

This method only makes sense in type A with rectangular shapes.

EXAMPLES:

sage: C = CrystalOfTableaux(["A",3], shape = [3,3,3])
sage: t = C(Tableau([[1,1,1],[2,2,3],[3,4,4]]))
sage: t
[[1, 1, 1], [2, 2, 3], [3, 4, 4]]
sage: t.promotion_inverse()
[[1, 1, 2], [2, 3, 3], [4, 4, 4]]
sage: t.promotion_inverse().parent()
The crystal of tableaux of type ['A', 3] and shape(s) [[3, 3, 3]]

to_tableau()¶

Returns the Tableau object corresponding to self.

EXAMPLES:

sage: T = CrystalOfTableaux(['A',3], shape = [2,2])
sage: t = T(rows=[[1,2],[3,4]]).to_tableau(); t
[[1, 2], [3, 4]]
sage: type(t)
<class 'sage.combinat.tableau.Tableau_class'>
sage: type(t[0][0])
<type 'sage.rings.integer.Integer'>
sage: T = CrystalOfTableaux(['D',3], shape = [1,1])
sage: t=T(rows=[[-3],[3]]).to_tableau(); t
[[-3], [3]]
sage: t=T(rows=[[3],[-3]]).to_tableau(); t
[[3], [-3]]
sage: T = CrystalOfTableaux(['B',2], shape = [1,1])
sage: t = T(rows=[[0],[0]]).to_tableau(); t
[[0], [0]]

class sage.combinat.crystals.tensor_product.CrystalOfWords¶

Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.Parent

Auxiliary class to provide a call method to create tensor product elements. This class is shared with several tensor product classes and is also used in CrystalOfTableaux to allow tableaux of different tensor product structures in column-reading (and hence different shapes) to be considered elements in the same crystal.

Element¶: alias of TensorProductOfCrystalsElement

class sage.combinat.crystals.tensor_product.FullTensorProductOfCrystals(crystals, **options)¶

Bases: sage.combinat.crystals.tensor_product.CrystalOfWords

TESTS:

sage: from sage.combinat.crystals.tensor_product import FullTensorProductOfCrystals
sage: C = CrystalOfLetters(['A',2])
sage: T = TensorProductOfCrystals(C,C)
sage: isinstance(T, FullTensorProductOfCrystals)
True
sage: TestSuite(T).run()

cardinality()¶

EXAMPLES:

sage: C = CrystalOfLetters(['A',2])
sage: T = TensorProductOfCrystals(C,C)
sage: T.cardinality()
9

class sage.combinat.crystals.tensor_product.ImmutableListWithParent(parent, list)¶

Bases: sage.combinat.combinat.CombinatorialObject, sage.structure.element.Element

A class for lists having a parent

Specification: any subclass C should implement __init__ which accepts the following form C(parent, list = list)

EXAMPLES: We create an immutable list whose parent is the class list:

sage: from sage.combinat.crystals.tensor_product import ImmutableListWithParent, TestParent
sage: l = ImmutableListWithParent(TestParent(), [1,2,3])
sage: l._list
[1, 2, 3]
sage: l.parent()
A parent for tests
sage: l.sibling([2,1]) == ImmutableListWithParent(TestParent(), [2,1])
True
sage: l.reversed()
[3, 2, 1]
sage: l.set_index(1,4)
[1, 4, 3]

reversed()¶

Returns the sibling of self which is obtained by reversing the elements of self.

EXAMPLES:

sage: from sage.combinat.crystals.tensor_product import ImmutableListWithParent, TestParent
sage: l = ImmutableListWithParent(TestParent(), [1,2,3])
sage: l.reversed()
[3, 2, 1]

set_index(k, value)¶

Returns the sibling of self obtained by setting the $k^{th}$ entry of self to value.

EXAMPLES:

sage: from sage.combinat.crystals.tensor_product import ImmutableListWithParent, TestParent
sage: l = ImmutableListWithParent(TestParent(), [1,2,3])
sage: l.set_index(0,2)
[2, 2, 3]
sage: l.set_index(1,4)
[1, 4, 3]
sage: _.parent()
A parent for tests

sibling(l)¶

Returns an ImmutableListWithParent object whose list is l and whose parent is the same as self’s parent.

Note that the implementation of this function makes an assumption about the constructor for subclasses.

EXAMPLES:

sage: from sage.combinat.crystals.tensor_product import ImmutableListWithParent, TestParent
sage: l = ImmutableListWithParent(TestParent(), [1,2,3])
sage: m = l.sibling([2,3,4]); m
[2, 3, 4]
sage: m.parent()
A parent for tests

sage.combinat.crystals.tensor_product.TensorProductOfCrystals(*crystals, **options)¶

Tensor product of crystals.

Given two crystals $B$ and $B'$ of the same type, one can form the tensor product $B \otimes B'$ . As a set $B \otimes B'$ is the Cartesian product $B \times B'$ . The crystal operators $f_i$ and $e_i$ act on $b \otimes b' \in B \otimes B'$ as follows:

$f_i(b \otimes b') = \begin{cases} f_i(b) \otimes b' & \text{if $\varepsilon_i(b) \ge \varphi_i(b')$}\\ b \otimes f_i(b') & \text{otherwise} \end{cases}$

and

$e_i(b \otimes b') = \begin{cases} b \otimes e_i(b') & \text{if $\varepsilon_i(b) \le \varphi_i(b')$}\\ e_i(b) \otimes b' & \text{otherwise.} \end{cases}$

Note that this is the opposite of Kashiwara’s convention for tensor products of crystals.

EXAMPLES:

We construct the type $A_2$ -crystal generated by $2 \otimes 1 \otimes 1$ :

sage: C = CrystalOfLetters(['A',2])
sage: T = TensorProductOfCrystals(C,C,C,generators=[[C(2),C(1),C(1)]])

It has $8$ elements:

sage: T.list()
[[2, 1, 1], [2, 1, 2], [2, 1, 3], [3, 1, 3], [3, 2, 3], [3, 1, 1], [3, 1, 2], [3, 2, 2]]

One can also check the Cartan type of the crystal:

sage: T.cartan_type()
['A', 2]

Other examples include crystals of tableaux (which internally are represented as tensor products obtained by reading the tableaux columnwise):

sage: C = CrystalOfTableaux(['A',3], shape=[1,1,0])
sage: D = CrystalOfTableaux(['A',3], shape=[1,0,0])
sage: T = TensorProductOfCrystals(C,D, generators=[[C(rows=[[1], [2]]), D(rows=[[1]])], [C(rows=[[2], [3]]), D(rows=[[1]])]])
sage: T.cardinality()
24
sage: TestSuite(T).run()
sage: T.module_generators
[[[[1], [2]], [[1]]], [[[2], [3]], [[1]]]]
sage: [x.weight() for x in T.module_generators]
[(2, 1, 0, 0), (1, 1, 1, 0)]

If no module generators are specified, we obtain the full tensor product:

sage: C=CrystalOfLetters(['A',2])
sage: T=TensorProductOfCrystals(C,C)
sage: T.list()
[[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]]
sage: T.cardinality()
9

For a tensor product of crystals without module generators, the default implementation of module_generators contains all elements in the tensor product of the crystals. If there is a subset of elements in the tensor product that still generates the crystal, this needs to be implemented for the specific crystal separately:

sage: T.module_generators.list()
[[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]]

For classical highest weight crystals, it is also possible to list all highest weight elements:

sage: C = CrystalOfLetters(['A',2])
sage: T = TensorProductOfCrystals(C,C,C,generators=[[C(2),C(1),C(1)],[C(1),C(2),C(1)]])
sage: T.highest_weight_vectors()
[[2, 1, 1], [1, 2, 1]]

class sage.combinat.crystals.tensor_product.TensorProductOfCrystalsElement(parent, list)¶

Bases: sage.combinat.crystals.tensor_product.ImmutableListWithParent

A class for elements of tensor products of crystals

affine_grading()¶

Returns the affine grading of $self$ .

INPUT:

self – an element of a tensor product of Kirillov-Reshetikhin crystals.

OUTPUT: an integer

The affine grading is only defined when self is an element of a tensor product of affine Kirillov-Reshetikhin crystals. It 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.

EXAMPLES:

sage: K = KirillovReshetikhinCrystal(['A',2,1],1,1)
sage: T = TensorProductOfCrystals(K,K)
sage: t = T.module_generators[0]
sage: t.affine_grading()
1

sage: K = KirillovReshetikhinCrystal(['A',2,1],1,1)
sage: T = TensorProductOfCrystals(K,K,K)
sage: hw = [b for b in T if all(b.epsilon(i)==0 for i in [1,2])]
sage: for b in hw:
...      print b, b.affine_grading()
...     
[[[1]], [[1]], [[1]]] 3
[[[1]], [[2]], [[1]]] 1
[[[2]], [[1]], [[1]]] 2
[[[3]], [[2]], [[1]]] 0

sage: K = KirillovReshetikhinCrystal(['C',2,1],1,1)
sage: T = TensorProductOfCrystals(K,K,K)
sage: hw = [b for b in T if all(b.epsilon(i)==0 for i in [1,2])]
sage: for b in hw:
...       print b, b.affine_grading()
...     
[[[1]], [[1]], [[1]]] 2
[[[1]], [[2]], [[1]]] 1
[[[1]], [[-1]], [[1]]] 0
[[[2]], [[1]], [[1]]] 1
[[[-2]], [[2]], [[1]]] 0
[[[-1]], [[1]], [[1]]] 1

e(i)¶

Returns the action of $e_i$ on self.

EXAMPLES:

sage: C = CrystalOfLetters(['A',5])
sage: T = TensorProductOfCrystals(C,C)
sage: T(C(1),C(2)).e(1) == T(C(1),C(1))
True
sage: T(C(2),C(1)).e(1) == None
True
sage: T(C(2),C(2)).e(1) == T(C(1),C(2))
True

e_string_to_ground_state()¶

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

INPUT:

self – an element of a tensor product of Kirillov-Reshetikhin crystals.

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

This method is only defined when self is an element of a tensor product of affine Kirillov-Reshetikhin crystals. It calculates a path from self to a ground state path using Demazure arrows as defined in Lemma 7.3 in [SchillingTingley2011].

EXAMPLES:

sage: K = KirillovReshetikhinCrystal(['A',2,1],1,1)
sage: T = TensorProductOfCrystals(K,K)
sage: t = T.module_generators[0]
sage: t.e_string_to_ground_state()
(0, 2)

sage: K = KirillovReshetikhinCrystal(['C',2,1],1,1)
sage: T = TensorProductOfCrystals(K,K)
sage: t = T.module_generators[0]; t
[[[1]], [[1]]]
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
[[[2]], [[1]]]
sage: y.e_string_to_ground_state()
()

energy_function()¶

Returns the energy function of $self$ .

INPUT:

self – an element of a tensor product of perfect Kirillov-Reshetkhin crystals of the same level.

OUTPUT: an integer

The energy is only defined when self is an element of a tensor product of affine Kirillov-Reshetikhin crystals. In this implementation, it is assumed that self is an element of a tensor product of perfect crystals of the same level, see Theorem 7.5 in [SchillingTingley2011].

REFERENCES:

[SchillingTingley2011] (1, 2) A. Schilling, P. Tingley. Demazure crystals, Kirillov-Reshetikhin crystals, and the energy function. preprint arXiv:1104.2359

EXAMPLES:

sage: K = KirillovReshetikhinCrystal(['A',2,1],1,1)
sage: T = TensorProductOfCrystals(K,K,K)
sage: hw = [b for b in T if all(b.epsilon(i)==0 for i in [1,2])]
sage: for b in hw:
...      print b, b.energy_function()
...     
[[[1]], [[1]], [[1]]] 0
[[[1]], [[2]], [[1]]] 2
[[[2]], [[1]], [[1]]] 1
[[[3]], [[2]], [[1]]] 3

sage: K = KirillovReshetikhinCrystal(['C',2,1],1,2)
sage: T = TensorProductOfCrystals(K,K)
sage: hw = [b for b in T if all(b.epsilon(i)==0 for i in [1,2])]
sage: for b in hw:  # long time (5s on sage.math, 2011)
...       print b, b.energy_function()
...     
[[], []] 4
[[], [[1, 1]]] 1
[[[1, 1]], []] 3
[[[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 = KirillovReshetikhinCrystal(['C',2,1],1,1)
sage: T = TensorProductOfCrystals(K)
sage: t = T.module_generators[0]
sage: t.energy_function()
Traceback (most recent call last):
...
AssertionError: All crystals in the tensor product need to be perfect of the same level

epsilon(i)¶

EXAMPLES:

sage: C = CrystalOfLetters(['A',5])
sage: T = TensorProductOfCrystals(C,C)
sage: T(C(1),C(1)).epsilon(1)
0
sage: T(C(1),C(2)).epsilon(1)
1
sage: T(C(2),C(1)).epsilon(1)
0

f(i)¶

Returns the action of $f_i$ on self.

EXAMPLES:

sage: C = CrystalOfLetters(['A',5])
sage: T = TensorProductOfCrystals(C,C)
sage: T(C(1),C(1)).f(1)
[1, 2]
sage: T(C(1),C(2)).f(1)
[2, 2]
sage: T(C(2),C(1)).f(1) is None
True

phi(i)¶

EXAMPLES:

sage: C = CrystalOfLetters(['A',5])
sage: T = TensorProductOfCrystals(C,C)
sage: T(C(1),C(1)).phi(1)
2
sage: T(C(1),C(2)).phi(1)
1
sage: T(C(2),C(1)).phi(1)
0

positions_of_unmatched_minus(i, dual=False, reverse=False)¶

EXAMPLES:

sage: C = CrystalOfLetters(['A',5])
sage: T = TensorProductOfCrystals(C,C)
sage: T(C(2),C(1)).positions_of_unmatched_minus(1)
[]
sage: T(C(1),C(2)).positions_of_unmatched_minus(1)
[0]

positions_of_unmatched_plus(i)¶

EXAMPLES:

sage: C = CrystalOfLetters(['A',5])
sage: T = TensorProductOfCrystals(C,C)
sage: T(C(2),C(1)).positions_of_unmatched_plus(1)
[]
sage: T(C(1),C(2)).positions_of_unmatched_plus(1)
[1]

weight()¶

Returns the weight of self.

EXAMPLES:

sage: C = CrystalOfLetters(['A',3])
sage: T = TensorProductOfCrystals(C,C)
sage: T(C(1),C(2)).weight()
(1, 1, 0, 0)
sage: T=CrystalOfTableaux(['D',4],shape=[])
sage: T.list()[0].weight()
(0, 0, 0, 0)

class sage.combinat.crystals.tensor_product.TensorProductOfCrystalsWithGenerators(crystals, generators, cartan_type)¶

Bases: sage.combinat.crystals.tensor_product.CrystalOfWords

EXAMPLES:

sage: C = CrystalOfLetters(['A',2])
sage: T = TensorProductOfCrystals(C,C,C,generators=[[C(2),C(1),C(1)]])
sage: TestSuite(T).run()

class sage.combinat.crystals.tensor_product.TestParent¶

Bases: sage.structure.unique_representation.UniqueRepresentation, sage.structure.parent.Parent

category: a category or list/tuple of categories

If category is a list or tuple, a JoinCategory is created out of them. If category is not specified, the category will be guessed (see CategoryObject), but won’t be used to inherit parent’s or element’s code from this category.

FIXME: eventually, category should be Sets() by default

INPUT:

base – An algebraic structure considered to be the “base” of this parent (e.g. the base field for a vector space).
category – The category in which this parent lies (or list or tuple thereof). Since categories support more general super-categories, this should be the most specific category possible.
element_constructor – A class or function that creates elements of this Parent given appropriate input (can also be filled in later with _populate_coercion_lists_)
gens – Generators for this object (can also be filled in later with _populate_generators_)
names – Names of generators.
normalize – Whether to standardize the names (remove punctuation, etc)
facade – a parent, or tuple thereof, or True

If facade is specified, then Sets().Facades() is added to the categories of the parent. Furthermore, if facade is not True, the internal attribute _facade_for is set accordingly for use by Sets.Facades.ParentMethods.facade_for().

sage.combinat.crystals.tensor_product.trunc(i)¶

Truncates to the integer closer to zero

EXAMPLES:

sage: from sage.combinat.crystals.tensor_product import trunc
sage: trunc(-3/2), trunc(-1), trunc(-1/2), trunc(0), trunc(1/2), trunc(1), trunc(3/2)
(-1, -1, 0, 0, 0, 1, 1)
sage: isinstance(trunc(3/2), Integer)
True

Tensor Products of Crystals¶

Previous topic

Next topic

This Page

Navigation

Tensor Products of Crystals¶

Previous topic

Next topic

This Page

Quick search

Navigation