Littelmann paths

class sage.combinat.crystals.littelmann_path.CrystalOfLSPaths(cartan_type, starting_weight)

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

Crystal graph of LS paths generated from the straight-line path to a given weight.

INPUT:

  • cartan_type – the Cartan type of a finite or affine root system
  • starting_weight – a weight given as a list of coefficients of the fundamental weights

The crystal class of piecewise linear paths in the weight space, generated from a straight-line path from the origin to a given element of the weight lattice.

OUTPUT: - a tuple of weights defining the directions of the piecewise linear segments

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2,1],[-1,0,1]); C
The crystal of LS paths of type ['A', 2, 1] and weight (-1, 0, 1)
sage: c = C.module_generators[0]; c
(-Lambda[0] + Lambda[2],)
sage: [c.f(i) for i in C.index_set()]
[None, None, (Lambda[1] - Lambda[2],)]

sage: R = C.R; R
Root system of type ['A', 2, 1]
sage: Lambda = R.weight_space().basis(); Lambda
Finite family {0: Lambda[0], 1: Lambda[1], 2: Lambda[2]}
sage: b=C(tuple([-Lambda[0]+Lambda[2]]))
sage: b==c
True
sage: b.f(2)
(Lambda[1] - Lambda[2],)

For classical highest weight crystals we can also compare the results with the tableaux implementation:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: list(set(C.list()))
[(-Lambda[1] - Lambda[2],), (-Lambda[1] + 1/2*Lambda[2], Lambda[1] - 1/2*Lambda[2]), (-Lambda[1] + 2*Lambda[2],),
(1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2]), (Lambda[1] - 2*Lambda[2],), (-2*Lambda[1] + Lambda[2],),
(2*Lambda[1] - Lambda[2],), (Lambda[1] + Lambda[2],)]
sage: C.cardinality()
8
sage: B = CrystalOfTableaux(['A',2],shape=[2,1])
sage: B.cardinality()
8
sage: B.digraph().is_isomorphic(C.digraph())
True

TESTS:

sage: C = CrystalOfLSPaths(['A',2,1],[-1,0,1])
sage: TestSuite(C).run(skip=['_test_elements', '_test_elements_eq', '_test_enumerated_set_contains', '_test_some_elements'])
sage: C = CrystalOfLSPaths(['E',6],[1,0,0,0,0,0])
sage: TestSuite(C).run()

REFERENCES:

.. [L] P. Littelmann, Paths and root operators in representation theory. Ann. of Math. (2) 142 (1995), no. 3, 499-525.
class Element(value, parent)

Bases: sage.structure.element_wrapper.ElementWrapper

TESTS:

sage: C = CrystalOfLSPaths(['E',6],[1,0,0,0,0,0])
sage: c=C.an_element()
sage: TestSuite(c).run()
compress()

Merges consecutive positively parallel steps present in the path.

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: Lambda = C.R.weight_space().fundamental_weights(); Lambda
Finite family {1: Lambda[1], 2: Lambda[2]}
sage: c = C(tuple([1/2*Lambda[1]+1/2*Lambda[2], 1/2*Lambda[1]+1/2*Lambda[2]]))
sage: c.compress()
(Lambda[1] + Lambda[2],)
dualize()

Returns dualized path.

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: for c in C:
...     print c, c.dualize()
...    
(Lambda[1] + Lambda[2],) (-Lambda[1] - Lambda[2],)
(-Lambda[1] + 2*Lambda[2],) (Lambda[1] - 2*Lambda[2],)
(1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2]) (1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2])
(Lambda[1] - 2*Lambda[2],) (-Lambda[1] + 2*Lambda[2],)
(-Lambda[1] - Lambda[2],) (Lambda[1] + Lambda[2],)
(2*Lambda[1] - Lambda[2],) (-2*Lambda[1] + Lambda[2],)
(-Lambda[1] + 1/2*Lambda[2], Lambda[1] - 1/2*Lambda[2]) (-Lambda[1] + 1/2*Lambda[2], Lambda[1] - 1/2*Lambda[2])
(-2*Lambda[1] + Lambda[2],) (2*Lambda[1] - Lambda[2],)
e(i, power=1, to_string_end=False, length_only=False)

Returns the i-th crystal raising operator on self.

