Littelmann paths - Combinatorics

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

# Littelmann paths

AUTHORS:

- Mark Shimozono, Anne Schilling (2012): Initial version

- Anne Schilling (2013): Implemented `CrystalOfProjectedLevelZeroLSPaths`

- Travis Scrimshaw (2016): Implemented `InfinityCrystalOfLSPaths`

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

  Bases: `UniqueRepresentation`, `Parent`

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

  INPUT:

  - `cartan_type` – (optional) the Cartan type

  - `starting_weight` – a weight; if `cartan_type` is given, then the weight should be given as a list of coefficients of the fundamental weights, otherwise it should be given in the `weight_space` basis; for affine highest weight crystals, one needs to use the extended weight space

  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.

  EXAMPLES:

  Sage

      sage: R = RootSystem(['A',2,1])
      sage: La = R.weight_space(extended = True).basis()
      sage: B = crystals.LSPaths(La[2]-La[0]); B
      The crystal of LS paths of type ['A', 2, 1] and weight -Lambda[0] + Lambda[2]

      sage: C = crystals.LSPaths(['A',2,1],[-1,0,1]); C
      The crystal of LS paths of type ['A', 2, 1] and weight -Lambda[0] + Lambda[2]
      sage: B == C
      True
      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],)

  Python

      >>> from sage.all import *
      >>> R = RootSystem(['A',Integer(2),Integer(1)])
      >>> La = R.weight_space(extended = True).basis()
      >>> B = crystals.LSPaths(La[Integer(2)]-La[Integer(0)]); B
      The crystal of LS paths of type ['A', 2, 1] and weight -Lambda[0] + Lambda[2]

      >>> C = crystals.LSPaths(['A',Integer(2),Integer(1)],[-Integer(1),Integer(0),Integer(1)]); C
      The crystal of LS paths of type ['A', 2, 1] and weight -Lambda[0] + Lambda[2]
      >>> B == C
      True
      >>> c = C.module_generators[Integer(0)]; c
      (-Lambda[0] + Lambda[2],)
      >>> [c.f(i) for i in C.index_set()]
      [None, None, (Lambda[1] - Lambda[2],)]

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

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

  Sage

      sage: C = crystals.LSPaths(['A',2],[1,1])
      sage: sorted(C, key=str)
      [(-2*Lambda[1] + Lambda[2],), (-Lambda[1] + 1/2*Lambda[2], Lambda[1] - 1/2*Lambda[2]),
       (-Lambda[1] + 2*Lambda[2],), (-Lambda[1] - Lambda[2],),
       (1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2]), (2*Lambda[1] - Lambda[2],),
       (Lambda[1] + Lambda[2],), (Lambda[1] - 2*Lambda[2],)]
      sage: C.cardinality()
      8
      sage: B = crystals.Tableaux(['A',2],shape=[2,1])
      sage: B.cardinality()
      8
      sage: B.digraph().is_isomorphic(C.digraph())
      True

  [Python]

      >>> from sage.all import *
      >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
      >>> sorted(C, key=str)
      [(-2*Lambda[1] + Lambda[2],), (-Lambda[1] + 1/2*Lambda[2], Lambda[1] - 1/2*Lambda[2]),
       (-Lambda[1] + 2*Lambda[2],), (-Lambda[1] - Lambda[2],),
       (1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2]), (2*Lambda[1] - Lambda[2],),
       (Lambda[1] + Lambda[2],), (Lambda[1] - 2*Lambda[2],)]
      >>> C.cardinality()
      8
      >>> B = crystals.Tableaux(['A',Integer(2)],shape=[Integer(2),Integer(1)])
      >>> B.cardinality()
      8
      >>> B.digraph().is_isomorphic(C.digraph())
      True

  Make sure you use the weight space and not the weight lattice for your weights:

  Sage

      sage: R = RootSystem(['A',2,1])
      sage: La = R.weight_lattice(extended = True).basis()
      sage: B = crystals.LSPaths(La[2]); B
      Traceback (most recent call last):
      ...
      ValueError: use the weight space, rather than weight lattice for your weights

  Python

      >>> from sage.all import *
      >>> R = RootSystem(['A',Integer(2),Integer(1)])
      >>> La = R.weight_lattice(extended = True).basis()
      >>> B = crystals.LSPaths(La[Integer(2)]); B
      Traceback (most recent call last):
      ...
      ValueError: use the weight space, rather than weight lattice for your weights

  REFERENCES:

  - [Li1995b]

  class Element

    Bases: `ElementWrapper`

    A Littelmann path (crystal element).

    compress()

      Merge consecutive positively parallel steps present in `self`.

      EXAMPLES:

      Sage

          sage: C = crystals.LSPaths(['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],)

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> Lambda = C.R.weight_space().fundamental_weights(); Lambda
          Finite family {1: Lambda[1], 2: Lambda[2]}
          >>> c = C(tuple([Integer(1)/Integer(2)*Lambda[Integer(1)]+Integer(1)/Integer(2)*Lambda[Integer(2)], Integer(1)/Integer(2)*Lambda[Integer(1)]+Integer(1)/Integer(2)*Lambda[Integer(2)]]))
          >>> c.compress()
          (Lambda[1] + Lambda[2],)

    dualize()

      Return the dualized path of `self`.

      EXAMPLES:

      Sage

          sage: C = crystals.LSPaths(['A',2],[1,1])
          sage: for c in C:
          ....:     print("{} {}".format(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],)

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> for c in C:
          ...     print("{} {}".format(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)

      Return the \(i\)-th crystal raising operator on `self`.

      INPUT:

      - `i` – element of the index set of the underlying root system

      - `power` – positive integer (default: 1); specifies the power of the raising operator to be applied

      - `to_string_end` – boolean (default: `False`); if `True`, returns the dominant end of the \(i\)-string of `self`

      - `length_only` – boolean; if `True`, returns the distance to the dominant end of the \(i\)-string of `self`

      EXAMPLES:

      Sage

          sage: C = crystals.LSPaths(['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

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> c = C[Integer(2)]; c
          (1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2])
          >>> c.e(Integer(1))
          >>> c.e(Integer(2))
          (-Lambda[1] + 2*Lambda[2],)
          >>> c.e(Integer(2),to_string_end=True)
          (-Lambda[1] + 2*Lambda[2],)
          >>> c.e(Integer(1),to_string_end=True)
          (1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2])
          >>> c.e(Integer(1),length_only=True)
          0

    endpoint()

      Compute the endpoint of `self`.

      EXAMPLES:

      Sage

          sage: C = crystals.LSPaths(['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

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> b = C.module_generators[Integer(0)]
          >>> b.endpoint()
          Lambda[1] + Lambda[2]
          >>> b.f_string([Integer(1),Integer(2),Integer(2),Integer(1)])
          (-Lambda[1] - Lambda[2],)
          >>> b.f_string([Integer(1),Integer(2),Integer(2),Integer(1)]).endpoint()
          -Lambda[1] - Lambda[2]
          >>> b.f_string([Integer(1),Integer(2)])
          (1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2])
          >>> b.f_string([Integer(1),Integer(2)]).endpoint()
          0
          >>> b = C([])
          >>> b.endpoint()
          0

    epsilon(i)

      Return 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

          sage: C = crystals.LSPaths(['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]

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> [c.epsilon(Integer(1)) for c in C]
          [0, 1, 0, 0, 1, 0, 1, 2]
          >>> [c.epsilon(Integer(2)) for c in C]
          [0, 0, 1, 2, 1, 1, 0, 0]

    f(i, power=1, to_string_end=False, length_only=False)

      Return the \(i\)-th crystal lowering operator on `self`.

      INPUT:

      - `i` – element of the index set of the underlying root system

      - `power` – positive integer (default: 1); specifies the power of the lowering operator to be applied

      - `to_string_end` – boolean (default: `False`); if `True`, returns the anti-dominant end of the \(i\)-string of `self`

      - `length_only` – boolean; if `True`, returns the distance to the anti-dominant end of the \(i\)-string of `self`

      EXAMPLES:

      Sage

          sage: C = crystals.LSPaths(['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 = crystals.LSPaths(['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],)

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> c = C.module_generators[Integer(0)]
          >>> c.f(Integer(1))
          (-Lambda[1] + 2*Lambda[2],)
          >>> c.f(Integer(1),power=Integer(2))
          >>> c.f(Integer(2))
          (2*Lambda[1] - Lambda[2],)
          >>> c.f(Integer(2),to_string_end=True)
          (2*Lambda[1] - Lambda[2],)
          >>> c.f(Integer(2),length_only=True)
          1

          >>> C = crystals.LSPaths(['A',Integer(2),Integer(1)],[-Integer(1),-Integer(1),Integer(2)])
          >>> c = C.module_generators[Integer(0)]
          >>> c.f(Integer(2),power=Integer(2))
          (Lambda[0] + Lambda[1] - 2*Lambda[2],)

    phi(i)

      Return 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

          sage: C = crystals.LSPaths(['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]

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> [c.phi(Integer(1)) for c in C]
          [1, 0, 0, 1, 0, 2, 1, 0]
          >>> [c.phi(Integer(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

          sage: C = crystals.LSPaths(['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],)

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> b = C.module_generators[Integer(0)]
          >>> b.reflect_step(Integer(0),Integer(1))
          (-Lambda[1] + 2*Lambda[2],)
          >>> b.reflect_step(Integer(0),Integer(2))
          (2*Lambda[1] - Lambda[2],)

    s(i)

      Compute 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

          sage: C = crystals.LSPaths(['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 = crystals.LSPaths(['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],)

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> c = C.module_generators[Integer(0)]
          >>> c.s(Integer(1))
          (-Lambda[1] + 2*Lambda[2],)
          >>> c.s(Integer(2))
          (2*Lambda[1] - Lambda[2],)

          >>> C = crystals.LSPaths(['A',Integer(2),Integer(1)],[-Integer(1),Integer(0),Integer(1)])
          >>> c = C.module_generators[Integer(0)]; c
          (-Lambda[0] + Lambda[2],)
          >>> c.s(Integer(2))
          (Lambda[1] - Lambda[2],)
          >>> c.s(Integer(1))
          (-Lambda[0] + Lambda[2],)
          >>> c.f(Integer(2)).s(Integer(1))
          (Lambda[0] - Lambda[1],)

    split_step(which_step, r)

      Split the 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

          sage: C = crystals.LSPaths(['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])

      Python

          >>> from sage.all import *
          >>> C = crystals.LSPaths(['A',Integer(2)],[Integer(1),Integer(1)])
          >>> b = C.module_generators[Integer(0)]
          >>> b.split_step(Integer(0),Integer(1)/Integer(3))
          (1/3*Lambda[1] + 1/3*Lambda[2], 2/3*Lambda[1] + 2/3*Lambda[2])

    weight()

      Return the weight of `self`.

      EXAMPLES:

      Sage

          sage: B = crystals.LSPaths(['A',1,1],[1,0])
          sage: b = B.highest_weight_vector()
          sage: b.f(0).weight()
          -Lambda[0] + 2*Lambda[1] - delta

      Python

          >>> from sage.all import *
          >>> B = crystals.LSPaths(['A',Integer(1),Integer(1)],[Integer(1),Integer(0)])
          >>> b = B.highest_weight_vector()
          >>> b.f(Integer(0)).weight()
          -Lambda[0] + 2*Lambda[1] - delta

  weight_lattice_realization()

    Return weight lattice realization of `self`.

    EXAMPLES:

    Sage

        sage: B = crystals.LSPaths(['B',3],[1,1,0])
        sage: B.weight_lattice_realization()
        Weight space over the Rational Field of the Root system of type ['B', 3]
        sage: B = crystals.LSPaths(['B',3,1],[1,1,1,0])
        sage: B.weight_lattice_realization()
        Extended weight space over the Rational Field of the Root system of type ['B', 3, 1]

    Python

        >>> from sage.all import *
        >>> B = crystals.LSPaths(['B',Integer(3)],[Integer(1),Integer(1),Integer(0)])
        >>> B.weight_lattice_realization()
        Weight space over the Rational Field of the Root system of type ['B', 3]
        >>> B = crystals.LSPaths(['B',Integer(3),Integer(1)],[Integer(1),Integer(1),Integer(1),Integer(0)])
        >>> B.weight_lattice_realization()
        Extended weight space over the Rational Field of the Root system of type ['B', 3, 1]

class sage.combinat.crystals.littelmann_path.CrystalOfProjectedLevelZeroLSPaths(starting_weight, starting_weight_parent)

  Bases: `CrystalOfLSPaths`

  Crystal of projected level zero LS paths.

  INPUT:

  - `weight` – a dominant weight of the weight space of an affine Kac-Moody root system

  When `weight` is just a single fundamental weight \(\Lambda_r\), this crystal is isomorphic to a Kirillov-Reshetikhin (KR) crystal, see also `sage.combinat.crystals.kirillov_reshetikhin.KirillovReshetikhinFromLSPaths()`. For general weights, it is isomorphic to a tensor product of single-column KR crystals.

  EXAMPLES:

  Sage

      sage: R = RootSystem(['C',3,1])
      sage: La = R.weight_space().basis()
      sage: LS = crystals.ProjectedLevelZeroLSPaths(La[1]+La[3])
      sage: LS.cardinality()
      84
      sage: GLS = LS.digraph()

      sage: K1 = crystals.KirillovReshetikhin(['C',3,1],1,1)
      sage: K3 = crystals.KirillovReshetikhin(['C',3,1],3,1)
      sage: T = crystals.TensorProduct(K3,K1)
      sage: T.cardinality()
      84
      sage: GT = T.digraph() # long time
      sage: GLS.is_isomorphic(GT, edge_labels = True) # long time
      True

  Python

      >>> from sage.all import *
      >>> R = RootSystem(['C',Integer(3),Integer(1)])
      >>> La = R.weight_space().basis()
      >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(1)]+La[Integer(3)])
      >>> LS.cardinality()
      84
      >>> GLS = LS.digraph()

      >>> K1 = crystals.KirillovReshetikhin(['C',Integer(3),Integer(1)],Integer(1),Integer(1))
      >>> K3 = crystals.KirillovReshetikhin(['C',Integer(3),Integer(1)],Integer(3),Integer(1))
      >>> T = crystals.TensorProduct(K3,K1)
      >>> T.cardinality()
      84
      >>> GT = T.digraph() # long time
      >>> GLS.is_isomorphic(GT, edge_labels = True) # long time
      True

  class Element

    Bases: `Element`

    Element of a crystal of projected level zero LS paths.

    energy_function()

      Return the energy function of `self`.

      The energy function \(D(\pi)\) of the level zero LS path \(\pi \in \mathbb{B}_\mathrm{cl}(\lambda)\) requires a series of definitions; for simplicity the root system is assumed to be untwisted affine.

      The LS path \(\pi\) is a piecewise linear map from the unit interval \([0,1]\) to the weight lattice. It is specified by “times” \(0 = \sigma_0 < \sigma_1 < \dotsm < \sigma_s = 1\) and “direction vectors” \(x_u \lambda\) where \(x_u \in W / W_J\) for \(1 \le u \le s\), and \(W_J\) is the stabilizer of \(\lambda\) in the finite Weyl group \(W\). Precisely,

      \[\pi(t) = \sum_{u'=1}^{u-1} (\sigma_{u'}-\sigma_{u'-1}) x_{u'} \lambda + (t-\sigma_{u-1}) x_{u} \lambda\]

      for \(1 \le u \le s\) and \(\sigma_{u-1} \le t \le \sigma_{u}\).

      For any \(x,y \in W / W_J\), let

      \[d: x = w_{0} \stackrel{\beta_{1}}{\leftarrow} w_{1} \stackrel{\beta_{2}}{\leftarrow} \cdots \stackrel{\beta_{n}}{\leftarrow} w_{n}=y\]

      be a shortest directed path in the parabolic quantum Bruhat graph. Define

      \[\begin{split}\mathrm{wt}(d) := \sum_{\substack{1 \le k \le n \\ \ell(w_{k-1}) < \ell(w_k)}} \beta_{k}^{\vee}.\end{split}\]

      It can be shown that \(\mathrm{wt}(d)\) depends only on \(x,y\); call its value \(\mathrm{wt}(x,y)\). The energy function \(D(\pi)\) is defined by

      \[D(\pi) = -\sum_{u=1}^{s-1} (1-\sigma_{u}) \langle \lambda, \mathrm{wt}(x_u,x_{u+1}) \rangle.\]

      For more information, see [LNSSS2013].

      Note

      In the dual-of-untwisted case the parabolic quantum Bruhat graph that is used is obtained by exchanging the roles of roots and coroots. Moreover, in the computation of the pairing the short roots must be doubled (or tripled for type \(G\)). This factor is determined by the translation factor of the corresponding root. Type \(BC\) is viewed as untwisted type, whereas the dual of \(BC\) is viewed as twisted. Except for the untwisted cases, these formulas are currently still conjectural.

      EXAMPLES:

      Sage

          sage: R = RootSystem(['C',3,1])
          sage: La = R.weight_space().basis()
          sage: LS = crystals.ProjectedLevelZeroLSPaths(La[1]+La[3])
          sage: b = LS.module_generators[0]
          sage: c = b.f(1).f(3).f(2)
          sage: c.energy_function()
          0
          sage: c=b.e(0)
          sage: c.energy_function()
          1

          sage: R = RootSystem(['A',2,1])
          sage: La = R.weight_space().basis()
          sage: LS = crystals.ProjectedLevelZeroLSPaths(2*La[1])
          sage: b = LS.module_generators[0]
          sage: c = b.e(0)
          sage: c.energy_function()
          1
          sage: for c in sorted(LS, key=str):
          ....:     print("{} {}".format(c,c.energy_function()))
          (-2*Lambda[0] + 2*Lambda[1],)                    0
          (-2*Lambda[1] + 2*Lambda[2],)                    0
          (-Lambda[0] + Lambda[1], -Lambda[1] + Lambda[2]) 1
          (-Lambda[0] + Lambda[1], Lambda[0] - Lambda[2])  1
          (-Lambda[1] + Lambda[2], -Lambda[0] + Lambda[1]) 0
          (-Lambda[1] + Lambda[2], Lambda[0] - Lambda[2])  1
          (2*Lambda[0] - 2*Lambda[2],)                     0
          (Lambda[0] - Lambda[2], -Lambda[0] + Lambda[1])  0
          (Lambda[0] - Lambda[2], -Lambda[1] + Lambda[2])  0

      Python

          >>> from sage.all import *
          >>> R = RootSystem(['C',Integer(3),Integer(1)])
          >>> La = R.weight_space().basis()
          >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(1)]+La[Integer(3)])
          >>> b = LS.module_generators[Integer(0)]
          >>> c = b.f(Integer(1)).f(Integer(3)).f(Integer(2))
          >>> c.energy_function()
          0
          >>> c=b.e(Integer(0))
          >>> c.energy_function()
          1

          >>> R = RootSystem(['A',Integer(2),Integer(1)])
          >>> La = R.weight_space().basis()
          >>> LS = crystals.ProjectedLevelZeroLSPaths(Integer(2)*La[Integer(1)])
          >>> b = LS.module_generators[Integer(0)]
          >>> c = b.e(Integer(0))
          >>> c.energy_function()
          1
          >>> for c in sorted(LS, key=str):
          ...     print("{} {}".format(c,c.energy_function()))
          (-2*Lambda[0] + 2*Lambda[1],)                    0
          (-2*Lambda[1] + 2*Lambda[2],)                    0
          (-Lambda[0] + Lambda[1], -Lambda[1] + Lambda[2]) 1
          (-Lambda[0] + Lambda[1], Lambda[0] - Lambda[2])  1
          (-Lambda[1] + Lambda[2], -Lambda[0] + Lambda[1]) 0
          (-Lambda[1] + Lambda[2], Lambda[0] - Lambda[2])  1
          (2*Lambda[0] - 2*Lambda[2],)                     0
          (Lambda[0] - Lambda[2], -Lambda[0] + Lambda[1])  0
          (Lambda[0] - Lambda[2], -Lambda[1] + Lambda[2])  0

      The next test checks that the energy function is constant on classically connected components:

      Sage

          sage: R = RootSystem(['A',2,1])
          sage: La = R.weight_space().basis()
          sage: LS = crystals.ProjectedLevelZeroLSPaths(2*La[1]+La[2])
          sage: G = LS.digraph(index_set=[1,2])
          sage: C = G.connected_components(sort=False)
          sage: [all(c[0].energy_function()==a.energy_function() for a in c) for c in C]
          [True, True, True, True]

          sage: R = RootSystem(['D',4,2])
          sage: La = R.weight_space().basis()
          sage: LS = crystals.ProjectedLevelZeroLSPaths(La[2])
          sage: J = R.cartan_type().classical().index_set()
          sage: hw = [x for x in LS if x.is_highest_weight(J)]
          sage: [(x.weight(), x.energy_function()) for x in hw]
          [(-2*Lambda[0] + Lambda[2], 0), (-2*Lambda[0] + Lambda[1], 1), (0, 2)]
          sage: G = LS.digraph(index_set=J)
          sage: C = G.connected_components(sort=False)
          sage: [all(c[0].energy_function()==a.energy_function() for a in c) for c in C]
          [True, True, True]

          sage: R = RootSystem(CartanType(['G',2,1]).dual())
          sage: La = R.weight_space().basis()
          sage: LS = crystals.ProjectedLevelZeroLSPaths(La[1]+La[2])
          sage: G = LS.digraph(index_set=[1,2])
          sage: C = G.connected_components(sort=False)
          sage: [all(c[0].energy_function()==a.energy_function() for a in c) for c in C] # long time
          [True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]

          sage: ct = CartanType(['BC',2,2]).dual()
          sage: R = RootSystem(ct)
          sage: La = R.weight_space().basis()
          sage: LS = crystals.ProjectedLevelZeroLSPaths(2*La[1]+La[2])
          sage: G = LS.digraph(index_set=R.cartan_type().classical().index_set())
          sage: C = G.connected_components(sort=False)
          sage: [all(c[0].energy_function()==a.energy_function() for a in c) for c in C] # long time
          [True, True, True, True, True, True, True, True, True, True, True]

          sage: R = RootSystem(['BC',2,2])
          sage: La = R.weight_space().basis()
          sage: LS = crystals.ProjectedLevelZeroLSPaths(2*La[1]+La[2])
          sage: G = LS.digraph(index_set=R.cartan_type().classical().index_set())
          sage: C = G.connected_components(sort=False)
          sage: [all(c[0].energy_function()==a.energy_function() for a in c) for c in C] # long time
          [True, True, True, True, True, True, True, True, True, True, True, True, True, True, True,
          True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]

      [Python]

          >>> from sage.all import *
          >>> R = RootSystem(['A',Integer(2),Integer(1)])
          >>> La = R.weight_space().basis()
          >>> LS = crystals.ProjectedLevelZeroLSPaths(Integer(2)*La[Integer(1)]+La[Integer(2)])
          >>> G = LS.digraph(index_set=[Integer(1),Integer(2)])
          >>> C = G.connected_components(sort=False)
          >>> [all(c[Integer(0)].energy_function()==a.energy_function() for a in c) for c in C]
          [True, True, True, True]

          >>> R = RootSystem(['D',Integer(4),Integer(2)])
          >>> La = R.weight_space().basis()
          >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(2)])
          >>> J = R.cartan_type().classical().index_set()
          >>> hw = [x for x in LS if x.is_highest_weight(J)]
          >>> [(x.weight(), x.energy_function()) for x in hw]
          [(-2*Lambda[0] + Lambda[2], 0), (-2*Lambda[0] + Lambda[1], 1), (0, 2)]
          >>> G = LS.digraph(index_set=J)
          >>> C = G.connected_components(sort=False)
          >>> [all(c[Integer(0)].energy_function()==a.energy_function() for a in c) for c in C]
          [True, True, True]

          >>> R = RootSystem(CartanType(['G',Integer(2),Integer(1)]).dual())
          >>> La = R.weight_space().basis()
          >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(1)]+La[Integer(2)])
          >>> G = LS.digraph(index_set=[Integer(1),Integer(2)])
          >>> C = G.connected_components(sort=False)
          >>> [all(c[Integer(0)].energy_function()==a.energy_function() for a in c) for c in C] # long time
          [True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]

          >>> ct = CartanType(['BC',Integer(2),Integer(2)]).dual()
          >>> R = RootSystem(ct)
          >>> La = R.weight_space().basis()
          >>> LS = crystals.ProjectedLevelZeroLSPaths(Integer(2)*La[Integer(1)]+La[Integer(2)])
          >>> G = LS.digraph(index_set=R.cartan_type().classical().index_set())
          >>> C = G.connected_components(sort=False)
          >>> [all(c[Integer(0)].energy_function()==a.energy_function() for a in c) for c in C] # long time
          [True, True, True, True, True, True, True, True, True, True, True]

          >>> R = RootSystem(['BC',Integer(2),Integer(2)])
          >>> La = R.weight_space().basis()
          >>> LS = crystals.ProjectedLevelZeroLSPaths(Integer(2)*La[Integer(1)]+La[Integer(2)])
          >>> G = LS.digraph(index_set=R.cartan_type().classical().index_set())
          >>> C = G.connected_components(sort=False)
          >>> [all(c[Integer(0)].energy_function()==a.energy_function() for a in c) for c in C] # long time
          [True, True, True, True, True, True, True, True, True, True, True, True, True, True, True,
          True, True, True, True, True, True, True, True, True, True, True, True, True, True, True, True]

    scalar_factors()

      Return the scalar factors for `self`.

      Each LS path (or `self`) can be written as a piecewise linear map

      \[\pi(t) = \sum_{u'=1}^{u-1} (\sigma_{u'} - \sigma_{u'-1}) \nu_{u'} + (t-\sigma_{u-1}) \nu_{u}\]

      for \(0 < \sigma_1 < \sigma_2 < \cdots < \sigma_s=1\) and \(\sigma_{u-1} \le t \le \sigma_{u}\) and \(1 \le u \le s\). This method returns the tuple of \((\sigma_1,\ldots,\sigma_s)\).

      EXAMPLES:

      Sage

          sage: R = RootSystem(['C',3,1])
          sage: La = R.weight_space().basis()
          sage: LS = crystals.ProjectedLevelZeroLSPaths(La[1]+La[3])
          sage: b = LS.module_generators[0]
          sage: b.scalar_factors()
          [1]
          sage: c = b.f(1).f(3).f(2)
          sage: c.scalar_factors()
          [1/3, 1]

      Python

          >>> from sage.all import *
          >>> R = RootSystem(['C',Integer(3),Integer(1)])
          >>> La = R.weight_space().basis()
          >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(1)]+La[Integer(3)])
          >>> b = LS.module_generators[Integer(0)]
          >>> b.scalar_factors()
          [1]
          >>> c = b.f(Integer(1)).f(Integer(3)).f(Integer(2))
          >>> c.scalar_factors()
          [1/3, 1]

    weyl_group_representation()

      Transform the weights in the LS path `self` to elements in the Weyl group.

      Each LS path can be written as the piecewise linear map:

      \[\pi(t) = \sum_{u'=1}^{u-1} (\sigma_{u'} - \sigma_{u'-1}) \nu_{u'} + (t-\sigma_{u-1}) \nu_{u}\]

      for \(0 < \sigma_1 < \sigma_2 < \cdots < \sigma_s = 1\) and \(\sigma_{u-1} \le t \le \sigma_{u}\) and \(1 \le u \le s\). Each weight \(\nu_u\) is also associated to a Weyl group element. This method returns the list of Weyl group elements associated to the \(\nu_u\) for \(1\le u\le s\).

      EXAMPLES:

      Sage

          sage: R = RootSystem(['C',3,1])
          sage: La = R.weight_space().basis()
          sage: LS = crystals.ProjectedLevelZeroLSPaths(La[1]+La[3])
          sage: b = LS.module_generators[0]
          sage: c = b.f(1).f(3).f(2)
          sage: c.weyl_group_representation()
          [s2*s1*s3, s1*s3]

      Python

          >>> from sage.all import *
          >>> R = RootSystem(['C',Integer(3),Integer(1)])
          >>> La = R.weight_space().basis()
          >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(1)]+La[Integer(3)])
          >>> b = LS.module_generators[Integer(0)]
          >>> c = b.f(Integer(1)).f(Integer(3)).f(Integer(2))
          >>> c.weyl_group_representation()
          [s2*s1*s3, s1*s3]

  classically_highest_weight_vectors()

    Return the classically highest weight vectors of `self`.

    EXAMPLES:

    Sage

        sage: R = RootSystem(['A',2,1])
        sage: La = R.weight_space().basis()
        sage: LS = crystals.ProjectedLevelZeroLSPaths(2*La[1])
        sage: LS.classically_highest_weight_vectors()
        ((-2*Lambda[0] + 2*Lambda[1],),
         (-Lambda[0] + Lambda[1], -Lambda[1] + Lambda[2]))

    Python

        >>> from sage.all import *
        >>> R = RootSystem(['A',Integer(2),Integer(1)])
        >>> La = R.weight_space().basis()
        >>> LS = crystals.ProjectedLevelZeroLSPaths(Integer(2)*La[Integer(1)])
        >>> LS.classically_highest_weight_vectors()
        ((-2*Lambda[0] + 2*Lambda[1],),
         (-Lambda[0] + Lambda[1], -Lambda[1] + Lambda[2]))

  is_perfect(level=1)

    Check whether the crystal `self` is perfect (of level `level`).

    INPUT:

    - `level` – (default: 1) positive integer

    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).

    EXAMPLES:

    Sage

        sage: C = CartanType(['C',2,1])
        sage: R = RootSystem(C)
        sage: La = R.weight_space().basis()
        sage: LS = crystals.ProjectedLevelZeroLSPaths(La[1])
        sage: LS.is_perfect()
        False
        sage: LS = crystals.ProjectedLevelZeroLSPaths(La[2])
        sage: LS.is_perfect()
        True

        sage: C = CartanType(['E',6,1])
        sage: R = RootSystem(C)
        sage: La = R.weight_space().basis()
        sage: LS = crystals.ProjectedLevelZeroLSPaths(La[1])
        sage: LS.is_perfect()
        True
        sage: LS.is_perfect(2)
        False

        sage: C = CartanType(['D',4,1])
        sage: R = RootSystem(C)
        sage: La = R.weight_space().basis()
        sage: all(crystals.ProjectedLevelZeroLSPaths(La[i]).is_perfect() for i in [1,2,3,4])
        True

        sage: C = CartanType(['A',6,2])
        sage: R = RootSystem(C)
        sage: La = R.weight_space().basis()
        sage: LS = crystals.ProjectedLevelZeroLSPaths(La[1]+La[2])
        sage: LS.is_perfect()
        True
        sage: LS.is_perfect(2)
        False

    Python

        >>> from sage.all import *
        >>> C = CartanType(['C',Integer(2),Integer(1)])
        >>> R = RootSystem(C)
        >>> La = R.weight_space().basis()
        >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(1)])
        >>> LS.is_perfect()
        False
        >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(2)])
        >>> LS.is_perfect()
        True

        >>> C = CartanType(['E',Integer(6),Integer(1)])
        >>> R = RootSystem(C)
        >>> La = R.weight_space().basis()
        >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(1)])
        >>> LS.is_perfect()
        True
        >>> LS.is_perfect(Integer(2))
        False

        >>> C = CartanType(['D',Integer(4),Integer(1)])
        >>> R = RootSystem(C)
        >>> La = R.weight_space().basis()
        >>> all(crystals.ProjectedLevelZeroLSPaths(La[i]).is_perfect() for i in [Integer(1),Integer(2),Integer(3),Integer(4)])
        True

        >>> C = CartanType(['A',Integer(6),Integer(2)])
        >>> R = RootSystem(C)
        >>> La = R.weight_space().basis()
        >>> LS = crystals.ProjectedLevelZeroLSPaths(La[Integer(1)]+La[Integer(2)])
        >>> LS.is_perfect()
        True
        >>> LS.is_perfect(Integer(2))
        False

  maximal_vector()

    Return the maximal vector of `self`.

    EXAMPLES:

    Sage

        sage: R = RootSystem(['A',2,1])
        sage: La = R.weight_space().basis()
        sage: LS = crystals.ProjectedLevelZeroLSPaths(2*La[1]+La[2])
        sage: LS.maximal_vector()
        (-3*Lambda[0] + 2*Lambda[1] + Lambda[2],)

    Python

        >>> from sage.all import *
        >>> R = RootSystem(['A',Integer(2),Integer(1)])
        >>> La = R.weight_space().basis()
        >>> LS = crystals.ProjectedLevelZeroLSPaths(Integer(2)*La[Integer(1)]+La[Integer(2)])
        >>> LS.maximal_vector()
        (-3*Lambda[0] + 2*Lambda[1] + Lambda[2],)

  one_dimensional_configuration_sum(q=None, group_components=True)

    Compute the one-dimensional configuration sum.

    INPUT:

    - `q` – (default: `None`) a variable or `None`; if `None`, a variable `q` is set in the code

    - `group_components` – boolean (default: `True`); 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. For untwisted types it uses the parabolic quantum Bruhat graph, see [LNSSS2013]. In the dual-of-untwisted case, the parabolic quantum Bruhat graph is defined by exchanging the roles of roots and coroots (which is still conjectural at this point).

    EXAMPLES:

    Sage

        sage: R = RootSystem(['A',2,1])
        sage: La = R.weight_space().basis()
        sage: LS = crystals.ProjectedLevelZeroLSPaths(2*La[1])
        sage: LS.one_dimensional_configuration_sum() # long time
        B[-2*Lambda[1] + 2*Lambda[2]] + (q+1)*B[-Lambda[1]]
         + (q+1)*B[Lambda[1] - Lambda[2]] + B[2*Lambda[1]]
         + B[-2*Lambda[2]] + (q+1)*B[Lambda[2]]
        sage: R.<t> = ZZ[]
        sage: LS.one_dimensional_configuration_sum(t, False) # long time
        B[-2*Lambda[1] + 2*Lambda[2]] + (t+1)*B[-Lambda[1]]
         + (t+1)*B[Lambda[1] - Lambda[2]] + B[2*Lambda[1]]
         + B[-2*Lambda[2]] + (t+1)*B[Lambda[2]]

    Python

        >>> from sage.all import *
        >>> R = RootSystem(['A',Integer(2),Integer(1)])
        >>> La = R.weight_space().basis()
        >>> LS = crystals.ProjectedLevelZeroLSPaths(Integer(2)*La[Integer(1)])
        >>> LS.one_dimensional_configuration_sum() # long time
        B[-2*Lambda[1] + 2*Lambda[2]] + (q+1)*B[-Lambda[1]]
         + (q+1)*B[Lambda[1] - Lambda[2]] + B[2*Lambda[1]]
         + B[-2*Lambda[2]] + (q+1)*B[Lambda[2]]
        >>> R = ZZ['t']; (t,) = R._first_ngens(1)
        >>> LS.one_dimensional_configuration_sum(t, False) # long time
        B[-2*Lambda[1] + 2*Lambda[2]] + (t+1)*B[-Lambda[1]]
         + (t+1)*B[Lambda[1] - Lambda[2]] + B[2*Lambda[1]]
         + B[-2*Lambda[2]] + (t+1)*B[Lambda[2]]

