Ticket #14686: trac_14686-crystals_speedup_functions-ts.patch

File trac_14686-crystals_speedup_functions-ts.patch, 112.0 KB (added by tscrim, 8 years ago)
  • sage/categories/crystals.py

    # HG changeset patch
    # User Travis Scrimshaw <tscrim@ucdavis.edur>
    # Date 1370443831 25200
    # Node ID 0892d08a377cc97ef61c6db7ef99a45ba2a600d7
    # Parent 675a8a107501d4753ef414bca4feb2d217305872
    #14686: More crystals speedups by changing basic crystal functions.
    
    diff --git a/sage/categories/crystals.py b/sage/categories/crystals.py
    a b class Crystals(Category_singleton): 
    4242
    4343    Furthermore, their elements should implement the following methods:
    4444
    45     - ``x.e(i)`` (returning `e_i(x)`)
     45    - ``x._e(i)`` (returning `e_i(x)`)
    4646
    47     - ``x.f(i)`` (returning `f_i(x)`)
     47    - ``x._f(i)`` (returning `f_i(x)`)
    4848
    49     - ``x.epsilon(i)`` (returning `\varepsilon_i(x)`)
     49    - ``x._epsilon(i)`` (returning `\varepsilon_i(x)`)
    5050
    51     - ``x.phi(i)`` (returning `\varphi_i(x)`)
     51    - ``x._phi(i)`` (returning `\varphi_i(x)`)
     52
     53    Each of these methods can assume that `i` is in the index set.
    5254
    5355    EXAMPLES::
    5456
    5557        sage: from sage.misc.abstract_method import abstract_methods_of_class
    5658        sage: abstract_methods_of_class(Crystals().element_class)
    57         {'required': ['e', 'epsilon', 'f', 'phi', 'weight'], 'optional': []}
     59        {'required': ['_e', '_epsilon', '_f', '_phi', 'weight'], 'optional': []}
    5860
    5961    TESTS::
    6062
    class Crystals(Category_singleton): 
    256258                index_set = self.index_set()
    257259            if max_depth < float('inf'):
    258260                from sage.combinat.backtrack import TransitiveIdealGraded
    259                 return TransitiveIdealGraded(lambda x: [x.f(i) for i in index_set]
    260                                                      + [x.e(i) for i in index_set],
     261                return TransitiveIdealGraded(lambda x: [x._f(i) for i in index_set]
     262                                                     + [x._e(i) for i in index_set],
    261263                                             self.module_generators, max_depth).__iter__()
    262264            from sage.combinat.backtrack import TransitiveIdeal
    263             return TransitiveIdeal(lambda x: [x.f(i) for i in index_set]
    264                                            + [x.e(i) for i in index_set],
     265            return TransitiveIdeal(lambda x: [x._f(i) for i in index_set]
     266                                           + [x._e(i) for i in index_set],
    265267                                   self.module_generators).__iter__()
    266268
    267269        def subcrystal(self, index_set=None, generators=None, max_depth=float("inf"),
    class Crystals(Category_singleton): 
    312314            from sage.combinat.backtrack import TransitiveIdealGraded
    313315
    314316            if direction == 'both':
    315                 return TransitiveIdealGraded(lambda x: [x.f(i) for i in index_set]
    316                                                      + [x.e(i) for i in index_set],
     317                return TransitiveIdealGraded(lambda x: [x._f(i) for i in index_set]
     318                                                     + [x._e(i) for i in index_set],
    317319                                             generators, max_depth)
    318320            if direction == 'upper':
    319                 return TransitiveIdealGraded(lambda x: [x.e(i) for i in index_set],
     321                return TransitiveIdealGraded(lambda x: [x._e(i) for i in index_set],
    320322                                             generators, max_depth)
    321323            if direction == 'lower':
    322                 return TransitiveIdealGraded(lambda x: [x.f(i) for i in index_set],
     324                return TransitiveIdealGraded(lambda x: [x._f(i) for i in index_set],
    323325                                             generators, max_depth)
    324326            raise ValueError("direction must be either 'both', 'upper', or 'lower'")
    325327
    class Crystals(Category_singleton): 
    562564            for x in subset:
    563565                d[x] = {}
    564566                for i in index_set:
    565                     child = x.f(i)
     567                    child = x._f(i)
    566568                    if child is None or child not in subset:
    567569                        continue
    568570                    d[x][child]=i
    class Crystals(Category_singleton): 
    797799                result += "  " + vertex_key(x) + " [ label = \" \", texlbl = \"$"+quoted_latex(x)+"$\" ];\n"
    798800            for x in self:
    799801                for i in self.index_set():
    800                     child = x.f(i)
     802                    child = x._f(i)
    801803                    if child is None:
    802804                        continue
    803805    #                result += "  " + vertex_key(x) + " -> "+vertex_key(child)+ " [ label = \" \", texlbl = \""+quoted_latex(i)+"\" ];\n"
    class Crystals(Category_singleton): 
    863865            """
    864866            return self.parent().cartan_type()
    865867
    866         @abstract_method
    867868        def e(self, i):
    868869            r"""
    869             Returns `e_i(x)` if it exists or ``None`` otherwise.
     870            Return `e_i(x)` if it exists or ``None`` otherwise.
     871
     872            EXAMPLES::
     873
     874                sage: C = Crystals().example(5)
     875                sage: x = C[2]; x
     876                3
     877                sage: x.e(1), x.e(2), x.e(3)
     878                (None, 2, None)
     879            """
     880            if i not in self.index_set():
     881                raise ValueError("%s is not in the index set"%i)
     882            return self._e(i)
     883
     884        def f(self, i):
     885            r"""
     886            Return `f_i(x)` if it exists or ``None`` otherwise.
     887
     888            EXAMPLES::
     889
     890                sage: C = Crystals().example(5)
     891                sage: x = C[1]; x
     892                2
     893                sage: x.f(1), x.f(2), x.f(3)
     894                (None, 3, None)
     895            """
     896            if i not in self.index_set():
     897                raise ValueError("%s is not in the index set"%i)
     898            return self._f(i)
     899
     900        def epsilon(self, i):
     901            r"""
     902            Return `\varepsilon_i` of ``self``.
     903
     904            EXAMPLES::
     905
     906                sage: C = CrystalOfLetters(['A',5])
     907                sage: C(1).epsilon(1)
     908                0
     909                sage: C(2).epsilon(1)
     910                1
     911            """
     912            if i not in self.index_set():
     913                raise ValueError("%s is not in the index set"%i)
     914            return self._epsilon(i)
     915
     916        def phi(self, i):
     917            r"""
     918            Return `\varphi_i` of ``self``.
     919
     920            EXAMPLES::
     921
     922                sage: C = CrystalOfLetters(['A',5])
     923                sage: C(1).phi(1)
     924                1
     925                sage: C(2).phi(1)
     926                0
     927            """
     928            if i not in self.index_set():
     929                raise ValueError("%s is not in the index set"%i)
     930            return self._phi(i)
     931
     932        @abstract_method
     933        def _e(self, i):
     934            r"""
     935            Return `e_i` of ``self`` if it exists or ``None`` otherwise with
     936            no safety check that ``i`` is in the index set.
    870937
    871938            This method should be implemented by the element class of
    872939            the crystal.
    class Crystals(Category_singleton): 
    876943                sage: C = Crystals().example(5)
    877944                sage: x = C[2]; x
    878945                3
    879                 sage: x.e(1), x.e(2), x.e(3)
     946                sage: x._e(1), x._e(2), x._e(3)
    880947                (None, 2, None)
    881948            """
    882949
    883950        @abstract_method
    884         def f(self, i):
     951        def _f(self, i):
    885952            r"""
    886             Returns `f_i(x)` if it exists or ``None`` otherwise.
     953            Return `f_i` of ``self`` if it exists or ``None`` otherwise with
     954            no safety check that ``i`` is in the index set.
    887955
    888956            This method should be implemented by the element class of
    889957            the crystal.
    class Crystals(Category_singleton): 
    893961                sage: C = Crystals().example(5)
    894962                sage: x = C[1]; x
    895963                2
    896                 sage: x.f(1), x.f(2), x.f(3)
     964                sage: x._f(1), x._f(2), x._f(3)
    897965                (None, 3, None)
    898966            """
    899967
    900968        @abstract_method
    901         def epsilon(self, i):
     969        def _epsilon(self, i):
    902970            r"""
     971            Return `\varepsilon_i` of ``self`` otherwise with no safety check
     972            that ``i`` is in the index set.
     973
     974            This method should be implemented by the element class of
     975            the crystal.
     976
    903977            EXAMPLES::
    904978
    905979                sage: C = CrystalOfLetters(['A',5])
    906                 sage: C(1).epsilon(1)
     980                sage: C(1)._epsilon(1)
    907981                0
    908                 sage: C(2).epsilon(1)
     982                sage: C(2)._epsilon(1)
    909983                1
    910984            """
    911985
    912986        @abstract_method
    913         def phi(self, i):
     987        def _phi(self, i):
    914988            r"""
     989            Return `\varphi_i` of ``self`` otherwise with no safety check
     990            that ``i`` is in the index set.
     991
     992            This method should be implemented by the element class of
     993            the crystal.
     994
    915995            EXAMPLES::
    916996
    917997                sage: C = CrystalOfLetters(['A',5])
    918                 sage: C(1).phi(1)
     998                sage: C(1)._phi(1)
    919999                1
    920                 sage: C(2).phi(1)
     1000                sage: C(2)._phi(1)
    9211001                0
    9221002            """
    9231003
    class Crystals(Category_singleton): 
    9631043                (1, 0, 0, 0, 0, 0)
    9641044            """
    9651045            Lambda = self.parent().Lambda()
    966             return sum(self.epsilon(i) * Lambda[i] for i in self.index_set())
     1046            return sum(self._epsilon(i) * Lambda[i] for i in self.index_set())
    9671047
    9681048        def Phi(self):
    9691049            """
    class Crystals(Category_singleton): 
    9781058                (1, 1, 0, 0, 0, 0)
    9791059            """
    9801060            Lambda = self.parent().Lambda()
    981             return sum(self.phi(i) * Lambda[i] for i in self.index_set())
     1061            return sum(self._phi(i) * Lambda[i] for i in self.index_set())
    9821062
    9831063        def f_string(self, list):
    9841064            r"""
    985             Applies `f_{i_r} ... f_{i_1}` to self for `list = [i_1, ..., i_r]`
     1065            Apply `f_{i_r} \cdots f_{i_1}` to ``self`` for
     1066            ``lst`` as `[i_1, \ldots, i_r]`.
    9861067
    9871068            EXAMPLES::
    9881069
    class Crystals(Category_singleton): 
    10011082
    10021083        def e_string(self, list):
    10031084            r"""
    1004             Applies `e_{i_r} ... e_{i_1}` to self for `list = [i_1, ..., i_r]`
     1085            Applies `e_{i_r} \cdots e_{i_1}` to ``self`` for
     1086            ``lst`` as `[i_1, \ldots, i_r]`.
    10051087
    10061088            EXAMPLES::
    10071089
    class Crystals(Category_singleton): 
    10181100                    return None
    10191101            return b
    10201102
     1103        def _f_string(self, lst):
     1104            r"""
     1105            Apply `f_{i_r} \cdots f_{i_1}` to ``self`` for
     1106            ``lst`` as `[i_1, \ldots, i_r]`. Assumes that all indices are in
     1107            the index set.
     1108
     1109            EXAMPLES::
     1110
     1111                sage: C = CrystalOfLetters(['A',3])
     1112                sage: b = C(1)
     1113                sage: b._f_string([1,2])
     1114                3
     1115                sage: b._f_string([2,1])
     1116            """
     1117            b = self
     1118            for i in lst:
     1119                b = b._f(i)
     1120                if b is None:
     1121                    return None
     1122            return b
     1123
     1124        def _e_string(self, lst):
     1125            r"""
     1126            Apply `e_{i_r} \cdots e_{i_1}` to ``self`` for
     1127            ``lst`` as `[i_1, \ldots, i_r]`. Assumes that all indices are in
     1128            the index set.
     1129
     1130            EXAMPLES::
     1131
     1132                sage: C = CrystalOfLetters(['A',3])
     1133                sage: b = C(3)
     1134                sage: b._e_string([2,1])
     1135                1
     1136                sage: b._e_string([1,2])
     1137            """
     1138            b = self
     1139            for i in lst:
     1140                b = b._e(i)
     1141                if b is None:
     1142                    return None
     1143            return b
     1144
    10211145        def s(self, i):
    10221146            r"""
    10231147            Returns the reflection of ``self`` along its `i`-string
    class Crystals(Category_singleton): 
    10401164            b = self
    10411165            if d > 0:
    10421166                for j in range(d):
    1043                     b = b.f(i)
     1167                    b = b._f(i)
    10441168            else:
    10451169                for j in range(-d):
    1046                     b = b.e(i)
     1170                    b = b._e(i)
    10471171            return b
    10481172
    10491173        def is_highest_weight(self, index_set = None):
    class Crystals(Category_singleton): 
    10651189            """
    10661190            if index_set is None:
    10671191                index_set = self.index_set()
    1068             return all(self.e(i) is None for i in index_set)
     1192            return all(self._e(i) is None for i in index_set)
    10691193
    10701194        def is_lowest_weight(self, index_set = None):
    10711195            r"""
    class Crystals(Category_singleton): 
    10861210            """
    10871211            if index_set is None:
    10881212                index_set = self.index_set()
    1089             return all(self.f(i) is None for i in index_set)
     1213            return all(self._f(i) is None for i in index_set)
    10901214
    10911215        def to_highest_weight(self, index_set = None):
    10921216            r"""
  • sage/categories/examples/crystals.py

    diff --git a/sage/categories/examples/crystals.py b/sage/categories/examples/crystals.py
    a b class HighestWeightCrystalOfTypeA(Unique 
    8181    Only the following basic operations are implemented:
    8282     - :meth:`~sage.categories.crystals.Crystals.cartan_type` or an attribute _cartan_type
    8383     - an attribute module_generators
    84      - :meth:`.Element.e`
    85      - :meth:`.Element.f`
     84     - :meth:`.Element._e`
     85     - :meth:`.Element._f`
    8686
    8787    All the other usual crystal operations are inherited from the
    8888    categories; for example::
    class HighestWeightCrystalOfTypeA(Unique 
    118118
    119119    class Element(ElementWrapper):
    120120
    121         def e(self, i):
     121        def _e(self, i):
    122122            r"""
    123             Returns the action of `e_i` on ``self``.
     123            Return the action of `e_i` on ``self``.
    124124
    125125            EXAMPLES::
    126126
    127127                sage: C = Crystals().example(4)
    128                 sage: [[c,i,c.e(i)] for i in C.index_set() for c in C if c.e(i) is not None]
     128                sage: [[c,i,c._e(i)] for i in C.index_set() for c in C if c._e(i) is not None]
    129129                [[2, 1, 1], [3, 2, 2], [4, 3, 3], [5, 4, 4]]
    130130            """
    131             assert i in self.index_set()
    132131            if self.value == i+1:
    133132                return self.parent()(self.value-1)
    134133            else:
    135134                return None
    136135
    137         def f(self, i):
     136        def _f(self, i):
    138137            r"""
    139             Returns the action of `f_i` on ``self``.
     138            Return the action of `f_i` on ``self``.
    140139
    141140            EXAMPLES::
    142141
    143142                sage: C = Crystals().example(4)
    144                 sage: [[c,i,c.f(i)] for i in C.index_set() for c in C if c.f(i) is not None]
     143                sage: [[c,i,c._f(i)] for i in C.index_set() for c in C if c._f(i) is not None]
    145144                [[1, 1, 2], [2, 2, 3], [3, 3, 4], [4, 4, 5]]
    146145            """
    147             assert i in self.index_set()
    148146            if self.value == i:
    149147                return self.parent()(self.value+1)
    150148            else:
    class NaiveCrystal(UniqueRepresentation, 
    195193        return "A broken crystal, defined by digraph, of dimension five."
    196194       
    197195    class Element(ElementWrapper):
    198         def e(self, i):
     196        def _e(self, i):
    199197            r"""
    200             Returns the action of `e_i` on ``self``.
     198            Return the action of `e_i` on ``self``.
    201199
    202200            EXAMPLES::
    203201
    204202                sage: C = Crystals().example(choice='naive')
    205                 sage: [[c,i,c.e(i)] for i in C.index_set() for c in [C(j) for j in [0..5]] if c.e(i) is not None]
     203                sage: [[c,i,c._e(i)] for i in C.index_set() for c in [C(j) for j in [0..5]] if c._e(i) is not None]
    206204                [[1, 1, 0], [2, 1, 1], [3, 1, 2], [5, 1, 3], [4, 2, 0], [5, 2, 4]]
    207205            """
    208             assert i in self.index_set()
    209206            for edge in self.parent().G.edges():
    210207               if edge[1]==int(str(self)) and edge[2]==i:
    211208                   return self.parent()(edge[0])
    212209            return None
    213210           
    214         def f(self, i):
     211        def _f(self, i):
    215212            r"""
    216             Returns the action of `f_i` on ``self``.
     213            Return the action of `f_i` on ``self``.
    217214
    218215            EXAMPLES::
    219216
    220217                sage: C = Crystals().example(choice='naive')
    221                 sage: [[c,i,c.f(i)] for i in C.index_set() for c in [C(j) for j in [0..5]] if c.f(i) is not None]
     218                sage: [[c,i,c._f(i)] for i in C.index_set() for c in [C(j) for j in [0..5]] if c._f(i) is not None]
    222219                [[0, 1, 1], [1, 1, 2], [2, 1, 3], [3, 1, 5], [0, 2, 4], [4, 2, 5]]
    223220            """
    224             assert i in self.index_set()
    225221            for edge in self.parent().G.edges_incident(int(str(self))): 
    226222                if edge[2] == i:
    227223                    return self.parent()(edge[1])
  • sage/categories/regular_crystals.py

    diff --git a/sage/categories/regular_crystals.py b/sage/categories/regular_crystals.py
    a b class RegularCrystals(Category_singleton 
    208208
    209209    class ElementMethods:
    210210
    211         def epsilon(self, i):
     211        def _epsilon(self, i):
    212212            r"""
    213213            Return `\varepsilon_i` of ``self``.
    214214
    215215            EXAMPLES::
    216216
    217217                sage: C = CrystalOfLetters(['A',5])
    218                 sage: C(1).epsilon(1)
     218                sage: C(1)._epsilon(1)
    219219                0
    220                 sage: C(2).epsilon(1)
     220                sage: C(2)._epsilon(1)
    221221                1
    222222            """
    223             assert i in self.index_set()
    224             x = self.e(i)
     223            x = self._e(i)
    225224            eps = 0
    226225            while x is not None:
    227                 x = x.e(i)
     226                x = x._e(i)
    228227                eps = eps + 1
    229228            return eps
    230229
    231         def phi(self, i):
     230        def _phi(self, i):
    232231            r"""
    233232            Return `\varphi_i` of ``self``.
    234233
    235234            EXAMPLES::
    236235
    237236                sage: C = CrystalOfLetters(['A',5])
    238                 sage: C(1).phi(1)
     237                sage: C(1)._phi(1)
    239238                1
    240                 sage: C(2).phi(1)
     239                sage: C(2)._phi(1)
    241240                0
    242241            """
    243             assert i in self.index_set()
    244             x = self.f(i)
     242            x = self._f(i)
    245243            phi = 0
    246244            while x is not None:
    247                 x = x.f(i)
     245                x = x._f(i)
    248246                phi = phi + 1
    249247            return phi
    250248
    class RegularCrystals(Category_singleton 
    318316                sage: x.demazure_operator_simple(0, ring = QQ).parent()
    319317                Free module generated by Kirillov-Reshetikhin crystal of type ['A', 2, 1] with (r,s)=(1,1) over Rational Field
    320318            """
     319            if i not in self.index_set():
     320                raise ValueError("%s is not in the index set"%i)
    321321            from sage.rings.integer_ring import ZZ
    322322            if ring is None:
    323323                ring = ZZ
    324324            C = self.parent().algebra(ring)
    325             r = self.phi(i) - self.epsilon(i)
     325            r = self._phi(i) - self._epsilon(i)
    326326            if r >= 0:
    327327                l = [self]
    328328                element = self
    329329                for k in range(r):
    330                     element = element.f(i)
     330                    element = element._f(i)
    331331                    l.append(element)
    332332                return C.sum_of_monomials(l)
    333333            else:
    334334                l = []
    335335                element = self
    336336                for k in range(-r-1):
    337                     element = element.e(i)
     337                    element = element._e(i)
    338338                    l.append(element)
    339339                return - C.sum_of_monomials(l)
    340340
    class RegularCrystals(Category_singleton 
    357357                sage: s.stembridgeDelta_depth(1,2)
    358358                -1
    359359            """
    360             if self.e(i) is None: return 0
     360            if self.e(i) is None:
     361                return 0
    361362            return -self.e(i).epsilon(j) + self.epsilon(j)
    362363
    363364        def stembridgeDelta_rise(self,i,j):
    class RegularCrystals(Category_singleton 
    379380                sage: s.stembridgeDelta_rise(1,2)
    380381                0
    381382            """
    382             if self.e(i) is None: return 0
     383            if self.e(i) is None:
     384                return 0
    383385            return self.e(i).phi(j) - self.phi(j)
    384386
    385387        def stembridgeDel_depth(self,i,j):
    class RegularCrystals(Category_singleton 
    401403                sage: s.stembridgeDel_depth(1,2)
    402404                -1
    403405            """
    404             if self.f(i) is None: return 0
     406            if self.f(i) is None:
     407                return 0
    405408            return -self.epsilon(j) + self.f(i).epsilon(j)
    406409
    407410        def stembridgeDel_rise(self,i,j):
    class RegularCrystals(Category_singleton 
    423426                sage: s.stembridgeDel_rise(1,2)
    424427                0
    425428            """
    426             if self.f(i) is None: return 0
     429            if self.f(i) is None:
     430                return 0
    427431            return self.phi(j)-self.f(i).phi(j)
    428432
    429433        def stembridgeTriple(self,i,j):
    class RegularCrystals(Category_singleton 
    458462                sage: u.stembridgeTriple(1,2)
    459463                (-2, -1, -1)
    460464            """
    461             if self.e(i) is None: return None
     465            if self.e(i) is None:
     466                return None
    462467            b=self.stembridgeDelta_depth(i,j)
    463468            c=self.stembridgeDelta_rise(i,j)
    464469            dd=self.cartan_type().dynkin_diagram()
    class RegularCrystals(Category_singleton 
    500505            """
    501506            tester = self._tester(**options)
    502507            goodness=True
    503             if index_set is None: index_set=self.index_set()
     508            if index_set is None:
     509                index_set=self.index_set()
    504510
    505511            for (i,j) in Subsets(index_set, 2):
    506                 if self.e(i) is not None and self.e(j) is not None:
     512                if self._e(i) is not None and self._e(j) is not None:
    507513                    triple=self.stembridgeTriple(i,j)
    508514                    #Test axioms P3 and P4.
    509515                    if not triple[0]==triple[1]+triple[2] or triple[1]>0 or triple[2]>0:
    class RegularCrystals(Category_singleton 
    514520                            tester.fail()
    515521                    if self.stembridgeDelta_depth(i,j)==0:
    516522                        #check E_i E_j(x)= E_j E_i(x)
    517                         if self.e(i).e(j)!=self.e(j).e(i) or self.e(i).e(j).stembridgeDel_rise(j, i)!=0:
     523                        if self._e(i)._e(j)!=self._e(j)._e(i) or self._e(i)._e(j).stembridgeDel_rise(j, i)!=0:
    518524                            if verbose:
    519525                                print 'Warning: Failed axiom P5 at: vector ', self, 'i,j=', i, j, 'Stembridge triple:', self.stembridgeTriple(i,j)
    520526                                goodness=False
    class RegularCrystals(Category_singleton 
    522528                                tester.fail()
    523529                    if self.stembridgeDelta_depth(i,j)==-1 and self.stembridgeDelta_depth(j,i)==-1:
    524530                        #check E_i E_j^2 E_i (x)= E_j E_i^2 E_j (x)
    525                         y1=self.e(j).e(i).e(i).e(j)
    526                         y2=self.e(j).e(i).e(i).e(j)
     531                        y1=self._e(j)._e(i)._e(i)._e(j)
     532                        y2=self._e(j)._e(i)._e(i)._e(j)
    527533                        a=y1.stembridgeDel_rise(j, i)
    528534                        b=y2.stembridgeDel_rise(i, j)
    529535                        if y1!=y2 or a!=-1 or b!=-1:
  • sage/combinat/crystals/affine.py

    diff --git a/sage/combinat/crystals/affine.py b/sage/combinat/crystals/affine.py
    a b class AffineCrystalFromClassicalElement( 
    325325        Assumes that `f_0` is implemented separately.
    326326        """
    327327
    328     def e(self, i):
     328    def _e(self, i):
    329329        r"""
    330         Returns the action of `e_i` on self.
     330        Return the action of `e_i` on ``self``.
    331331
    332332        EXAMPLES::
    333333
    class AffineCrystalFromClassicalElement( 
    337337            sage: pr_inverse = attrcall("promotion_inverse")
    338338            sage: A=AffineCrystalFromClassicalAndPromotion(['A',n,1],C,pr,pr_inverse,1)
    339339            sage: b=A(rows=[[1]])
    340             sage: b.e(0)
     340            sage: b._e(0)
    341341            [[3]]
    342             sage: b.e(1)
     342            sage: b._e(1)
    343343        """
    344344        if i == 0:
    345345            return self.e0()
    346346        else:
    347             x = self.lift().e(i)
     347            x = self.lift()._e(i)
    348348            if (x == None):
    349349                return None
    350350            else:
    351351                return self.parent().retract(x)
    352352
    353     def f(self, i):
     353    def _f(self, i):
    354354        r"""
    355         Returns the action of `f_i` on self.
     355        Return the action of `f_i` on ``self``.
    356356
    357357        EXAMPLES::
    358358
    class AffineCrystalFromClassicalElement( 
    362362            sage: pr_inverse = attrcall("promotion_inverse")
    363363            sage: A=AffineCrystalFromClassicalAndPromotion(['A',n,1],C,pr,pr_inverse,1)
    364364            sage: b=A(rows=[[3]])
    365             sage: b.f(0)
     365            sage: b._f(0)
    366366            [[1]]
    367             sage: b.f(2)
     367            sage: b._f(2)
    368368        """
    369369        if i == 0:
    370370            return self.f0()
    371371        else:
    372             x = self.lift().f(i)
     372            x = self.lift()._f(i)
    373373            if (x == None):
    374374                return None
    375375            else:
    class AffineCrystalFromClassicalElement( 
    381381        """
    382382        return super(AffineCrystalFromClassicalElement, self).epsilon(0)
    383383
    384     def epsilon(self, i):
    385         """
    386         Returns the maximal time the crystal operator `e_i` can be applied to self.
     384    def _epsilon(self, i):
     385        r"""
     386        Return `\varepsilon_i` of ``self``.
    387387
    388388        EXAMPLES::
    389389
    class AffineCrystalFromClassicalElement( 
    392392            sage: pr = attrcall("promotion")
    393393            sage: pr_inverse = attrcall("promotion_inverse")
    394394            sage: A=AffineCrystalFromClassicalAndPromotion(['A',n,1],C,pr,pr_inverse,1)
    395             sage: [x.epsilon(0) for x in A.list()]
     395            sage: [x._epsilon(0) for x in A.list()]
    396396            [1, 0, 0]
    397             sage: [x.epsilon(1) for x in A.list()]
     397            sage: [x._epsilon(1) for x in A.list()]
    398398            [0, 1, 0]
    399399        """
    400400        if i == 0:
    401401            return self.epsilon0()
    402402        else:
    403             return self.lift().epsilon(i)
     403            return self.lift()._epsilon(i)
    404404
    405405    def phi0(self):
    406406        r"""
    407         Uses `phi_0` from the super class, but should be implemented if a faster implementation exists.
     407        Uses `phi_0` from the super class, but should be implemented if a
     408        faster implementation exists.
    408409        """
    409410        return super(AffineCrystalFromClassicalElement, self).phi(0)
    410411
    411     def phi(self, i):
     412    def _phi(self, i):
    412413        r"""
    413         Returns the maximal time the crystal operator `f_i` can be applied to self.
     414        Return `\varphi_i` of ``self``.
    414415
    415416        EXAMPLES::
    416417
    class AffineCrystalFromClassicalElement( 
    419420            sage: pr = attrcall("promotion")
    420421            sage: pr_inverse = attrcall("promotion_inverse")
    421422            sage: A=AffineCrystalFromClassicalAndPromotion(['A',n,1],C,pr,pr_inverse,1)
    422             sage: [x.phi(0) for x in A.list()]
     423            sage: [x._phi(0) for x in A.list()]
    423424            [0, 0, 1]
    424             sage: [x.phi(1) for x in A.list()]
     425            sage: [x._phi(1) for x in A.list()]
    425426            [1, 0, 0]
    426427        """
    427428        if i == 0:
    428429            return self.phi0()
    429430        else:
    430             return self.lift().phi(i)
     431            return self.lift()._phi(i)
    431432
    432433    def __lt__(self, other):
    433434        """
    class AffineCrystalFromClassicalAndPromo 
    603604            sage: b.e0()
    604605            [[3]]
    605606        """
    606         x = self.parent().automorphism(self).e(self.parent().dynkin_node)
     607        x = self.parent().automorphism(self)._e(self.parent().dynkin_node)
    607608        if (x == None):
    608609            return None
    609610        else:
    class AffineCrystalFromClassicalAndPromo 
    625626            sage: b.f0()
    626627            [[1]]
    627628        """
    628         x = self.parent().automorphism(self).f(self.parent().dynkin_node)
     629        x = self.parent().automorphism(self)._f(self.parent().dynkin_node)
    629630        if (x == None):
    630631            return None
    631632        else:
    class AffineCrystalFromClassicalAndPromo 
    646647            [1, 0, 0]
    647648        """
    648649        x = self.parent().automorphism(self)
    649         return x.lift().epsilon(self.parent().dynkin_node)
     650        return x.lift()._epsilon(self.parent().dynkin_node)
    650651
    651652    def phi0(self):
    652653        r"""
    class AffineCrystalFromClassicalAndPromo 
    663664            [0, 0, 1]
    664665        """
    665666        x = self.parent().automorphism(self)
    666         return x.lift().phi(self.parent().dynkin_node)
     667        return x.lift()._phi(self.parent().dynkin_node)
    667668
    668669AffineCrystalFromClassicalAndPromotion.Element = AffineCrystalFromClassicalAndPromotionElement
  • sage/combinat/crystals/alcove_path.py

    diff --git a/sage/combinat/crystals/alcove_path.py b/sage/combinat/crystals/alcove_path.py
    a b class CrystalOfAlcovePathsElement(Elemen 
    620620        lambda_chain = self.parent()._R.lambda_chain()
    621621        return [lambda_chain.index(j) for j in self.value]
    622622
    623     def phi(self, i):
     623    def _phi(self, i):
    624624        r"""
    625625        Return the distance to the end of the `i`-string.
    626626
    class CrystalOfAlcovePathsElement(Elemen 
    630630        EXAMPLES::
    631631
    632632            sage: C = CrystalOfAlcovePaths(['A',2],[1,1])
    633             sage: [c.phi(1) for c in C]
     633            sage: [c._phi(1) for c in C]
    634634            [1, 2, 0, 1, 0, 0, 1, 0]
    635             sage: [c.phi(2) for c in C]
     635            sage: [c._phi(2) for c in C]
    636636            [1, 0, 2, 0, 1, 1, 0, 0]
    637637        """
    638638        highest_weight_crystal = self.parent()._highest_weight_crystal
    class CrystalOfAlcovePathsElement(Elemen 
    647647        M = Integer(m)/2 - Integer(1)/2
    648648        return M
    649649
    650     def epsilon(self, i):
     650    def _epsilon(self, i):
    651651        r"""
    652652        Return the distance to the start of the `i`-string.
    653653
    654654        EXAMPLES::
    655655
    656656            sage: C = CrystalOfAlcovePaths(['A',2],[1,1])
    657             sage: [c.epsilon(1) for c in C]
     657            sage: [c._epsilon(1) for c in C]
    658658            [0, 0, 1, 1, 0, 2, 0, 1]
    659             sage: [c.epsilon(2) for c in C]
     659            sage: [c._epsilon(2) for c in C]
    660660            [0, 1, 0, 0, 1, 0, 2, 1]
    661661        """
    662662        #crude but functional
    class CrystalOfAlcovePathsElement(Elemen 
    872872
    873873        return signs
    874874
    875     def e(self, i):
     875    def _e(self, i):
    876876        r"""
    877877        Return the `i`-th crystal raising operator on ``self``.
    878878
    class CrystalOfAlcovePathsElement(Elemen 
    885885            sage: C = CrystalOfAlcovePaths(['A',2],[2,0]); C
    886886            Highest weight crystal of alcove paths of type ['A', 2] and weight 2*Lambda[1]
    887887            sage: x = C( () )
    888             sage: x.e(1)
    889             sage: x.f(1) == x.f(1).f(2).e(2)
     888            sage: x._e(1)
     889            sage: x._f(1) == x._f(1)._f(2)._e(2)
    890890            True
    891891        """
    892892        Parent = self.parent()
    class CrystalOfAlcovePathsElement(Elemen 
    995995
    996996        return (positions, gi)
    997997
    998     def f(self, i):
     998    def _f(self, i):
    999999        r"""
    10001000        Returns the `i`-th crystal lowering operator on ``self``.
    10011001
    class CrystalOfAlcovePathsElement(Elemen 
    10071007
    10081008            sage: C=CrystalOfAlcovePaths(['B',2],[1,1])
    10091009            sage: x=C(  () )
    1010             sage: x.f(1)
     1010            sage: x._f(1)
    10111011            ((alpha[1], 0),)
    1012             sage: x.f(1).f(2)
     1012            sage: x._f(1)._f(2)
    10131013            ((alpha[1], 0), (alpha[1] + alpha[2], 2))
    10141014
    10151015        """
  • sage/combinat/crystals/direct_sum.py

    diff --git a/sage/combinat/crystals/direct_sum.py b/sage/combinat/crystals/direct_sum.py
    a b class DirectSumOfCrystals(DisjointUnionE 
    128128        A class for elements of direct sums of crystals
    129129        """
    130130
    131         def e(self, i):
     131        def _e(self, i):
    132132            r"""
    133             Returns the action of `e_i` on self.
     133            Return the action of `e_i` on ``self``.
    134134
    135135            EXAMPLES::
    136136
    137137                sage: C = CrystalOfLetters(['A',2])
    138138                sage: B = DirectSumOfCrystals([C,C], keepkey=True)
    139                 sage: [[b, b.e(2)] for b in B]
     139                sage: [[b, b._e(2)] for b in B]
    140140                [[(0, 1), None], [(0, 2), None], [(0, 3), (0, 2)], [(1, 1), None], [(1, 2), None], [(1, 3), (1, 2)]]
    141141            """
    142142            v = self.value
    143             vn = v[1].e(i)
     143            vn = v[1]._e(i)
    144144            if vn is None:
    145145                return None
    146146            else:
    147147                return self.parent()(tuple([v[0],vn]))
    148148
    149         def f(self, i):
     149        def _f(self, i):
    150150            r"""
    151             Returns the action of `f_i` on self.
     151            Return the action of `f_i` on ``self``.
    152152
    153153            EXAMPLES::
    154154
    155155                sage: C = CrystalOfLetters(['A',2])
    156156                sage: B = DirectSumOfCrystals([C,C], keepkey=True)
    157                 sage: [[b,b.f(1)] for b in B]
     157                sage: [[b,b._f(1)] for b in B]
    158158                [[(0, 1), (0, 2)], [(0, 2), None], [(0, 3), None], [(1, 1), (1, 2)], [(1, 2), None], [(1, 3), None]]
    159159            """
    160160            v = self.value
    161             vn = v[1].f(i)
     161            vn = v[1]._f(i)
    162162            if vn is None:
    163163                return None
    164164            else:
    class DirectSumOfCrystals(DisjointUnionE 
    180180            """
    181181            return self.value[1].weight()
    182182
    183         def phi(self, i):
     183        def _phi(self, i):
    184184            r"""
    185185            EXAMPLES::
    186186
    187187                sage: C = CrystalOfLetters(['A',2])
    188188                sage: B = DirectSumOfCrystals([C,C], keepkey=True)
    189189                sage: b = B( tuple([0,C(2)]) )
    190                 sage: b.phi(2)
     190                sage: b._phi(2)
    191191                1
    192192            """
    193             return self.value[1].phi(i)
     193            return self.value[1]._phi(i)
    194194
    195         def epsilon(self, i):
     195        def _epsilon(self, i):
    196196            r"""
    197197            EXAMPLES::
    198198
    199199                sage: C = CrystalOfLetters(['A',2])
    200200                sage: B = DirectSumOfCrystals([C,C], keepkey=True)
    201201                sage: b = B( tuple([0,C(2)]) )
    202                 sage: b.epsilon(2)
     202                sage: b._epsilon(2)
    203203                0
    204204            """
    205             return self.value[1].epsilon(i)
     205            return self.value[1]._epsilon(i)
    206206
  • sage/combinat/crystals/elementary_crystals.py

    diff --git a/sage/combinat/crystals/elementary_crystals.py b/sage/combinat/crystals/elementary_crystals.py
    a b class AbstractSingleCrystalElement(Eleme 
    142142        """
    143143        return not self.__eq__(other)
    144144
    145     def e(self,i):
     145    def _e(self,i):
    146146        r"""
    147147        Return `e_i` of ``self``, which is ``None`` for all `i`.
    148148
    class AbstractSingleCrystalElement(Eleme 
    156156            sage: la = RootSystem(ct).weight_lattice().fundamental_weights()
    157157            sage: T = TCrystal(ct,la[1])
    158158            sage: t = T.highest_weight_vector()
    159             sage: t.e(1)
    160             sage: t.e(2)
     159            sage: t._e(1)
     160            sage: t._e(2)
    161161        """
    162162        return None
    163163
    164     def f(self,i):
     164    def _f(self,i):
    165165        r"""
    166166        Return `f_i` of ``self``, which is ``None`` for all `i`.
    167167
    class AbstractSingleCrystalElement(Eleme 
    175175            sage: la = RootSystem(ct).weight_lattice().fundamental_weights()
    176176            sage: T = TCrystal(ct,la[1])
    177177            sage: t = T.highest_weight_vector()
    178             sage: t.f(1)
    179             sage: t.f(2)
     178            sage: t._f(1)
     179            sage: t._f(2)
    180180        """
    181181        return None
    182182
    class TCrystal(Parent, UniqueRepresentat 
    337337            """
    338338            return "{t_{"+self.parent()._weight._latex_()+"}}"
    339339
    340         def epsilon(self,i):
     340        def _epsilon(self,i):
    341341            r"""
    342342            Return `\varepsilon_i` of ``self``, which is `-\infty` for all `i`.
    343343
    class TCrystal(Parent, UniqueRepresentat 
    351351                sage: la = RootSystem(ct).weight_lattice().fundamental_weights()
    352352                sage: T = TCrystal(ct,la[4]+la[5]-la[1]-la[2])
    353353                sage: t = T.highest_weight_vector()
    354                 sage: [t.epsilon(i) for i in T.index_set()]
     354                sage: [t._epsilon(i) for i in T.index_set()]
    355355                [-inf, -inf, -inf, -inf, -inf]
    356356            """
    357357            return float("-inf")
    358358
    359         def phi(self,i):
     359        def _phi(self,i):
    360360            r"""
    361361            Return `\varphi_i` of ``self``, which is `-\infty` for all `i`.
    362362
    class TCrystal(Parent, UniqueRepresentat 
    370370                sage: la = RootSystem(ct).weight_lattice().fundamental_weights()
    371371                sage: T = TCrystal(ct,la[4]+la[5]-la[1]-la[2])
    372372                sage: t = T.highest_weight_vector()
    373                 sage: [t.phi(i) for i in T.index_set()]
     373                sage: [t._phi(i) for i in T.index_set()]
    374374                [-inf, -inf, -inf, -inf, -inf]
    375375            """
    376376            return float("-inf")
    class RCrystal(Parent, UniqueRepresentat 
    565565            """
    566566            return "{r_{"+self.parent()._weight._latex_()+"}}"
    567567
    568         def epsilon(self, i):
     568        def _epsilon(self, i):
    569569            r"""
    570570            Return `\varepsilon_i` of ``self``.
    571571
    class RCrystal(Parent, UniqueRepresentat 
    581581                sage: la = RootSystem(['A',2]).weight_lattice().fundamental_weights()
    582582                sage: R = RCrystal("A2",la[1])
    583583                sage: r = R.highest_weight_vector()
    584                 sage: [r.epsilon(i) for i in R.index_set()]
     584                sage: [r._epsilon(i) for i in R.index_set()]
    585585                [-1, 0]
    586586            """
    587587            P = self.cartan_type().root_system().ambient_space()
    588588            h = P.simple_coroots()
    589             return -1*P(self.weight()).scalar(h[i])
     589            return -P(self.weight()).scalar(h[i])
    590590
    591         def phi(self,i):
     591        def _phi(self,i):
    592592            r"""
    593593            Return `\varphi_i` of ``self``, which is `0` for all `i`.
    594594
    class RCrystal(Parent, UniqueRepresentat 
    601601                sage: la = RootSystem("C5").weight_lattice().fundamental_weights()
    602602                sage: R = RCrystal("C5",la[4]+la[5])
    603603                sage: r = R.highest_weight_vector()
    604                 sage: [r.phi(i) for i in R.index_set()]
     604                sage: [r._phi(i) for i in R.index_set()]
    605605                [0, 0, 0, 0, 0]
    606606            """
    607607            return 0
    class ElementaryCrystal(Parent, UniqueRe 
    823823            """
    824824            return "{b_{%s}(%s)}"%(self.parent()._i, self._m)
    825825
    826         def e(self,i):
     826        def _e(self,i):
    827827            r"""
    828828            Return the action of `e_i` on ``self``.
    829829
    class ElementaryCrystal(Parent, UniqueRe 
    834834            EXAMPLES::
    835835
    836836                sage: B = ElementaryCrystal(['E',7],1)
    837                 sage: B(3).e(1)
     837                sage: B(3)._e(1)
    838838                4
    839839                sage: B(172).e_string([1]*171)
    840840                343
    841                 sage: B(0).e(2)
     841                sage: B(0)._e(2)
    842842            """
    843843            if i == self.parent()._i:
    844844                return self.__class__(self.parent(), self._m+1)
    845845            else:
    846846                return None
    847847
    848         def f(self, i):
     848        def _f(self, i):
    849849            r"""
    850850            Return the action of `f_i` on ``self``.
    851851
    class ElementaryCrystal(Parent, UniqueRe 
    856856            EXAMPLES::
    857857
    858858                sage: B = ElementaryCrystal(['E',7],1)
    859                 sage: B(3).f(1)
     859                sage: B(3)._f(1)
    860860                2
    861861                sage: B(172).f_string([1]*171)
    862862                1
    863                 sage: B(0).e(2)
     863                sage: B(0)._f(2)
    864864            """
    865865            if i == self.parent()._i:
    866866                return self.__class__(self.parent(), self._m-1)
    867867            else:
    868868                return None
    869869
    870         def epsilon(self, i):
     870        def _epsilon(self, i):
    871871            r"""
    872872            Return `\varepsilon_i` of ``self``.
    873873
    class ElementaryCrystal(Parent, UniqueRe 
    878878            EXAMPLES::
    879879
    880880                sage: B = ElementaryCrystal(['F',4],3)
    881                 sage: [[B(j).epsilon(i) for i in B.index_set()] for j in range(5)]
     881                sage: [[B(j)._epsilon(i) for i in B.index_set()] for j in range(5)]
    882882                [[-inf, -inf, 0, -inf],
    883883                 [-inf, -inf, -1, -inf],
    884884                 [-inf, -inf, -2, -inf],
    class ElementaryCrystal(Parent, UniqueRe 
    890890            else:
    891891                return float("-inf")
    892892
    893         def phi(self, i):
     893        def _phi(self, i):
    894894            r"""
    895895            Return `\varphi_i` of ``self``.
    896896
    class ElementaryCrystal(Parent, UniqueRe 
    901901            EXAMPLES::
    902902
    903903                sage: B = ElementaryCrystal(['E',8,1],4)
    904                 sage: [[B(m).phi(j) for j in B.index_set()] for m in range(44,49)]
     904                sage: [[B(m)._phi(j) for j in B.index_set()] for m in range(44,49)]
    905905                [[-inf, -inf, -inf, -inf, 44, -inf, -inf, -inf, -inf],
    906906                 [-inf, -inf, -inf, -inf, 45, -inf, -inf, -inf, -inf],
    907907                 [-inf, -inf, -inf, -inf, 46, -inf, -inf, -inf, -inf],
    class ComponentCrystal(Parent,UniqueRepr 
    10431043            """
    10441044            return "{c}"
    10451045
    1046         def epsilon(self,i):
     1046        def _epsilon(self,i):
    10471047            r"""
    10481048            Return `\varepsilon_i` of ``self``, which is `0` for all `i`.
    10491049
    class ComponentCrystal(Parent,UniqueRepr 
    10551055
    10561056                sage: C = ComponentCrystal("C5")
    10571057                sage: c = C.highest_weight_vector()
    1058                 sage: [c.epsilon(i) for i in C.index_set()]
     1058                sage: [c._epsilon(i) for i in C.index_set()]
    10591059                [0, 0, 0, 0, 0]
    10601060            """
    10611061            return 0
    10621062
    1063         def phi(self,i):
     1063        def _phi(self,i):
    10641064            r"""
    10651065            Return `\varphi_i` of ``self``, which is `0` for all `i`.
    10661066
    class ComponentCrystal(Parent,UniqueRepr 
    10721072
    10731073                sage: C = ComponentCrystal("C5")
    10741074                sage: c = C.highest_weight_vector()
    1075                 sage: [c.phi(i) for i in C.index_set()]
     1075                sage: [c._phi(i) for i in C.index_set()]
    10761076                [0, 0, 0, 0, 0]
    10771077            """
    10781078            return 0
  • sage/combinat/crystals/fast_crystals.py

    diff --git a/sage/combinat/crystals/fast_crystals.py b/sage/combinat/crystals/fast_crystals.py
    a b class FastCrystal(UniqueRepresentation,  
    413413                return cmp(self.parent(), other.parent())
    414414            return self.parent().cmp_elements(self, other)
    415415
    416         def e(self, i):
     416        def _e(self, i):
    417417            """
    418             Returns the action of `e_i` on self.
     418            Return the action of `e_i` on ``self``.
    419419
    420420            EXAMPLES::
    421421
    422422                sage: C = FastCrystal(['A',2],shape=[2,1])
    423                 sage: C(1).e(1)
     423                sage: C(1)._e(1)
    424424                [0, 0, 0]
    425                 sage: C(0).e(1) is None
     425                sage: C(0)._e(1) is None
    426426                True
    427427            """
    428             assert i in self.index_set()
    429428            if i == 1:
    430429                r = self.parent()._rootoperators[self.value][0]
    431430            else:
    432431                r = self.parent()._rootoperators[self.value][2]
    433432            return self.parent()(r) if r is not None else None
    434433
    435 
    436         def f(self, i):
     434        def _f(self, i):
    437435            """
    438             Returns the action of `f_i` on self.
     436            Return the action of `f_i` on ``self``.
    439437
    440438            EXAMPLES::
    441439
    442440                sage: C = FastCrystal(['A',2],shape=[2,1])
    443                 sage: C(6).f(1)
     441                sage: C(6)._f(1)
    444442                [1, 2, 1]
    445                 sage: C(7).f(1) is None
     443                sage: C(7)._f(1) is None
    446444                True
    447445            """
    448             assert i in self.index_set()
    449446            if i == 1:
    450447                r = self.parent()._rootoperators[self.value][1]
    451448            else:
  • sage/combinat/crystals/generalized_young_walls.py

    diff --git a/sage/combinat/crystals/generalized_young_walls.py b/sage/combinat/crystals/generalized_young_walls.py
    a b class GeneralizedYoungWall(Combinatorial 
    248248        """
    249249        return sum(len(r) for r in self.data)
    250250
    251     def e(self,i):
     251    def _e(self, i):
    252252        r"""
    253253        Return the application of the Kashiwara raising operator
    254254        `\widetilde{e}_i` on ``self``.
    class GeneralizedYoungWall(Combinatorial 
    259259        EXAMPLES::
    260260
    261261            sage: x=CrystalOfGeneralizedYoungWalls(3)([[],[1,0,3,2],[2,1],[3,2,1,0,3,2],[],[],[2]])
    262             sage: x.e(2)
     262            sage: x._e(2)
    263263            [[], [1, 0, 3, 2], [2, 1], [3, 2, 1, 0, 3, 2]]
    264             sage: _.e(2)
     264            sage: _._e(2)
    265265            [[], [1, 0, 3], [2, 1], [3, 2, 1, 0, 3, 2]]
    266             sage: _.e(2)
     266            sage: _._e(2)
    267267            [[], [1, 0, 3], [2, 1], [3, 2, 1, 0, 3]]
    268             sage: _.e(2)
     268            sage: _._e(2)
    269269        """
    270270        signature = self.generate_signature(i)
    271271        raw_signature = signature[0]
    class GeneralizedYoungWall(Combinatorial 
    282282        else:
    283283            return None
    284284
    285     def f(self,i):
     285    def _f(self,i):
    286286        r"""
    287287        Return the application of the Kashiwara lowering operator
    288288        `\widetilde{f}_i` on ``self``.
    class GeneralizedYoungWall(Combinatorial 
    293293        EXAMPLES::
    294294
    295295            sage: hw = CrystalOfGeneralizedYoungWalls(2)([])
    296             sage: hw.f(1)
     296            sage: hw._f(1)
    297297            [[], [1]]
    298             sage: _.f(2)
     298            sage: _._f(2)
    299299            [[], [1], [2]]
    300             sage: _.f(0)
     300            sage: _._f(0)
    301301            [[], [1, 0], [2]]
    302             sage: _.f(0)
     302            sage: _._f(0)
    303303            [[0], [1, 0], [2]]
    304304        """
    305305        signature = self.generate_signature(i)
    class GeneralizedYoungWall(Combinatorial 
    347347        """
    348348        s = ""
    349349        if self.data == []:
    350                 s += "\\emptyset"
     350            s += "\\emptyset"
    351351        else:
    352352            s += "\\begin{tikzpicture}[baseline=5,scale=.25] \\foreach \\x [count=\\s from 0] in \n"
    353353            s += "{" + ','.join("{" + ','.join( str(i) for i in r ) + "}" for r in self.data ) + "} \n"
    class GeneralizedYoungWall(Combinatorial 
    373373                W.append(-1*alpha[i])
    374374        return L(sum(w for w in W))
    375375
    376     def epsilon(self, i):
     376    def _epsilon(self, i):
    377377        r"""
    378378        Return the number of `i`-colored arrows in the `i`-string above
    379379        ``self`` in the crystal graph.
    class GeneralizedYoungWall(Combinatorial 
    381381        EXAMPLES::
    382382
    383383            sage: y=CrystalOfGeneralizedYoungWalls(3)([[],[1,0,3,2],[2,1],[3,2,1,0,3,2],[],[],[2]])
    384             sage: y.epsilon(1)
     384            sage: y._epsilon(1)
    385385            0
    386             sage: y.epsilon(2)
     386            sage: y._epsilon(2)
    387387            3
    388             sage: y.epsilon(0)
     388            sage: y._epsilon(0)
    389389            0
    390390        """
    391         if i not in self.index_set():
    392             raise ValueError("i must in in the index set")
    393391        eps = 0
    394392        while True:
    395             self = self.e(i)
     393            self = self._e(i)
    396394            if self is None:
    397395                break
    398396            eps = eps+1
    class GeneralizedYoungWall(Combinatorial 
    409407            Lambda[0] + 3*Lambda[2]
    410408        """
    411409        La = self.cartan_type().root_system().weight_lattice().fundamental_weights()
    412         return sum(self.epsilon(i)*La[i] for i in self.index_set())
     410        return sum(self._epsilon(i)*La[i] for i in self.index_set())
    413411
    414     def phi(self,i):
     412    def _phi(self,i):
    415413        r"""
    416414        Return the value `\varepsilon_i(Y) + \langle h_i,
    417415        \mathrm{wt}(Y)\rangle`, where `h_i` is the `i`-th simple
    class GeneralizedYoungWall(Combinatorial 
    420418        EXAMPLES::
    421419
    422420            sage: y = CrystalOfGeneralizedYoungWalls(3)([[0],[1,0,3,2],[2,1],[3,2,1,0,3,2],[0],[],[2]])
    423             sage: y.phi(1)
     421            sage: y._phi(1)
    424422            3
    425             sage: y.phi(2)
     423            sage: y._phi(2)
    426424            -1
    427425        """
    428426        h = self.parent().weight_lattice_realization().simple_coroots()
    429         return self.epsilon(i) + self.weight().scalar(h[i])
     427        return self._epsilon(i) + self.weight().scalar(h[i])
    430428
    431429    def Phi(self):
    432430        r"""
    class GeneralizedYoungWall(Combinatorial 
    443441            2*Lambda[0] + Lambda[1] - Lambda[2] + Lambda[3]
    444442            """
    445443        La = self.cartan_type().root_system().weight_lattice().fundamental_weights()
    446         return sum(self.phi(i)*La[i] for i in self.index_set())
     444        return sum(self._phi(i)*La[i] for i in self.index_set())
    447445
    448446    def column(self, k):
    449447        r"""
    class HighestWeightCrystalofGYWElement(G 
    711709    Element of the highest weight crystal of generalized Young walls.
    712710    """
    713711
    714     def e(self,i):
     712    def _e(self,i):
    715713        r"""
    716714        Compute the action of `\widetilde{e}_i` restricted to the highest weight crystal.
    717715
    class HighestWeightCrystalofGYWElement(G 
    719717
    720718            sage: La = RootSystem(['A',2,1]).weight_lattice().fundamental_weights()[1]
    721719            sage: hwy = HighestWeightCrystalOfGYW(2,La)([[],[1,0],[2,1]])
    722             sage: hwy.e(1)
     720            sage: hwy._e(1)
    723721            [[], [1, 0], [2]]
    724             sage: hwy.e(2)
    725             sage: hwy.e(3)
     722            sage: hwy._e(2)
     723            sage: hwy._e(3)
    726724        """
    727         ret = GeneralizedYoungWall.e(self, i)
     725        ret = GeneralizedYoungWall._e(self, i)
    728726        if ret is None:
    729727            return None
    730728        if ret.in_highest_weight_crystal(self.parent().hw):
    731729            return self.__class__(self.parent(),ret.data)
    732730        return None
    733731
    734     def f(self,i):
     732    def _f(self,i):
    735733        r"""
    736734        Compute the action of `\widetilde{f}_i` restricted to the highest weight crystal.
    737735
    class HighestWeightCrystalofGYWElement(G 
    740738            sage: La = RootSystem(['A',2,1]).weight_lattice().fundamental_weights()[1]
    741739            sage: GYW = CrystalOfGeneralizedYoungWalls(2)
    742740            sage: y = GYW([[],[1,0],[2,1]])
    743             sage: y.f(1)
     741            sage: y._f(1)
    744742            [[], [1, 0], [2, 1], [], [1]]
    745743            sage: hwy = HighestWeightCrystalOfGYW(2,La)([[],[1,0],[2,1]])
    746             sage: hwy.f(1)
     744            sage: hwy._f(1)
    747745        """
    748         ret = GeneralizedYoungWall.f(self, i)
     746        ret = GeneralizedYoungWall._f(self, i)
    749747        if ret.in_highest_weight_crystal(self.parent().hw):
    750748            return self.__class__(self.parent(),ret.data)
    751749        return None
  • sage/combinat/crystals/infinity_crystals.py

    diff --git a/sage/combinat/crystals/infinity_crystals.py b/sage/combinat/crystals/infinity_crystals.py
    a b class InfinityCrystalOfTableaux(CrystalO 
    5050    types `A_n`, `B_n`, `C_n`, and `D_n`, and by Kang and Misra [KM94]_ in
    5151    type `G_2`.
    5252
    53     NOTE: We are using the English convention for our tableaux.
     53    .. NOTE::
     54
     55        We are using the English convention for our tableaux.
    5456
    5557    We say a tableau `T` is *marginally large* if:
    5658
    class InfinityCrystalOfTableaux(CrystalO 
    137139       Crystal bases and tensor product decompositions of `U_q(G_2)`-modules.
    138140       J. Algebra 163, pp. 675--691, 1994.
    139141
    140     .. [KN94] M. Kashiwara and T. Nakashima.
    141        Crystal Graphs for Representations of the `q`-Analogue of Classical Lie
    142        Algebras.
    143        J. Algebra 165, pp. 295--345, 1994.
    144 
    145142    INPUT:
    146143
    147144    - ``cartan_type`` -- One of ``['A',n]``, ``['B',n]``, ``['C',n]``,
    class InfinityCrystalOfTableaux(CrystalO 
    282279        Elements in `\mathcal{B}(\infty)` crystal of tableaux.
    283280        """
    284281
    285         def e(self,i):
     282        def _e(self,i):
    286283            r"""
    287284            Return the action of `\widetilde{e}_i` on ``self``.
    288285
    class InfinityCrystalOfTableaux(CrystalO 
    294291
    295292                sage: B = InfinityCrystalOfTableaux(['B',3])
    296293                sage: b = B(rows=[[1,1,1,1,1,1,1,2,0,-3,-1,-1,-1,-1],[2,2,2,2,-2,-2],[3,-3,-3]])
    297                 sage: b.e(3).pp()
     294                sage: b._e(3).pp()
    298295                1  1  1  1  1  1  1  2  0 -3 -1 -1 -1 -1
    299296                2  2  2  2 -2 -2
    300297                3  0 -3
    301                 sage: b.e(1).pp()
     298                sage: b._e(1).pp()
    302299                1  1  1  1  1  1  1  0 -3 -1 -1 -1 -1
    303300                2  2  2  2 -2 -2
    304301                3 -3 -3
    305302            """
    306             if i not in self.index_set():
    307                 raise ValueError('i is not in the index set.')
    308303            position = self.positions_of_unmatched_plus(i)
    309304            if position == []:
    310305                return None
    311306            k = position[0]
    312             ret = self.set_index(k, self[k].e(i))
     307            ret = self.set_index(k, self[k]._e(i))
    313308            if k+i > len(self):
    314309                return ret
    315310            for j in reversed(range(1, i+1)):
    class InfinityCrystalOfTableaux(CrystalO 
    320315                ret._list.pop(k)
    321316            return ret
    322317
    323         def f(self, i):
     318        def _f(self, i):
    324319            r"""
    325320            Return the action of `\widetilde{f}_i` on ``self``.
    326321
    class InfinityCrystalOfTableaux(CrystalO 
    332327
    333328                sage: B = InfinityCrystalOfTableaux(['C',4])
    334329                sage: b = B.highest_weight_vector()
    335                 sage: b.f(1).pp()
     330                sage: b._f(1).pp()
    336331                1  1  1  1  2
    337332                2  2  2
    338333                3  3
    339334                4
    340                 sage: b.f(3).pp()
     335                sage: b._f(3).pp()
    341336                1  1  1  1  1
    342337                2  2  2  2
    343338                3  3  4
    344339                4
    345                 sage: b.f(3).f(4).pp()
     340                sage: b._f(3)._f(4).pp()
    346341                1  1  1  1  1
    347342                2  2  2  2
    348343                3  3 -4
    349344                4
    350345            """
    351             if i not in self.index_set():
    352                 raise ValueError('i is not in the index set.')
    353346            position = self.positions_of_unmatched_minus(i)
    354347            if position == []:
    355348                return None
    356349            k = position[len(position)-1]
    357             ret = self.set_index(k, self[k].f(i))
     350            ret = self.set_index(k, self[k]._f(i))
    358351            if k+i > len(self):
    359352                return ret
    360353            for j in reversed(range(1,i+1)):
    class InfinityCrystalOfTableaux(CrystalO 
    365358                ret._list.insert(k,self.parent().letters(j+1))
    366359            return ret
    367360
    368         def phi(self,i):
     361        def _phi(self,i):
    369362            r"""
    370363            Return `\varphi_i` of ``self``.
    371364
    class InfinityCrystalOfTableaux(CrystalO 
    381374            EXAMPLES::
    382375
    383376                sage: B = InfinityCrystalOfTableaux("A3")
    384                 sage: [B.highest_weight_vector().f_string([1,3,2,3,1,3,2,1]).phi(i) for i in B.index_set()]
     377                sage: [B.highest_weight_vector().f_string([1,3,2,3,1,3,2,1])._phi(i) for i in B.index_set()]
    385378                [-3, 4, -3]
    386379
    387380                sage: B = InfinityCrystalOfTableaux("G2")
    388                 sage: [B.highest_weight_vector().f_string([2,2,1,2,1,1,1,2]).phi(i) for i in B.index_set()]
     381                sage: [B.highest_weight_vector().f_string([2,2,1,2,1,1,1,2])._phi(i) for i in B.index_set()]
    389382                [5, -3]
    390383            """
    391384            P = self.parent().weight_lattice_realization()
    class InfinityCrystalOfTableaux(CrystalO 
    607600            for i in word:
    608601                a = 0
    609602                while self.e(i) != None:
    610                     self = self.e(i)
     603                    self = self._e(i)
    611604                    a += 1
    612605                ret.append(a)
    613606            return ret
    class InfinityCrystalOfTableauxTypeD(Inf 
    678671        r"""
    679672        Elements in `\mathcal{B}(\infty)` crystal of tableaux for type `D_n`.
    680673        """
    681         def e(self, i):
     674        def _e(self, i):
    682675            r"""
    683676            Return the action of `\widetilde{e}_i` on ``self``.
    684677
    class InfinityCrystalOfTableauxTypeD(Inf 
    693686                1  1  1  1  2  3
    694687                2  2  2
    695688                3 -3
    696                 sage: b.e(2).pp()
     689                sage: b._e(2).pp()
    697690                1  1  1  1  2  2
    698691                2  2  2
    699692                3 -3
    700693            """
    701             if i not in self.index_set():
    702                 raise ValueError('i is not in the index set.')
    703694            position = self.positions_of_unmatched_plus(i)
    704695            if position == []:
    705696                return None
    706697            k = position[0]
    707             ret = self.set_index(k, self[k].e(i))
     698            ret = self.set_index(k, self[k]._e(i))
    708699            if i == self.cartan_type().rank():
    709700                i -= 1
    710701            if k+i > len(self):
    class InfinityCrystalOfTableauxTypeD(Inf 
    717708                ret._list.pop(k)
    718709            return ret
    719710
    720         def f(self, i):
     711        def _f(self, i):
    721712            r"""
    722713            Return the action of `\widetilde{f}_i` on ``self``.
    723714
    class InfinityCrystalOfTableauxTypeD(Inf 
    733724                2  2  2  2  2
    734725                3  3  3 -5
    735726                4  5
    736                 sage: b.f(1).pp()
     727                sage: b._f(1).pp()
    737728                1  1  1  1  1  1  2  2  2
    738729                2  2  2  2  2
    739730                3  3  3 -5
    740731                4  5
    741                 sage: b.f(5).pp()
     732                sage: b._f(5).pp()
    742733                1  1  1  1  1  1  2  2
    743734                2  2  2  2  2
    744735                3  3  3 -5
    745736                4 -4
    746737            """
    747             ret = InfinityCrystalOfTableaux.Element.f(self, i)
     738            ret = InfinityCrystalOfTableaux.Element._f(self, i)
    748739            if ret._list[0].value == -self.cartan_type().rank():
    749740                # Exceptional case for f_n where we need to add a new column
    750741                for j in range(i-1):
  • sage/combinat/crystals/kirillov_reshetikhin.py

    diff --git a/sage/combinat/crystals/kirillov_reshetikhin.py b/sage/combinat/crystals/kirillov_reshetikhin.py
    a b class KR_type_E6(KirillovReshetikhinCrys 
    10911091             [[(1, -3), (-1, 3)]],
    10921092             [[(-1,), (-1, 3)]]]
    10931093        """
    1094         return [x for x in self.classical_decomposition() if all(x.epsilon(i) == 0 for i in [2,3,4,5])]
     1094        return [x for x in self.classical_decomposition() if all(x._epsilon(i) == 0 for i in [2,3,4,5])]
    10951095
    10961096    @cached_method
    10971097    def highest_weight_dict(self):
    class KR_type_E6(KirillovReshetikhinCrys 
    11081108             [[(2, -1), (1,)]]: ((-2, 0, 1, 0, 0, 0, 0), 1),
    11091109             []: ((0, 0, 0, 0, 0, 0, 0), 0)}
    11101110        """
    1111         hw = [x for x in self.hw_auxiliary() if x.epsilon(1) == 0]
     1111        hw = [x for x in self.hw_auxiliary() if x._epsilon(1) == 0]
    11121112        dic = dict( ( x, tuple( [self.affine_weight(x), len(x)] ) ) for x in hw )
    11131113        assert len(hw) == len(dic)
    11141114        return dic
    class KR_type_E6(KirillovReshetikhinCrys 
    11291129             ((0, -2, 0, 1, 0, 0, 0), 1): [[(-1,), (-1, 3)]],
    11301130             ((-2, 0, 1, 0, 0, 0, 0), 1): [[(2, -1), (1,)]]}
    11311131        """
    1132         hw = [x for x in self.hw_auxiliary() if x.epsilon(6) == 0]
     1132        hw = [x for x in self.hw_auxiliary() if x._epsilon(6) == 0]
    11331133        dic = dict( ( tuple( [self.affine_weight(x), len(x)] ), x ) for x in hw )
    11341134        assert len(hw) == len(dic)
    11351135        return dic
    class KR_type_CElement(KirillovReshetikh 
    14381438            2
    14391439        """
    14401440        b = self.parent().to_ambient_crystal()(self)
    1441         return b.epsilon(1)
     1441        return b._epsilon(1)
    14421442
    14431443    def phi0(self):
    14441444        r"""
    class KR_type_CElement(KirillovReshetikh 
    14531453            2
    14541454        """
    14551455        b = self.parent().to_ambient_crystal()(self)
    1456         return b.phi(1)
     1456        return b._phi(1)
    14571457
    14581458KR_type_C.Element = KR_type_CElement
    14591459
    class KR_type_A2Element(AffineCrystalFro 
    16991699            1
    17001700        """
    17011701        b = self.parent().to_ambient_crystal()(self)
    1702         return b.epsilon(1)
     1702        return b._epsilon(1)
    17031703
    17041704    def phi0(self):
    17051705        r"""
    class KR_type_A2Element(AffineCrystalFro 
    17151715            1
    17161716        """
    17171717        b = self.parent().to_ambient_crystal()(self)
    1718         return b.phi(1)
     1718        return b._phi(1)
    17191719
    17201720KR_type_A2.Element = KR_type_A2Element
    17211721
    class KR_type_boxElement(KirillovResheti 
    19061906            sage: b.e(0) # indirect doctest
    19071907            [[-1]]
    19081908        """
    1909         b = self.parent().to_ambient_crystal()(self).e(0)
     1909        b = self.parent().to_ambient_crystal()(self)._e(0)
    19101910        if b is None:
    19111911            return None
    19121912        return self.parent().from_ambient_crystal()(b)
    class KR_type_boxElement(KirillovResheti 
    19231923            sage: b.f(0) # indirect doctest
    19241924            [[1]]
    19251925        """
    1926         b = self.parent().to_ambient_crystal()(self).f(0)
     1926        b = self.parent().to_ambient_crystal()(self)._f(0)
    19271927        if b is None:
    19281928            return None
    19291929        return self.parent().from_ambient_crystal()(b)
    class KR_type_boxElement(KirillovResheti 
    19411941            2
    19421942        """
    19431943        b = self.parent().to_ambient_crystal()(self)
    1944         return b.epsilon(0)
     1944        return b._epsilon(0)
    19451945
    19461946    def phi0(self):
    19471947        r"""
    class KR_type_boxElement(KirillovResheti 
    19561956            2
    19571957        """
    19581958        b = self.parent().to_ambient_crystal()(self)
    1959         return b.phi(0)
     1959        return b._phi(0)
    19601960
    19611961KR_type_box.Element = KR_type_boxElement
    19621962
    class KR_type_BnElement(KirillovReshetik 
    21362136            sage: b.e(0) # indirect doctest
    21372137            [--+, []]
    21382138        """
    2139         b = self.parent().to_ambient_crystal()(self).e_string([0,0])
     2139        b = self.parent().to_ambient_crystal()(self)._e_string([0,0])
    21402140        if b is None:
    21412141            return None
    21422142        return self.parent().from_ambient_crystal()(b)
    class KR_type_BnElement(KirillovReshetik 
    21532153            sage: b.f(0) # indirect doctest
    21542154
    21552155        """
    2156         b = self.parent().to_ambient_crystal()(self).f_string([0,0])
     2156        b = self.parent().to_ambient_crystal()(self)._f_string([0,0])
    21572157        if b is None:
    21582158            return None
    21592159        return self.parent().from_ambient_crystal()(b)
    class KR_type_BnElement(KirillovReshetik 
    21712171            1
    21722172        """
    21732173        b = self.parent().to_ambient_crystal()(self)
    2174         return b.epsilon(0)/2
     2174        return b._epsilon(0)/2
    21752175
    21762176    def phi0(self):
    21772177        r"""
    class KR_type_BnElement(KirillovReshetik 
    21862186            0
    21872187        """
    21882188        b = self.parent().to_ambient_crystal()(self)
    2189         return b.phi(0)/2
     2189        return b._phi(0)/2
    21902190
    21912191KR_type_Bn.Element = KR_type_BnElement
    21922192
  • sage/combinat/crystals/kyoto_path_model.py

    diff --git a/sage/combinat/crystals/kyoto_path_model.py b/sage/combinat/crystals/kyoto_path_model.py
    a b class KyotoPathModel(TensorProductOfCrys 
    220220        """
    221221        An element in the path realization model.
    222222        """
    223         def e(self, i):
     223        def _e(self, i):
    224224            """
    225225            Return the action of `e_i` on ``self``.
    226226
    class KyotoPathModel(TensorProductOfCrys 
    230230                sage: L = RootSystem(['A',2,1]).weight_space()
    231231                sage: C = KyotoPathModel(B, L.fundamental_weight(0))
    232232                sage: mg = C.module_generators[0]
    233                 sage: all(mg.e(i) is None for i in C.index_set())
     233                sage: all(mg._e(i) is None for i in C.index_set())
    234234                True
    235                 sage: mg.f(0).e(0) == mg
     235                sage: mg._f(0)._e(0) == mg
    236236                True
    237237            """
    238238            position = self.positions_of_unmatched_plus(i)
    class KyotoPathModel(TensorProductOfCrys 
    241241            k = position[0]
    242242            if k == len(self)-1:
    243243                return None
    244             crystal = self[k].e(i)
     244            crystal = self[k]._e(i)
    245245            if k == len(self)-2 and crystal.Epsilon() == self._list[-1].Phi():
    246246                l = self._list[:-1]
    247247                l[-1] = crystal
    248248                return self.__class__(self.parent(), l)
    249249            return self.set_index(k, crystal)
    250250
    251         def f(self, i):
     251        def _f(self, i):
    252252            """
    253253            Return the action of `f_i` on ``self``.
    254254
    class KyotoPathModel(TensorProductOfCrys 
    258258                sage: L = RootSystem(['A',2,1]).weight_space()
    259259                sage: C = KyotoPathModel(B, L.fundamental_weight(0))
    260260                sage: mg = C.module_generators[0]
    261                 sage: mg.f(2)
    262                 sage: mg.f(0)
     261                sage: mg._f(2)
     262                sage: mg._f(0)
    263263                [[[1]], [[2]]]
    264264                sage: mg.f_string([0,1,2])
    265265                [[[2]], [[3]], [[1]]]
    class KyotoPathModel(TensorProductOfCrys 
    272272                l = self._list[:]
    273273                k = len(l) % len(self.parent()._crystals)
    274274                l.append(self.parent()._phi_dicts[k][ l[-1].Epsilon() ])
    275                 l[-2] = l[-2].f(i)
     275                l[-2] = l[-2]._f(i)
    276276                return self.__class__(self.parent(), l)
    277             return self.set_index(k, self[k].f(i))
     277            return self.set_index(k, self[k]._f(i))
    278278
  • sage/combinat/crystals/letters.pyx

    diff --git a/sage/combinat/crystals/letters.pyx b/sage/combinat/crystals/letters.pyx
    a b cdef class EmptyLetter(Element): 
    489489        """
    490490        return self.parent().weight_lattice_realization().zero()
    491491
    492     cpdef e(self, int i):
     492    cpdef _e(self, int i):
    493493        """
    494494        Return `e_i` of ``self`` which is ``None``.
    495495
    496496        EXAMPLES::
    497497
    498498            sage: C = CrystalOfLetters(['C', 3])
    499             sage: C('E').e(1)
     499            sage: C('E')._e(1)
    500500        """
    501501        return None
    502502
    503     f = e
     503    _f = _e
    504504
    505     cpdef int epsilon(self, int i):
     505    cpdef int _epsilon(self, int i):
    506506        r"""
    507507        Return `\varepsilon_i` of ``self``.
    508508
    509509        EXAMPLES::
    510510
    511511            sage: C = CrystalOfLetters(['C', 3])
    512             sage: C('E').epsilon(1)
     512            sage: C('E')._epsilon(1)
    513513            0
    514514        """
    515515        return 0
    516516
    517     phi = epsilon
     517    _phi = _epsilon
    518518
    519519#########################
    520520# Type A
    cdef class Crystal_of_letters_type_A_ele 
    556556        """
    557557        return self._parent.weight_lattice_realization().monomial(self.value-1)
    558558
    559     cpdef Letter e(self, int i):
     559    cpdef Letter _e(self, int i):
    560560        r"""
    561561        Return the action of `e_i` on ``self``.
    562562       
    563563        EXAMPLES::
    564564       
    565565            sage: C = CrystalOfLetters(['A',4])
    566             sage: [(c,i,c.e(i)) for i in C.index_set() for c in C if c.e(i) is not None]
     566            sage: [(c,i,c._e(i)) for i in C.index_set() for c in C if c._e(i) is not None]
    567567            [(2, 1, 1), (3, 2, 2), (4, 3, 3), (5, 4, 4)]
    568568        """
    569569        if self.value == i+1:
    cdef class Crystal_of_letters_type_A_ele 
    571571        else:
    572572            return None
    573573
    574     cpdef Letter f(self, int i):
     574    cpdef Letter _f(self, int i):
    575575        r"""
    576576        Return the action of `f_i` on ``self``.
    577577       
    578578        EXAMPLES::
    579579       
    580580            sage: C = CrystalOfLetters(['A',4])
    581             sage: [(c,i,c.f(i)) for i in C.index_set() for c in C if c.f(i) is not None]
     581            sage: [(c,i,c._f(i)) for i in C.index_set() for c in C if c._f(i) is not None]
    582582            [(1, 1, 2), (2, 2, 3), (3, 3, 4), (4, 4, 5)]
    583583        """
    584584        if self.value == i:
    cdef class Crystal_of_letters_type_A_ele 
    586586        else:
    587587            return None
    588588
    589     cpdef int epsilon(self, int i):
     589    cpdef int _epsilon(self, int i):
    590590        r"""
    591591        Return `\varepsilon_i` of ``self``.
    592592
    593593        EXAMPLES::
    594594
    595595            sage: C = CrystalOfLetters(['A',4])
    596             sage: [(c,i) for i in C.index_set() for c in C if c.epsilon(i) != 0]
     596            sage: [(c,i) for i in C.index_set() for c in C if c._epsilon(i) != 0]
    597597            [(2, 1), (3, 2), (4, 3), (5, 4)]
    598598        """
    599599        if self.value == i+1:
    600600            return 1
    601601        return 0
    602602
    603     cpdef int phi(self, int i):
     603    cpdef int _phi(self, int i):
    604604        r"""
    605605        Return `\varphi_i` of ``self``.
    606606
    607607        EXAMPLES::
    608608
    609609            sage: C = CrystalOfLetters(['A',4])
    610             sage: [(c,i) for i in C.index_set() for c in C if c.phi(i) != 0]
     610            sage: [(c,i) for i in C.index_set() for c in C if c._phi(i) != 0]
    611611            [(1, 1), (2, 2), (3, 3), (4, 4)]
    612612        """
    613613        if self.value == i:
    cdef class Crystal_of_letters_type_B_ele 
    649649        else:
    650650            return self._parent.weight_lattice_realization()(0)
    651651
    652     cpdef Letter e(self, int i):
     652    cpdef Letter _e(self, int i):
    653653        r"""
    654654        Return the action of `e_i` on ``self``.
    655655       
    656656        EXAMPLES::
    657657       
    658658            sage: C = CrystalOfLetters(['B',4])
    659             sage: [(c,i,c.e(i)) for i in C.index_set() for c in C if c.e(i) is not None]
     659            sage: [(c,i,c._e(i)) for i in C.index_set() for c in C if c._e(i) is not None]
    660660            [(2, 1, 1),
    661661             (-1, 1, -2),
    662662             (3, 2, 2),
    cdef class Crystal_of_letters_type_B_ele 
    678678        else:
    679679            return None
    680680
    681     cpdef Letter f(self, int i):
     681    cpdef Letter _f(self, int i):
    682682        r"""
    683683        Return the actions of `f_i` on ``self``.
    684684       
    685685        EXAMPLES::
    686686       
    687687            sage: C = CrystalOfLetters(['B',4])
    688             sage: [(c,i,c.f(i)) for i in C.index_set() for c in C if c.f(i) is not None]
     688            sage: [(c,i,c._f(i)) for i in C.index_set() for c in C if c._f(i) is not None]
    689689            [(1, 1, 2),
    690690             (-2, 1, -1),
    691691             (2, 2, 3),
    cdef class Crystal_of_letters_type_B_ele 
    707707        else:
    708708            return None
    709709
    710     cpdef int epsilon(self, int i):
     710    cpdef int _epsilon(self, int i):
    711711        r"""
    712712        Return `\varepsilon_i` of ``self``.
    713713
    714714        EXAMPLES::
    715715
    716716            sage: C = CrystalOfLetters(['B',3])
    717             sage: [(c,i) for i in C.index_set() for c in C if c.epsilon(i) != 0]
     717            sage: [(c,i) for i in C.index_set() for c in C if c._epsilon(i) != 0]
    718718            [(2, 1), (-1, 1), (3, 2), (-2, 2), (0, 3), (-3, 3)]
    719719        """
    720720        cdef int n = self._parent._cartan_type.n
    cdef class Crystal_of_letters_type_B_ele 
    728728            return 1
    729729        return 0
    730730
    731     cpdef int phi(self, int i):
     731    cpdef int _phi(self, int i):
    732732        r"""
    733733        Return `\varphi_i` of ``self``.
    734734
    cdef class Crystal_of_letters_type_C_ele 
    787787        else:
    788788            return self._parent.weight_lattice_realization()(0)
    789789
    790     cpdef Letter e(self, int i):
     790    cpdef Letter _e(self, int i):
    791791        r"""
    792792        Return the action of `e_i` on ``self``.
    793793       
    794794        EXAMPLES::
    795795       
    796796            sage: C = CrystalOfLetters(['C',4])
    797             sage: [(c,i,c.e(i)) for i in C.index_set() for c in C if c.e(i) is not None]
     797            sage: [(c,i,c._e(i)) for i in C.index_set() for c in C if c._e(i) is not None]
    798798            [(2, 1, 1),
    799799             (-1, 1, -2),
    800800             (3, 2, 2),
    cdef class Crystal_of_letters_type_C_ele 
    810810        else:
    811811            return None
    812812
    813     cpdef Letter f(self, int i):
     813    cpdef Letter _f(self, int i):
    814814        r"""
    815815        Return the action of `f_i` on ``self``.
    816816
    817817        EXAMPLES::
    818818
    819819            sage: C = CrystalOfLetters(['C',4])
    820             sage: [(c,i,c.f(i)) for i in C.index_set() for c in C if c.f(i) is not None]
     820            sage: [(c,i,c._f(i)) for i in C.index_set() for c in C if c._f(i) is not None]
    821821            [(1, 1, 2), (-2, 1, -1), (2, 2, 3),
    822822             (-3, 2, -2), (3, 3, 4), (-4, 3, -3), (4, 4, -4)]
    823823        """
    cdef class Crystal_of_letters_type_C_ele 
    828828        else:
    829829            return None
    830830
    831     cpdef int epsilon(self, int i):
     831    cpdef int _epsilon(self, int i):
    832832        r"""
    833833        Return `\varepsilon_i` of ``self``.
    834834
    835835        EXAMPLES::
    836836
    837837            sage: C = CrystalOfLetters(['C',3])
    838             sage: [(c,i) for i in C.index_set() for c in C if c.epsilon(i) != 0]
     838            sage: [(c,i) for i in C.index_set() for c in C if c._epsilon(i) != 0]
    839839            [(2, 1), (-1, 1), (3, 2), (-2, 2), (-3, 3)]
    840840        """
    841841        if self.value == i+1 or self.value == -i:
    842842            return 1
    843843        return 0
    844844
    845     cpdef int phi(self, int i):
     845    cpdef int _phi(self, int i):
    846846        r"""
    847847        Return `\varphi_i` of ``self``.
    848848
    849849        EXAMPLES::
    850850
    851851            sage: C = CrystalOfLetters(['C',3])
    852             sage: [(c,i) for i in C.index_set() for c in C if c.phi(i) != 0]
     852            sage: [(c,i) for i in C.index_set() for c in C if c._phi(i) != 0]
    853853            [(1, 1), (-2, 1), (2, 2), (-3, 2), (3, 3)]
    854854        """
    855855        if self.value == i or self.value == -i-1:
    cdef class Crystal_of_letters_type_D_ele 
    894894        else:
    895895            return self._parent.weight_lattice_realization()(0)
    896896
    897     cpdef Letter e(self, int i):
     897    cpdef Letter _e(self, int i):
    898898        r"""
    899899        Return the action of `e_i` on ``self``.
    900900       
    901901        EXAMPLES::
    902902       
    903903            sage: C = CrystalOfLetters(['D',5])
    904             sage: [(c,i,c.e(i)) for i in C.index_set() for c in C if c.e(i) is not None]
     904            sage: [(c,i,c._e(i)) for i in C.index_set() for c in C if c._e(i) is not None]
    905905            [(2, 1, 1),
    906906             (-1, 1, -2),
    907907             (3, 2, 2),
    cdef class Crystal_of_letters_type_D_ele 
    927927        else:
    928928            return None
    929929
    930     cpdef Letter f(self, int i):
     930    cpdef Letter _f(self, int i):
    931931        r"""
    932932        Return the action of `f_i` on ``self``.
    933933       
    934934        EXAMPLES::
    935935       
    936936            sage: C = CrystalOfLetters(['D',5])
    937             sage: [(c,i,c.f(i)) for i in C.index_set() for c in C if c.f(i) is not None]
     937            sage: [(c,i,c._f(i)) for i in C.index_set() for c in C if c._f(i) is not None]
    938938            [(1, 1, 2),
    939939             (-2, 1, -1),
    940940             (2, 2, 3),
    cdef class Crystal_of_letters_type_D_ele 
    958958        else:
    959959            return None
    960960
    961     cpdef int epsilon(self, int i):
     961    cpdef int _epsilon(self, int i):
    962962        r"""
    963963        Return `\varepsilon_i` of ``self``.
    964964
    965965        EXAMPLES::
    966966
    967967            sage: C = CrystalOfLetters(['D',4])
    968             sage: [(c,i) for i in C.index_set() for c in C if c.epsilon(i) != 0]
     968            sage: [(c,i) for i in C.index_set() for c in C if c._epsilon(i) != 0]
    969969            [(2, 1), (-1, 1), (3, 2), (-2, 2), (4, 3), (-3, 3), (-4, 4), (-3, 4)]
    970970        """
    971971        if self.value == i+1 or self.value == -i:
    cdef class Crystal_of_letters_type_D_ele 
    975975            return 1
    976976        return 0
    977977
    978     cpdef int phi(self, int i):
     978    cpdef int _phi(self, int i):
    979979        r"""
    980980        Return `\varphi_i` of ``self``.
    981981
    982982        EXAMPLES::
    983983
    984984            sage: C = CrystalOfLetters(['D',4])
    985             sage: [(c,i) for i in C.index_set() for c in C if c.phi(i) != 0]
     985            sage: [(c,i) for i in C.index_set() for c in C if c._phi(i) != 0]
    986986            [(1, 1), (-2, 1), (2, 2), (-3, 2), (3, 3), (-4, 3), (3, 4), (4, 4)]
    987987        """
    988988        if self.value == i or self.value == -i-1:
    cdef class Crystal_of_letters_type_G_ele 
    10331033        else:
    10341034            raise RuntimeError("G2 crystal of letters element %d not valid"%self.value)
    10351035
    1036     cpdef Letter e(self, int i):
     1036    cpdef Letter _e(self, int i):
    10371037        r"""
    10381038        Return the action of `e_i` on ``self``.
    10391039       
    10401040        EXAMPLES::
    10411041       
    10421042            sage: C = CrystalOfLetters(['G',2])
    1043             sage: [(c,i,c.e(i)) for i in C.index_set() for c in C if c.e(i) is not None]
     1043            sage: [(c,i,c._e(i)) for i in C.index_set() for c in C if c._e(i) is not None]
    10441044            [(2, 1, 1),
    10451045             (0, 1, 3),
    10461046             (-3, 1, 0),
    cdef class Crystal_of_letters_type_G_ele 
    10671067            else:
    10681068                return None
    10691069       
    1070     cpdef Letter f(self, int i):
     1070    cpdef Letter _f(self, int i):
    10711071        r"""
    10721072        Return the action of `f_i` on ``self``.
    10731073       
    10741074        EXAMPLES::
    10751075       
    10761076            sage: C = CrystalOfLetters(['G',2])
    1077             sage: [(c,i,c.f(i)) for i in C.index_set() for c in C if c.f(i) is not None]
     1077            sage: [(c,i,c._f(i)) for i in C.index_set() for c in C if c._f(i) is not None]
    10781078            [(1, 1, 2),
    10791079             (3, 1, 0),
    10801080             (0, 1, -3),
    cdef class Crystal_of_letters_type_G_ele 
    11011101            else:
    11021102                return None
    11031103
    1104     cpdef int epsilon(self, int i):
     1104    cpdef int _epsilon(self, int i):
    11051105        r"""
    11061106        Return `\varepsilon_i` of ``self``.
    11071107
    11081108        EXAMPLES::
    11091109
    11101110            sage: C = CrystalOfLetters(['G',2])
    1111             sage: [(c,i) for i in C.index_set() for c in C if c.epsilon(i) != 0]
     1111            sage: [(c,i) for i in C.index_set() for c in C if c._epsilon(i) != 0]
    11121112            [(2, 1), (0, 1), (-3, 1), (-1, 1), (3, 2), (-2, 2)]
    11131113        """
    11141114        if i == 1:
    cdef class Crystal_of_letters_type_G_ele 
    11191119            return 1
    11201120        return 0
    11211121
    1122     cpdef int phi(self, int i):
     1122    cpdef int _phi(self, int i):
    11231123        r"""
    11241124        Return `\varphi_i` of ``self``.
    11251125
    11261126        EXAMPLES::
    11271127
    11281128            sage: C = CrystalOfLetters(['G',2])
    1129             sage: [(c,i) for i in C.index_set() for c in C if c.phi(i) != 0]
     1129            sage: [(c,i) for i in C.index_set() for c in C if c._phi(i) != 0]
    11301130            [(1, 1), (3, 1), (0, 1), (-2, 1), (2, 2), (-3, 2)]
    11311131        """
    11321132        if i == 1:
    cdef class LetterTuple(Element): 
    12641264                ret+= repr(v)
    12651265        return ret + "\\right)"
    12661266
    1267     cpdef int epsilon(self, int i):
     1267    cpdef int _epsilon(self, int i):
    12681268        r"""
    12691269        Return `\varepsilon_i` of ``self``.
    12701270
    12711271        EXAMPLES::
    12721272
    12731273            sage: C = CrystalOfLetters(['E',6])
    1274             sage: C((-6,)).epsilon(1)
     1274            sage: C((-6,))._epsilon(1)
    12751275            0
    1276             sage: C((-6,)).epsilon(6)
     1276            sage: C((-6,))._epsilon(6)
    12771277            1
    12781278        """
    12791279        if -i in self.value:
    12801280            return 1
    12811281        return 0
    12821282
    1283     cpdef int phi(self, int i):
     1283    cpdef int _phi(self, int i):
    12841284        r"""
    12851285        Return `\varphi_i` of ``self``.
    12861286
    12871287        EXAMPLES::
    12881288
    12891289            sage: C = CrystalOfLetters(['E',6])
    1290             sage: C((1,)).phi(1)
     1290            sage: C((1,))._phi(1)
    12911291            1
    1292             sage: C((1,)).phi(6)
     1292            sage: C((1,))._phi(6)
    12931293            0
    12941294        """
    12951295        if i in self.value:
    cdef class Crystal_of_letters_type_E6_el 
    13811381        R=self._parent.weight_lattice_realization().fundamental_weights()
    13821382        return sum(cmp(i,0)*R[abs(i)] for i in self.value)
    13831383
    1384     cpdef LetterTuple e(self, int i):
     1384    cpdef LetterTuple _e(self, int i):
    13851385        r"""
    13861386        Return the action of `e_i` on ``self``.
    13871387
    13881388        EXAMPLES::
    13891389
    13901390            sage: C = CrystalOfLetters(['E',6])
    1391             sage: C((-1,3)).e(1)
     1391            sage: C((-1,3))._e(1)
    13921392            (1,)
    1393             sage: C((-2,-3,4)).e(2)
     1393            sage: C((-2,-3,4))._e(2)
    13941394            (-3, 2)
    1395             sage: C((1,)).e(1)
     1395            sage: C((1,))._e(1)
    13961396        """
    13971397        if self.value == (-1, 3) and i == 1:
    13981398            return self._parent._element_constructor_((1,))
    cdef class Crystal_of_letters_type_E6_el 
    14691469        else:
    14701470            return None
    14711471
    1472     cpdef LetterTuple f(self, int i):
     1472    cpdef LetterTuple _f(self, int i):
    14731473        r"""
    14741474        Return the action of `f_i` on ``self``.
    14751475
    14761476        EXAMPLES::
    14771477
    14781478            sage: C = CrystalOfLetters(['E',6])
    1479             sage: C((1,)).f(1)
     1479            sage: C((1,))._f(1)
    14801480            (-1, 3)
    1481             sage: C((-6,)).f(1)
     1481            sage: C((-6,))._f(1)
    14821482        """
    14831483        if self.value == (1,) and i == 1:
    14841484            return self._parent._element_constructor_((-1, 3))
    cdef class Crystal_of_letters_type_E6_el 
    16401640        #  tuple from a list
    16411641        return self._parent._element_constructor_(tuple([-i for i in p.value]))
    16421642   
    1643     cpdef LetterTuple e(self, int i):
     1643    cpdef LetterTuple _e(self, int i):
    16441644        r"""
    16451645        Return the action of `e_i` on ``self``.
    16461646       
    16471647        EXAMPLES::
    16481648
    16491649            sage: C = CrystalOfLetters(['E',6], dual = True)
    1650             sage: C((-1,)).e(1)
     1650            sage: C((-1,))._e(1)
    16511651            (1, -3)
    16521652        """
    1653         return self.retract(self.lift().f(i))
     1653        return self.retract(self.lift()._f(i))
    16541654
    1655     cpdef LetterTuple f(self, int i):
     1655    cpdef LetterTuple _f(self, int i):
    16561656        r"""
    16571657        Return the action of `f_i` on ``self``.
    16581658       
    16591659        EXAMPLES::
    16601660
    16611661            sage: C = CrystalOfLetters(['E',6], dual = True)
    1662             sage: C((6,)).f(6)
     1662            sage: C((6,))._f(6)
    16631663            (5, -6)
    1664             sage: C((6,)).f(1)
     1664            sage: C((6,))._f(1)
    16651665        """
    1666         return self.retract(self.lift().e(i))
     1666        return self.retract(self.lift()._e(i))
    16671667
    16681668    def weight(self):
    16691669        """
    cdef class Crystal_of_letters_type_E7_el 
    17821782        R=self._parent.weight_lattice_realization().fundamental_weights()
    17831783        return sum(cmp(i,0)*R[abs(i)] for i in self.value)
    17841784
    1785     cpdef LetterTuple e(self, int i):
     1785    cpdef LetterTuple _e(self, int i):
    17861786        r"""
    17871787        Return the action of `e_i` on ``self``.
    17881788
    17891789        EXAMPLES::
    17901790       
    17911791            sage: C = CrystalOfLetters(['E',7])
    1792             sage: C((7,)).e(7)
    1793             sage: C((-7,6)).e(7)
     1792            sage: C((7,))._e(7)
     1793            sage: C((-7,6))._e(7)
    17941794            (7,)
    17951795        """
    17961796        if self.value ==  (-7, 6)  and i ==  7 :
    cdef class Crystal_of_letters_type_E7_el 
    19641964        else:
    19651965            return None
    19661966
    1967     cpdef LetterTuple f(self, int i):
     1967    cpdef LetterTuple _f(self, int i):
    19681968        r"""
    19691969        Return the action of `f_i` on ``self``.
    19701970       
    19711971        EXAMPLES::
    19721972
    19731973            sage: C = CrystalOfLetters(['E',7])
    1974             sage: C((-7,)).f(7)
    1975             sage: C((7,)).f(7)
     1974            sage: C((-7,))._f(7)
     1975            sage: C((7,))._f(7)
    19761976            (-7, 6)
    19771977        """
    19781978        if self.value ==  (7,)  and i ==  7 :
  • sage/combinat/crystals/littelmann_path.py

    diff --git a/sage/combinat/crystals/littelmann_path.py b/sage/combinat/crystals/littelmann_path.py
    a b class CrystalOfLSPaths(UniqueRepresentat 
    355355                    psmin = ps
    356356            return tuple(minima_pos)
    357357
    358         def epsilon(self, i):
     358        def _epsilon(self, i):
    359359            r"""
    360             Returns the distance to the beginning of the `i`-string.
     360            Return the distance to the beginning of the `i`-string.
    361361
    362362            This method overrides the generic implementation in the category of crystals
    363363            since this computation is more efficient.
    class CrystalOfLSPaths(UniqueRepresentat 
    365365            EXAMPLES::
    366366
    367367                sage: C = CrystalOfLSPaths(['A',2],[1,1])
    368                 sage: [c.epsilon(1) for c in C]
     368                sage: [c._epsilon(1) for c in C]
    369369                [0, 1, 0, 0, 1, 0, 1, 2]
    370                 sage: [c.epsilon(2) for c in C]
     370                sage: [c._epsilon(2) for c in C]
    371371                [0, 0, 1, 2, 1, 1, 0, 0]
    372372            """
    373             return self.e(i,length_only=True)
     373            return self._e(i,length_only=True)
    374374
    375         def phi(self, i):
     375        def _phi(self, i):
    376376            r"""
    377             Returns the distance to the end of the `i`-string.
     377            Return the distance to the end of the `i`-string.
    378378
    379379            This method overrides the generic implementation in the category of crystals
    380380            since this computation is more efficient.
    class CrystalOfLSPaths(UniqueRepresentat 
    382382            EXAMPLES::
    383383
    384384                sage: C = CrystalOfLSPaths(['A',2],[1,1])
    385                 sage: [c.phi(1) for c in C]
     385                sage: [c._phi(1) for c in C]
    386386                [1, 0, 0, 1, 0, 2, 1, 0]
    387                 sage: [c.phi(2) for c in C]
     387                sage: [c._phi(2) for c in C]
    388388                [1, 2, 1, 0, 0, 0, 0, 1]
    389389            """
    390             return self.f(i,length_only=True)
     390            return self._f(i,length_only=True)
    391391
    392         def e(self, i, power=1, to_string_end=False, length_only=False):
     392        def _e(self, i, power=1, to_string_end=False, length_only=False):
    393393            r"""
    394             Returns the `i`-th crystal raising operator on ``self``.
     394            Return the `i`-th crystal raising operator on ``self``.
    395395
    396396            INPUT:
    397397
    class CrystalOfLSPaths(UniqueRepresentat 
    408408                sage: C = CrystalOfLSPaths(['A',2],[1,1])
    409409                sage: c = C[2]; c
    410410                (1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2])
    411                 sage: c.e(1)
    412                 sage: c.e(2)
     411                sage: c._e(1)
     412                sage: c._e(2)
    413413                (-Lambda[1] + 2*Lambda[2],)
    414                 sage: c.e(2,to_string_end=True)
     414                sage: c._e(2,to_string_end=True)
    415415                (-Lambda[1] + 2*Lambda[2],)
    416                 sage: c.e(1,to_string_end=True)
     416                sage: c._e(1,to_string_end=True)
    417417                (1/2*Lambda[1] - Lambda[2], -1/2*Lambda[1] + Lambda[2])
    418                 sage: c.e(1,length_only=True)
     418                sage: c._e(1,length_only=True)
    419419                0
    420420            """
    421             assert i in self.index_set()
    422421            data = self._string_data(i)
    423422            # compute the minimum i-height M on the path
    424423            if len(data) == 0:
    class CrystalOfLSPaths(UniqueRepresentat 
    486485            dual_path.reverse()
    487486            return self.parent()(tuple(dual_path))
    488487
    489         def f(self, i, power=1, to_string_end=False, length_only=False):
     488        def _f(self, i, power=1, to_string_end=False, length_only=False):
    490489            r"""
    491             Returns the `i`-th crystal lowering operator on ``self``.
     490            Return the `i`-th crystal lowering operator on ``self``.
    492491
    493492            INPUT:
    494493
    class CrystalOfLSPaths(UniqueRepresentat 
    504503
    505504                sage: C = CrystalOfLSPaths(['A',2],[1,1])
    506505                sage: c = C.module_generators[0]
    507                 sage: c.f(1)
     506                sage: c._f(1)
    508507                (-Lambda[1] + 2*Lambda[2],)
    509                 sage: c.f(1,power=2)
    510                 sage: c.f(2)
     508                sage: c._f(1,power=2)
     509                sage: c._f(2)
    511510                (2*Lambda[1] - Lambda[2],)
    512                 sage: c.f(2,to_string_end=True)
     511                sage: c._f(2,to_string_end=True)
    513512                (2*Lambda[1] - Lambda[2],)
    514                 sage: c.f(2,length_only=True)
     513                sage: c._f(2,length_only=True)
    515514                1
    516515
    517516                sage: C = CrystalOfLSPaths(['A',2,1],[-1,-1,2])
    518517                sage: c = C.module_generators[0]
    519                 sage: c.f(2,power=2)
     518                sage: c._f(2,power=2)
    520519                (Lambda[0] + Lambda[1] - 2*Lambda[2],)
    521520            """
    522521            dual_path = self.dualize()
    523             dual_path = dual_path.e(i, power, to_string_end, length_only)
     522            dual_path = dual_path._e(i, power, to_string_end, length_only)
    524523            if length_only:
    525524                return dual_path
    526525            if dual_path == None:
    class CrystalOfLSPaths(UniqueRepresentat 
    553552                sage: c.f(2).s(1)
    554553                (Lambda[0] - Lambda[1],)
    555554            """
    556             ph = self.phi(i)
    557             ep = self.epsilon(i)
     555            if i not in self.index_set():
     556                raise ValueError("%s is not in the index set"%i)
     557            ph = self._phi(i)
     558            ep = self._epsilon(i)
    558559            diff = ph - ep
    559560            if diff >= 0:
    560                 return self.f(i, power=diff)
     561                return self._f(i, power=diff)
    561562            else:
    562                 return self.e(i, power=-diff)
     563                return self._e(i, power=-diff)
    563564
    564565        def _latex_(self):
    565566            r"""
  • sage/combinat/crystals/spins.py

    diff --git a/sage/combinat/crystals/spins.py b/sage/combinat/crystals/spins.py
    a b class Spin(LetterTuple): 
    345345        """
    346346        return Tableau([[i] for i in reversed(self.signature())])._latex_()
    347347
     348    def _epsilon(self, i):
     349        r"""
     350        Return `\varepsilon_i` of ``self``.
     351
     352        EXAMPLES::
     353
     354            sage: C = CrystalOfSpins(['B',3])
     355            sage: [[C[m]._epsilon(i) for i in range(1,4)] for m in range(8)]
     356            [[0, 0, 0], [0, 0, 1], [0, 1, 0], [1, 0, 0],
     357             [0, 0, 1], [1, 0, 1], [0, 1, 0], [0, 0, 1]]
     358        """
     359        if self._e(i) is None:
     360            return 0
     361        return 1
     362
     363    def _phi(self, i):
     364        r"""
     365        Return `\varphi_i` of ``self``.
     366
     367        EXAMPLES::
     368
     369            sage: C = CrystalOfSpins(['B',3])
     370            sage: [[C[m]._phi(i) for i in range(1,4)] for m in range(8)]
     371            [[0, 0, 1], [0, 1, 0], [1, 0, 1], [0, 0, 1],
     372             [1, 0, 0], [0, 1, 0], [0, 0, 1], [0, 0, 0]]
     373        """
     374        if self._f(i) is None:
     375            return 0
     376        return 1
    348377
    349378class Spin_crystal_type_B_element(Spin):
    350379    r"""
    351     Type B spin representation crystal element
     380    Type `B` spin representation crystal element.
    352381    """
    353     def e(self, i):
     382    def _e(self, i):
    354383        r"""
    355         Returns the action of `e_i` on self.
    356        
     384        Return the action of `e_i` on ``self``.
     385
    357386        EXAMPLES::
    358        
     387
    359388            sage: C = CrystalOfSpins(['B',3])
    360             sage: [[C[m].e(i) for i in range(1,4)] for m in range(8)]
     389            sage: [[C[m]._e(i) for i in range(1,4)] for m in range(8)]
    361390            [[None, None, None], [None, None, +++], [None, ++-, None], [+-+, None, None],
    362391            [None, None, +-+], [+--, None, -++], [None, -+-, None], [None, None, --+]]
    363392        """
    364         assert i in self.index_set()
    365393        rank = self.parent().cartan_type().n
    366394        if i < rank:
    367395            if self.value[i-1] == -1 and self.value[i] == 1:
    class Spin_crystal_type_B_element(Spin): 
    375403                ret[i-1] = 1
    376404                return self.parent()(ret)
    377405        else:
    378             return None   
     406            return None
    379407
    380     def f(self, i):
     408    def _f(self, i):
    381409        r"""
    382         Returns the action of `f_i` on self.
    383        
     410        Return the action of `f_i` on ``self``.
     411
    384412        EXAMPLES::
    385        
     413
    386414            sage: C = CrystalOfSpins(['B',3])
    387             sage: [[C[m].f(i) for i in range(1,4)] for m in range(8)]
     415            sage: [[C[m]._f(i) for i in range(1,4)] for m in range(8)]
    388416            [[None, None, ++-], [None, +-+, None], [-++, None, +--], [None, None, -+-],
    389417            [-+-, None, None], [None, --+, None], [None, None, ---], [None, None, None]]
    390418        """
    391         assert i in self.index_set()
    392419        rank = self.parent().cartan_type().n
    393420        if i < rank:
    394421            if self.value[i-1] == 1 and self.value[i] == -1:
    class Spin_crystal_type_B_element(Spin): 
    406433
    407434class Spin_crystal_type_D_element(Spin):
    408435    r"""
    409     Type D spin representation crystal element
     436    Type `D` spin representation crystal element.
    410437    """
    411     def e(self, i):
     438    def _e(self, i):
    412439        r"""
    413         Returns the action of `e_i` on self.
    414        
     440        Return the action of `e_i` on ``self``.
     441
    415442        EXAMPLES::
    416        
     443
    417444            sage: D = CrystalOfSpinsPlus(['D',4])
    418             sage: [[D.list()[m].e(i) for i in range(1,4)] for m in range(8)]
     445            sage: [[D.list()[m]._e(i) for i in range(1,4)] for m in range(8)]
    419446            [[None, None, None], [None, None, None], [None, ++--, None], [+-+-, None, None],
    420447            [None, None, +-+-], [+--+, None, -++-], [None, -+-+, None], [None, None, None]]
    421        
     448
    422449        ::
    423        
     450
    424451            sage: E = CrystalOfSpinsMinus(['D',4])
    425             sage: [[E[m].e(i) for i in range(1,4)] for m in range(8)]
     452            sage: [[E[m]._e(i) for i in range(1,4)] for m in range(8)]
    426453            [[None, None, None], [None, None, +++-], [None, ++-+, None], [+-++, None, None],
    427454            [None, None, None], [+---, None, None], [None, -+--, None], [None, None, --+-]]
    428455        """
    429         assert i in self.index_set()
    430456        rank = self.parent().cartan_type().n
    431457        if i < rank:
    432458            if self.value[i-1] == -1 and self.value[i] == 1:
    class Spin_crystal_type_D_element(Spin): 
    443469        else:
    444470            return None   
    445471
    446     def f(self, i):
     472    def _f(self, i):
    447473        r"""
    448         Returns the action of `f_i` on self.
    449        
     474        Return the action of `f_i` on ``self``.
     475
    450476        EXAMPLES::
    451        
     477
    452478            sage: D = CrystalOfSpinsPlus(['D',4])
    453             sage: [[D.list()[m].f(i) for i in range(1,4)] for m in range(8)]
     479            sage: [[D.list()[m]._f(i) for i in range(1,4)] for m in range(8)]
    454480            [[None, None, None], [None, +-+-, None], [-++-, None, +--+], [None, None, -+-+],
    455481            [-+-+, None, None], [None, --++, None], [None, None, None], [None, None, None]]
    456        
     482
    457483        ::
    458        
     484
    459485            sage: E = CrystalOfSpinsMinus(['D',4])
    460             sage: [[E[m].f(i) for i in range(1,4)] for m in range(8)]
     486            sage: [[E[m]._f(i) for i in range(1,4)] for m in range(8)]
    461487            [[None, None, ++-+], [None, +-++, None], [-+++, None, None], [None, None, None],
    462488            [-+--, None, None], [None, --+-, None], [None, None, ---+], [None, None, None]]
    463489        """
    464         assert i in self.index_set()
    465490        rank = self.parent().cartan_type().n
    466491        if i < rank:
    467492            if self.value[i-1] == 1 and self.value[i] == -1:
  • sage/combinat/crystals/tensor_product.py

    diff --git a/sage/combinat/crystals/tensor_product.py b/sage/combinat/crystals/tensor_product.py
    a b class TensorProductOfCrystalsElement(Imm 
    817817        """
    818818        return sum(self[i].weight() for i in range(len(self)))
    819819
    820     def epsilon(self, i):
     820    def _epsilon(self, i):
    821821        r"""
    822822        Return `\varepsilon_i` of ``self``.
    823823
    class TensorProductOfCrystalsElement(Imm 
    832832            sage: b1 = B.highest_weight_vector().f(2)
    833833            sage: b2 = B.highest_weight_vector().f_string([2,2,1])
    834834            sage: t = T(b2, b1)
    835             sage: [t.epsilon(i) for i in B.index_set()]
     835            sage: [t._epsilon(i) for i in B.index_set()]
    836836            [0, 3]
    837837        """
    838838        return max(self._sig(i, k) for k in range(1, len(self)+1))
    839839
    840     def phi(self, i):
     840    def _phi(self, i):
    841841        r"""
    842842        Return `\varphi_i` of ``self``.
    843843
    class TensorProductOfCrystalsElement(Imm 
    853853            sage: b1 = B.highest_weight_vector().f_string([1,0])
    854854            sage: b2 = B.highest_weight_vector().f_string([0,1])
    855855            sage: t = T(b2, b1)
    856             sage: [t.phi(i) for i in B.index_set()]
     856            sage: [t._phi(i) for i in B.index_set()]
    857857            [1, 1, 4]
    858858        """
    859859        P = self[-1].parent().weight_lattice_realization()
    class TensorProductOfCrystalsElement(Imm 
    893893            [[0, -1], [0, 0], [0, 1], [1, 2]]
    894894        """
    895895        if k == 1:
    896             return self[-1].epsilon(i)
    897         return self._sig(i, k-1) + self[-k].epsilon(i) - self[-k+1].phi(i)
     896            return self[-1]._epsilon(i)
     897        return self._sig(i, k-1) + self[-k]._epsilon(i) - self[-k+1]._phi(i)
    898898
    899     def e(self,i):
     899    def _e(self,i):
    900900        r"""
    901901        Return the action of `e_i` on ``self``.
    902902
    class TensorProductOfCrystalsElement(Imm 
    911911            sage: b1 = B.highest_weight_vector().f_string([1,4,3])
    912912            sage: b2 = B.highest_weight_vector().f_string([2,2,3,1,4])
    913913            sage: t = T(b2, b1)
    914             sage: t.e(1)
     914            sage: t._e(1)
    915915            [[[1, 1, 1, 1, 1], [2, 2, 3, -3], [3]], [[1, 1, 1, 1, 2], [2, 2, 2], [3, -3]]]
    916             sage: t.e(2)
    917             sage: t.e(3)
     916            sage: t._e(2)
     917            sage: t._e(3)
    918918            [[[1, 1, 1, 1, 1, 2], [2, 2, 3, -4], [3]], [[1, 1, 1, 1, 2], [2, 2, 2], [3, -3]]]
    919             sage: t.e(4)
     919            sage: t._e(4)
    920920            [[[1, 1, 1, 1, 1, 2], [2, 2, 3, 4], [3]], [[1, 1, 1, 1, 2], [2, 2, 2], [3, -3]]]
    921921        """
    922922        N = len(self) + 1
    923923        for k in range(1, N):
    924924            if all(self._sig(i,k) > self._sig(i,j) for j in range(1, k)) and \
    925925                    all(self._sig(i,k) >= self._sig(i,j) for j in range(k+1, N)):
    926                 crystal = self[-k].e(i)
     926                crystal = self[-k]._e(i)
    927927                if crystal is None:
    928928                    return None
    929929                return self.set_index(-k, crystal)
    930930        return None
    931931
    932     def f(self,i):
     932    def _f(self,i):
    933933        r"""
    934934        Return the action of `f_i` on ``self``.
    935935
    class TensorProductOfCrystalsElement(Imm 
    946946            sage: b2 = B.highest_weight_vector().f_string([0])
    947947            sage: b3 = B.highest_weight_vector()
    948948            sage: t = T(b3, b2, b1)
    949             sage: t.f(0)
     949            sage: t._f(0)
    950950            [[[0]], [[0]], [[0, 3]]]
    951             sage: t.f(1)
     951            sage: t._f(1)
    952952            [[], [[0]], [[0, 3], [1]]]
    953             sage: t.f(2)
     953            sage: t._f(2)
    954954            [[], [[0]], [[0, 3, 2]]]
    955             sage: t.f(3)
     955            sage: t._f(3)
    956956            [[], [[0, 3]], [[0, 3]]]
    957957        """
    958958        N = len(self) + 1
    959959        for k in range(1, N):
    960960            if all(self._sig(i,k) >= self._sig(i,j) for j in range(1, k)) and \
    961961                    all(self._sig(i,k) > self._sig(i,j) for j in range(k+1, N)):
    962                 crystal = self[-k].f(i)
     962                crystal = self[-k]._f(i)
    963963                if crystal is None:
    964964                    return None
    965965                return self.set_index(-k, crystal)
    class TensorProductOfRegularCrystalsElem 
    978978        sage: isinstance(elt, TensorProductOfRegularCrystalsElement)
    979979        True
    980980    """
    981     def e(self, i):
     981    def _e(self, i):
    982982        """
    983983        Return the action of `e_i` on ``self``.
    984984
    class TensorProductOfRegularCrystalsElem 
    986986
    987987            sage: C = CrystalOfLetters(['A',5])
    988988            sage: T = TensorProductOfCrystals(C,C)
    989             sage: T(C(1),C(2)).e(1) == T(C(1),C(1))
     989            sage: T(C(1),C(2))._e(1) == T(C(1),C(1))
    990990            True
    991             sage: T(C(2),C(1)).e(1) == None
     991            sage: T(C(2),C(1))._e(1) == None
    992992            True
    993             sage: T(C(2),C(2)).e(1) == T(C(1),C(2))
     993            sage: T(C(2),C(2))._e(1) == T(C(1),C(2))
    994994            True
    995995        """
    996         if i not in self.index_set():
    997             raise ValueError("i must be in the index set")
    998996        position = self.positions_of_unmatched_plus(i)
    999997        if position == []:
    1000998            return None
    1001999        k = position[0]
    1002         return self.set_index(k, self[k].e(i))
     1000        return self.set_index(k, self[k]._e(i))
    10031001
    10041002    def weight(self):
    10051003        """
    class TensorProductOfRegularCrystalsElem 
    10171015        """
    10181016        return sum((self[j].weight() for j in range(len(self))), self.parent().weight_lattice_realization().zero())
    10191017
    1020     def f(self, i):
     1018    def _f(self, i):
    10211019        """
    10221020        Return the action of `f_i` on ``self``.
    10231021
    class TensorProductOfRegularCrystalsElem 
    10251023
    10261024            sage: C = CrystalOfLetters(['A',5])
    10271025            sage: T = TensorProductOfCrystals(C,C)
    1028             sage: T(C(1),C(1)).f(1)
     1026            sage: T(C(1),C(1))._f(1)
    10291027            [1, 2]
    1030             sage: T(C(1),C(2)).f(1)
     1028            sage: T(C(1),C(2))._f(1)
    10311029            [2, 2]
    1032             sage: T(C(2),C(1)).f(1) is None
     1030            sage: T(C(2),C(1))._f(1) is None
    10331031            True
    10341032        """
    1035         if i not in self.index_set():
    1036             raise ValueError("i must be in the index set")
    10371033        position = self.positions_of_unmatched_minus(i)
    10381034        if position == []:
    10391035            return None
    10401036        k = position[len(position)-1]
    1041         return self.set_index(k, self[k].f(i))
     1037        return self.set_index(k, self[k]._f(i))
    10421038
    1043     def phi(self, i):
     1039    def _phi(self, i):
    10441040        r"""
    10451041        Return `\varphi_i` of ``self``.
    10461042
    class TensorProductOfRegularCrystalsElem 
    10481044
    10491045            sage: C = CrystalOfLetters(['A',5])
    10501046            sage: T = TensorProductOfCrystals(C,C)
    1051             sage: T(C(1),C(1)).phi(1)
     1047            sage: T(C(1),C(1))._phi(1)
    10521048            2
    1053             sage: T(C(1),C(2)).phi(1)
     1049            sage: T(C(1),C(2))._phi(1)
    10541050            1
    1055             sage: T(C(2),C(1)).phi(1)
     1051            sage: T(C(2),C(1))._phi(1)
    10561052            0
    10571053        """
    10581054        self = self.reversed()
    10591055        height = 0
    10601056        for j in range(len(self)):
    1061             plus = self[j].epsilon(i)
    1062             minus = self[j].phi(i)
     1057            plus = self[j]._epsilon(i)
     1058            minus = self[j]._phi(i)
    10631059            if height-plus < 0:
    10641060                height = minus
    10651061            else:
    10661062                height = height - plus + minus
    10671063        return height
    10681064
    1069     def epsilon(self, i):
     1065    def _epsilon(self, i):
    10701066        r"""
    10711067        Return `\varepsilon_i` of ``self``.
    10721068
    class TensorProductOfRegularCrystalsElem 
    10741070
    10751071            sage: C = CrystalOfLetters(['A',5])
    10761072            sage: T = TensorProductOfCrystals(C,C)
    1077             sage: T(C(1),C(1)).epsilon(1)
     1073            sage: T(C(1),C(1))._epsilon(1)
    10781074            0
    1079             sage: T(C(1),C(2)).epsilon(1)
     1075            sage: T(C(1),C(2))._epsilon(1)
    10801076            1
    1081             sage: T(C(2),C(1)).epsilon(1)
     1077            sage: T(C(2),C(1))._epsilon(1)
    10821078            0
    10831079        """
    10841080        height = 0
    10851081        for j in range(len(self)):
    1086             minus = self[j].phi(i)
    1087             plus = self[j].epsilon(i)
     1082            minus = self[j]._phi(i)
     1083            plus = self[j]._epsilon(i)
    10881084            if height-minus < 0:
    10891085                height = plus
    10901086            else:
    class TensorProductOfRegularCrystalsElem 
    11081104            self = self.reversed()
    11091105        if dual == False:
    11101106            for j in range(len(self)):
    1111                 minus = self[j].phi(i)
    1112                 plus = self[j].epsilon(i)
     1107                minus = self[j]._phi(i)
     1108                plus = self[j]._epsilon(i)
    11131109                if height-minus < 0:
    11141110                    unmatched_plus.append(j)
    11151111                    height = plus
    class TensorProductOfRegularCrystalsElem 
    11171113                    height = height - minus + plus
    11181114        else:
    11191115            for j in range(len(self)):
    1120                 plus = self[j].epsilon(i)
    1121                 minus = self[j].phi(i)
     1116                plus = self[j]._epsilon(i)
     1117                minus = self[j]._phi(i)
    11221118                if height-plus < 0:
    11231119                    unmatched_plus.append(j)
    11241120                    height = minus
    class TensorProductOfRegularCrystalsElem 
    12981294        I = self.cartan_type().classical().index_set()
    12991295        ell = max(ceil(K.s()/K.cartan_type().c()[K.r()]) for K in self.parent().crystals)
    13001296        for i in I:
    1301             if self.epsilon(i) > 0:
    1302                 return (i,) + (self.e(i)).e_string_to_ground_state()
    1303         if self.epsilon(0) > ell:
    1304             return (0,) + (self.e(0)).e_string_to_ground_state()
     1297            if self._epsilon(i) > 0:
     1298                return (i,) + (self._e(i)).e_string_to_ground_state()
     1299        if self._epsilon(0) > ell:
     1300            return (0,) + (self._e(0)).e_string_to_ground_state()
    13051301        return ()
    13061302
    13071303CrystalOfWords.Element = TensorProductOfCrystalsElement
  • sage/combinat/rigged_configurations/kr_tableaux.py

    diff --git a/sage/combinat/rigged_configurations/kr_tableaux.py b/sage/combinat/rigged_configurations/kr_tableaux.py
    a b class KirillovReshetikhinTableauxElement 
    651651        if index_set is None:
    652652            index_set = self.index_set()
    653653        for i in index_set:
    654             if self.epsilon(i) != 0:
    655                 self = self.e(i)
     654            if self._epsilon(i) != 0:
     655                self = self._e(i)
    656656                hw = self.to_classical_highest_weight(index_set=index_set)
    657657                return [hw[0], [i] + hw[1]]
    658658        return [self, []]
    class KirillovReshetikhinTableauxElement 
    671671        """
    672672        return self.Phi() - self.Epsilon()
    673673
    674     def e(self, i):
     674    def _e(self, i):
    675675        """
    676676        Perform the action of `e_i` on ``self``.
    677677
    class KirillovReshetikhinTableauxElement 
    682682        EXAMPLES::
    683683
    684684            sage: KRT = KirillovReshetikhinTableaux(['D',4,1], 2,2)
    685             sage: KRT.module_generators[0].e(0)
     685            sage: KRT.module_generators[0]._e(0)
    686686            [[-2, 1], [-1, -1]]
    687687        """
    688688        if i == 0:
    class KirillovReshetikhinTableauxElement 
    690690            if ret is None:
    691691                return None
    692692            return ret.to_Kirillov_Reshetikhin_tableau()
    693         return TensorProductOfRegularCrystalsElement.e(self, i)
     693        return TensorProductOfRegularCrystalsElement._e(self, i)
    694694
    695     def f(self, i):
     695    def _f(self, i):
    696696        """
    697697        Perform the action of `f_i` on ``self``.
    698698
    class KirillovReshetikhinTableauxElement 
    703703        EXAMPLES::
    704704
    705705            sage: KRT = KirillovReshetikhinTableaux(['D',4,1], 2,2)
    706             sage: KRT.module_generators[0].f(0)
     706            sage: KRT.module_generators[0]._f(0)
    707707            [[1, 1], [2, -1]]
    708708        """
    709709        if i == 0:
    class KirillovReshetikhinTableauxElement 
    711711            if ret is None:
    712712                return None
    713713            return ret.to_Kirillov_Reshetikhin_tableau()
    714         return TensorProductOfRegularCrystalsElement.f(self, i)
     714        return TensorProductOfRegularCrystalsElement._f(self, i)
    715715
    716716KirillovReshetikhinTableaux.Element = KirillovReshetikhinTableauxElement
    717717
    class KRTableauxSpinElement(KirillovResh 
    722722    Here we are in the embedding `B(\Lambda_n) \to B(2 \Lambda_n)`, so `e_i`
    723723    and `f_i` act by `e_i^2` and `f_i^2` respectively.
    724724    """
    725     def e(self, i):
     725    def _e(self, i):
    726726        r"""
    727727        Calculate the action of `e_i` on ``self``.
    728728
    729729        EXAMPLES::
    730730
    731731            sage: KRT = KirillovReshetikhinTableaux(['D',4,1], 4, 1)
    732             sage: KRT([-1, -4, 3, 2]).e(1)
     732            sage: KRT([-1, -4, 3, 2])._e(1)
    733733            [[1], [3], [-4], [-2]]
    734             sage: KRT([-1, -4, 3, 2]).e(3)
     734            sage: KRT([-1, -4, 3, 2])._e(3)
    735735        """
    736         half = TensorProductOfRegularCrystalsElement.e(self, i)
     736        half = TensorProductOfRegularCrystalsElement._e(self, i)
    737737        if half is None:
    738738            return None
    739         return TensorProductOfRegularCrystalsElement.e(half, i)
     739        return TensorProductOfRegularCrystalsElement._e(half, i)
    740740
    741     def f(self, i):
     741    def _f(self, i):
    742742        r"""
    743743        Calculate the action of `f_i` on ``self``.
    744744
    745745        EXAMPLES::
    746746
    747747            sage: KRT = KirillovReshetikhinTableaux(['D',4,1], 4, 1)
    748             sage: KRT([-1, -4, 3, 2]).f(1)
    749             sage: KRT([-1, -4, 3, 2]).f(3)
     748            sage: KRT([-1, -4, 3, 2])._f(1)
     749            sage: KRT([-1, -4, 3, 2])._f(3)
    750750            [[2], [4], [-3], [-1]]
    751751        """
    752         half = TensorProductOfRegularCrystalsElement.f(self, i)
     752        half = TensorProductOfRegularCrystalsElement._f(self, i)
    753753        if half is None:
    754754            return None
    755755
    756         return TensorProductOfRegularCrystalsElement.f(half, i)
     756        return TensorProductOfRegularCrystalsElement._f(half, i)
    757757
    758     def epsilon(self, i):
     758    def _epsilon(self, i):
    759759        r"""
    760760        Compute `\epsilon_i` of ``self``.
    761761
    762762        EXAMPLES::
    763763
    764764            sage: KRT = KirillovReshetikhinTableaux(['D',4,1], 4, 1)
    765             sage: KRT([-1, -4, 3, 2]).epsilon(1)
     765            sage: KRT([-1, -4, 3, 2])._epsilon(1)
    766766            1
    767767            sage: KRT([-1, -4, 3, 2]).epsilon(3)
    768768            0
    769769        """
    770         return TensorProductOfRegularCrystalsElement.epsilon(self, i) / 2
     770        return TensorProductOfRegularCrystalsElement._epsilon(self, i) / 2
    771771
    772     def phi(self, i):
     772    def _phi(self, i):
    773773        r"""
    774774        Compute `\phi_i` of ``self``.
    775775
    776776        EXAMPLES::
    777777
    778778            sage: KRT = KirillovReshetikhinTableaux(['D',4,1], 4, 1)
    779             sage: KRT([-1, -4, 3, 2]).phi(1)
     779            sage: KRT([-1, -4, 3, 2])._phi(1)
    780780            0
    781             sage: KRT([-1, -4, 3, 2]).phi(3)
     781            sage: KRT([-1, -4, 3, 2])._phi(3)
    782782            1
    783783        """
    784         return TensorProductOfRegularCrystalsElement.phi(self, i) / 2
     784        return TensorProductOfRegularCrystalsElement._phi(self, i) / 2
    785785
    786786    @cached_method
    787787    def to_array(self, rows=True):
  • sage/combinat/rigged_configurations/rigged_configuration_element.py

    diff --git a/sage/combinat/rigged_configurations/rigged_configuration_element.py b/sage/combinat/rigged_configurations/rigged_configuration_element.py
    a b class RiggedConfigurationElement(Clonabl 
    561561        """
    562562        return list(self)
    563563
    564     def e(self, a):
     564    def _e(self, a):
    565565        r"""
    566566        Action of the crystal operator `e_a` on this rigged configuration element.
    567567
    class RiggedConfigurationElement(Clonabl 
    584584
    585585            sage: RC = RiggedConfigurations(['A', 4, 1], [[2,1]])
    586586            sage: elt = RC(partition_list=[[1], [1], [1], [1]])
    587             sage: elt.e(3)
    588             sage: elt.e(1)
     587            sage: elt._e(3)
     588            sage: elt._e(1)
    589589            <BLANKLINE>
    590590            (/)
    591591            <BLANKLINE>
    class RiggedConfigurationElement(Clonabl 
    596596            -1[ ]-1
    597597            <BLANKLINE>
    598598        """
    599         assert a in self.parent()._cartan_type.index_set()
    600599        if a == 0:
    601600            raise NotImplementedError("Only classical crystal operators implemented")
    602601
    class RiggedConfigurationElement(Clonabl 
    709708
    710709        return(RiggedPartition(new_list, new_rigging, new_vac_nums))
    711710
    712     def f(self, a):
     711    def _f(self, a):
    713712        r"""
    714713        Action of crystal operator `f_a` on this rigged configuration element.
    715714
    class RiggedConfigurationElement(Clonabl 
    734733
    735734            sage: RC = RiggedConfigurations(['A', 4, 1], [[2,1]])
    736735            sage: elt = RC(partition_list=[[1], [1], [1], [1]])
    737             sage: elt.f(1)
    738             sage: elt.f(2)
     736            sage: elt._f(1)
     737            sage: elt._f(2)
    739738            <BLANKLINE>
    740739            0[ ]0
    741740            <BLANKLINE>
    class RiggedConfigurationElement(Clonabl 
    747746            -1[ ]-1
    748747            <BLANKLINE>
    749748        """
    750         assert a in self.parent()._cartan_type.index_set()
    751749        if a == 0:
    752750            raise NotImplementedError("Only classical crystal operators implemented")
    753751
  • sage/combinat/rigged_configurations/tensor_product_kr_tableaux_element.py

    diff --git a/sage/combinat/rigged_configurations/tensor_product_kr_tableaux_element.py b/sage/combinat/rigged_configurations/tensor_product_kr_tableaux_element.py
    a b class TensorProductOfKirillovReshetikhin 
    157157            retStr += " (X) " + repr(self[i])
    158158        return(retStr)
    159159
    160     def e(self, i):
     160    def _e(self, i):
    161161        r"""
    162162        Return the action of `e_i` on ``self``.
    163163
    class TensorProductOfKirillovReshetikhin 
    165165
    166166            sage: KRT = TensorProductOfKirillovReshetikhinTableaux(['D', 4, 1], [[2,1]])
    167167            sage: T = KRT(pathlist=[[4,3]])
    168             sage: T.e(1)
    169             sage: T.e(2)
     168            sage: T._e(1)
     169            sage: T._e(2)
    170170            [[2], [4]]
    171171        """
    172172        if i != 0:
    173             return TensorProductOfRegularCrystalsElement.e(self, i)
     173            return TensorProductOfRegularCrystalsElement._e(self, i)
    174174
    175175        return None
    176176
    177     def f(self, i):
     177    def _f(self, i):
    178178        r"""
    179179        Return the action of `f_i` on ``self``.
    180180
    class TensorProductOfKirillovReshetikhin 
    182182
    183183            sage: KRT = TensorProductOfKirillovReshetikhinTableaux(['D', 4, 1], [[2,1]])
    184184            sage: T = KRT(pathlist=[[4,3]])
    185             sage: T.f(1)
    186             sage: T.f(4)
     185            sage: T._f(1)
     186            sage: T._f(4)
    187187            [[-4], [4]]
    188188        """
    189189        if i != 0:
    190             return TensorProductOfRegularCrystalsElement.f(self, i)
     190            return TensorProductOfRegularCrystalsElement._f(self, i)
    191191
    192192        return None
    193193