INPUT:

  • i – element of the index set of the underlying root system

  • power – positive integer; specifies the power of the raising operator

    to be applied (default: 1)

  • to_string_end – boolean; if set to True, returns the dominant end of the i-string of self. (default: False)

  • length_only – boolean; if set to True, returns the distance to the dominant

    end of the i-string of self.

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: c = C[2]; c
(1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2])
sage: c.e(1)
sage: c.e(2)
(-Lambda[1] + 2*Lambda[2],)
sage: c.e(2,to_string_end=True)
(-Lambda[1] + 2*Lambda[2],)
sage: c.e(1,to_string_end=True)
(1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2])
sage: c.e(1,length_only=True)
0
endpoint()

Computes the endpoint of the path.

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: b = C.module_generators[0]
sage: b.endpoint()
Lambda[1] + Lambda[2]
sage: b.f_string([1,2,2,1])
(-Lambda[1] - Lambda[2],)
sage: b.f_string([1,2,2,1]).endpoint()
-Lambda[1] - Lambda[2]
sage: b.f_string([1,2])
(1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2])
sage: b.f_string([1,2]).endpoint()
0
sage: b = C([])
sage: b.endpoint()
0
epsilon(i)

Returns the distance to the beginning of the i-string.

This method overrides the generic implementation in the category of crystals since this computation is more efficient.

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: [c.epsilon(1) for c in C]
[0, 1, 0, 0, 1, 0, 1, 2]
sage: [c.epsilon(2) for c in C]
[0, 0, 1, 2, 1, 1, 0, 0]
f(i, power=1, to_string_end=False, length_only=False)

Returns the i-th crystal lowering operator on self.

INPUT:

  • i – element of the index set of the underlying root system

  • power – positive integer; specifies the power of the lowering operator

    to be applied (default: 1)

  • to_string_end – boolean; if set to True, returns the anti-dominant end of the i-string of self. (default: False)

  • length_only – boolean; if set to True, returns the distance to the anti-dominant

    end of the i-string of self.

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: c = C.module_generators[0]
sage: c.f(1)
(-Lambda[1] + 2*Lambda[2],)
sage: c.f(1,power=2)
sage: c.f(2)
(2*Lambda[1] - Lambda[2],)
sage: c.f(2,to_string_end=True)
(2*Lambda[1] - Lambda[2],)
sage: c.f(2,length_only=True)
1

sage: C = CrystalOfLSPaths(['A',2,1],[-1,-1,2])
sage: c = C.module_generators[0]
sage: c.f(2,power=2)
(Lambda[0] + Lambda[1] - 2*Lambda[2],)
phi(i)

Returns the distance to the end of the i-string.

This method overrides the generic implementation in the category of crystals since this computation is more efficient.

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: [c.phi(1) for c in C]
[1, 0, 0, 1, 0, 2, 1, 0]
sage: [c.phi(2) for c in C]
[1, 2, 1, 0, 0, 0, 0, 1]
reflect_step(which_step, i)

Apply the i-th simple reflection to the indicated step in self.

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: b = C.module_generators[0]
sage: b.reflect_step(0,1)
(-Lambda[1] + 2*Lambda[2],)
sage: b.reflect_step(0,2)
(2*Lambda[1] - Lambda[2],)
s(i)

Computes the reflection of self along the i-string.

This method is more efficient than the generic implementation since it uses powers of e and f in the Littelmann model directly.

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: c = C.module_generators[0]
sage: c.s(1)
(-Lambda[1] + 2*Lambda[2],)
sage: c.s(2)
(2*Lambda[1] - Lambda[2],)

sage: C = CrystalOfLSPaths(['A',2,1],[-1,0,1])
sage: c = C.module_generators[0]; c
(-Lambda[0] + Lambda[2],)
sage: c.s(2)
(Lambda[1] - Lambda[2],)
sage: c.s(1)
(-Lambda[0] + Lambda[2],)
sage: c.f(2).s(1)
(Lambda[0] - Lambda[1],)
split_step(which_step, r)

Splits indicated step into two parallel steps of relative lengths r and 1-r.

INPUT: - which_step – a position in the tuple self - r – a rational number between 0 and 1

EXAMPLES:

sage: C = CrystalOfLSPaths(['A',2],[1,1])
sage: b = C.module_generators[0]
sage: b.split_step(0,1/3)
(1/3*Lambda[1] + 1/3*Lambda[2], 2/3*Lambda[1] + 2/3*Lambda[2])

Previous topic

Kirillov-Reshetikhin Crystals

Next topic

Spin Crystals

This Page