class sage.combinat.crystals.littelmann_path.InfinityCrystalOfLSPaths(cartan_type)

  Bases: `UniqueRepresentation`, `Parent`

  LS path model for \(\mathcal{B}(\infty)\).

  Elements of \(\mathcal{B}(\infty)\) are equivalence classes of paths \([\pi]\) in \(\mathcal{B}(k\rho)\) for \(k\gg 0\), where \(\rho\) is the Weyl vector. A canonical representative for an element of \(\mathcal{B}(\infty)\) is chosen by taking \(k\) to be minimal such that the endpoint of \(\pi\) is strictly dominant but its representative in \(\mathcal{B}((k-1)\rho)\) is on the wall of the dominant chamber.

  REFERENCES:

  - [LZ2011]

  class Element

    Bases: `Element`

    e(i, power=1, length_only=False)

      Return the \(i\)-th crystal raising operator on `self`.

      INPUT:

      - `i` – element of the index set

      - `power` – (default: 1) positive integer; specifies the power of the lowering operator to be applied

      - `length_only` – boolean (default: `False`); if `True`, then return the distance to the anti-dominant end of the \(i\)-string of `self`

      EXAMPLES:

      Sage

          sage: B = crystals.infinity.LSPaths(['B',3,1])
          sage: mg = B.module_generator()
          sage: mg.e(0)
          sage: mg.e(1)
          sage: mg.e(2)
          sage: x = mg.f_string([1,0,2,1,0,2,1,1,0])
          sage: all(x.f(i).e(i) == x for i in B.index_set())
          True
          sage: all(x.e(i).f(i) == x for i in B.index_set() if x.epsilon(i) > 0)
          True

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.LSPaths(['B',Integer(3),Integer(1)])
          >>> mg = B.module_generator()
          >>> mg.e(Integer(0))
          >>> mg.e(Integer(1))
          >>> mg.e(Integer(2))
          >>> x = mg.f_string([Integer(1),Integer(0),Integer(2),Integer(1),Integer(0),Integer(2),Integer(1),Integer(1),Integer(0)])
          >>> all(x.f(i).e(i) == x for i in B.index_set())
          True
          >>> all(x.e(i).f(i) == x for i in B.index_set() if x.epsilon(i) > Integer(0))
          True

    f(i, power=1, length_only=False)

      Return the \(i\)-th crystal lowering operator on `self`.

      INPUT:

      - `i` – element of the index set

      - `power` – (default: 1) positive integer; specifies the power of the lowering operator to be applied

      - `length_only` – boolean (default: `False`); if `True`, then return the distance to the anti-dominant end of the \(i\)-string of `self`

      EXAMPLES:

      Sage

          sage: B = crystals.infinity.LSPaths(['D',3,2])
          sage: mg = B.highest_weight_vector()
          sage: mg.f(1)
          (3*Lambda[0] - Lambda[1] + 3*Lambda[2],
           2*Lambda[0] + 2*Lambda[1] + 2*Lambda[2])
          sage: mg.f(2)
          (Lambda[0] + 2*Lambda[1] - Lambda[2],
           2*Lambda[0] + 2*Lambda[1] + 2*Lambda[2])
          sage: mg.f(0)
          (-Lambda[0] + 2*Lambda[1] + Lambda[2] - delta,
           2*Lambda[0] + 2*Lambda[1] + 2*Lambda[2])

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.LSPaths(['D',Integer(3),Integer(2)])
          >>> mg = B.highest_weight_vector()
          >>> mg.f(Integer(1))
          (3*Lambda[0] - Lambda[1] + 3*Lambda[2],
           2*Lambda[0] + 2*Lambda[1] + 2*Lambda[2])
          >>> mg.f(Integer(2))
          (Lambda[0] + 2*Lambda[1] - Lambda[2],
           2*Lambda[0] + 2*Lambda[1] + 2*Lambda[2])
          >>> mg.f(Integer(0))
          (-Lambda[0] + 2*Lambda[1] + Lambda[2] - delta,
           2*Lambda[0] + 2*Lambda[1] + 2*Lambda[2])

    phi(i)

      Return \(\varphi_i\) of `self`.

      Let \(\pi \in \mathcal{B}(\infty)\). Define

      \[\varphi_i(\pi) := \varepsilon_i(\pi) + \langle h_i, \mathrm{wt}(\pi) \rangle,\]

      where \(h_i\) is the \(i\)-th simple coroot and \(\mathrm{wt}(\pi)\) is the `weight()` of \(\pi\).

      INPUT:

      - `i` – element of the index set

      EXAMPLES:

      Sage

          sage: B = crystals.infinity.LSPaths(['D',4])
          sage: mg = B.highest_weight_vector()
          sage: x = mg.f_string([1,3,4,2,4,3,2,1,4])
          sage: [x.phi(i) for i in B.index_set()]
          [-1, 4, -2, -3]

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.LSPaths(['D',Integer(4)])
          >>> mg = B.highest_weight_vector()
          >>> x = mg.f_string([Integer(1),Integer(3),Integer(4),Integer(2),Integer(4),Integer(3),Integer(2),Integer(1),Integer(4)])
          >>> [x.phi(i) for i in B.index_set()]
          [-1, 4, -2, -3]

    weight()

      Return the weight of `self`.

      Todo

      This is a generic algorithm. We should find a better description and implement it.

      EXAMPLES:

      Sage

          sage: B = crystals.infinity.LSPaths(['E',6])
          sage: mg = B.highest_weight_vector()
          sage: f_seq = [1,4,2,6,4,2,3,1,5,5]
          sage: x = mg.f_string(f_seq)
          sage: x.weight()
          -3*Lambda[1] - 2*Lambda[2] + 2*Lambda[3] + Lambda[4] - Lambda[5]

          sage: al = B.cartan_type().root_system().weight_space().simple_roots()
          sage: x.weight() == -sum(al[i] for i in f_seq)
          True

      Python

          >>> from sage.all import *
          >>> B = crystals.infinity.LSPaths(['E',Integer(6)])
          >>> mg = B.highest_weight_vector()
          >>> f_seq = [Integer(1),Integer(4),Integer(2),Integer(6),Integer(4),Integer(2),Integer(3),Integer(1),Integer(5),Integer(5)]
          >>> x = mg.f_string(f_seq)
          >>> x.weight()
          -3*Lambda[1] - 2*Lambda[2] + 2*Lambda[3] + Lambda[4] - Lambda[5]

          >>> al = B.cartan_type().root_system().weight_space().simple_roots()
          >>> x.weight() == -sum(al[i] for i in f_seq)
          True

  module_generator()

    Return the module generator (or highest weight element) of `self`.

    The module generator is the unique path \(\pi_\infty\colon t \mapsto t\rho\), for \(t \in [0,\infty)\).

    EXAMPLES:

    Sage

        sage: B = crystals.infinity.LSPaths(['A',6,2])
        sage: mg = B.module_generator(); mg
        (Lambda[0] + Lambda[1] + Lambda[2] + Lambda[3],)
        sage: mg.weight()
        0

    Python

        >>> from sage.all import *
        >>> B = crystals.infinity.LSPaths(['A',Integer(6),Integer(2)])
        >>> mg = B.module_generator(); mg
        (Lambda[0] + Lambda[1] + Lambda[2] + Lambda[3],)
        >>> mg.weight()
        0

  weight_lattice_realization()

    Return the weight lattice realization of `self`.

    EXAMPLES:

    Sage

        sage: B = crystals.infinity.LSPaths(['C',4])
        sage: B.weight_lattice_realization()
        Weight space over the Rational Field of the Root system of type ['C', 4]

    Python

        >>> from sage.all import *
        >>> B = crystals.infinity.LSPaths(['C',Integer(4)])
        >>> B.weight_lattice_realization()
        Weight space over the Rational Field of the Root system of type ['C', 4]

sage.combinat.crystals.littelmann_path.positively_parallel_weights(v, w)

  Check whether the vectors `v` and `w` are positive scalar multiples of each other.

  EXAMPLES:

  Sage

      sage: from sage.combinat.crystals.littelmann_path import positively_parallel_weights
      sage: La = RootSystem(['A',5,2]).weight_space(extended=True).fundamental_weights()
      sage: rho = sum(La)
      sage: positively_parallel_weights(rho, 4*rho)
      True
      sage: positively_parallel_weights(4*rho, rho)
      True
      sage: positively_parallel_weights(rho, -rho)
      False
      sage: positively_parallel_weights(rho, La[1] + La[2])
      False

  Python

      >>> from sage.all import *
      >>> from sage.combinat.crystals.littelmann_path import positively_parallel_weights
      >>> La = RootSystem(['A',Integer(5),Integer(2)]).weight_space(extended=True).fundamental_weights()
      >>> rho = sum(La)
      >>> positively_parallel_weights(rho, Integer(4)*rho)
      True
      >>> positively_parallel_weights(Integer(4)*rho, rho)
      True
      >>> positively_parallel_weights(rho, -rho)
      False
      >>> positively_parallel_weights(rho, La[Integer(1)] + La[Integer(2)])
      False