CoCalc -- highest_weight

GitHub Repository: sagemath/sagesmc
Path: blob/master/src/sage/combinat/crystals/highest_weight_crystals.py
⁸⁸¹⁷ views
1
r"""
2
Highest weight crystals
3
"""
4

5
#*****************************************************************************
6
#       Copyright (C) 2009   Anne Schilling <anne at math.ucdavis.edu>
7
#
8
#  Distributed under the terms of the GNU General Public License (GPL)
9
#
10
#    This code is distributed in the hope that it will be useful,
11
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
12
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
#    General Public License for more details.
14
#
15
#  The full text of the GPL is available at:
16
#
17
#                  http://www.gnu.org/licenses/
18
#****************************************************************************
19

20
from sage.categories.classical_crystals import ClassicalCrystals
21
from sage.structure.parent import Parent
22
from sage.combinat.root_system.cartan_type import CartanType
23
from sage.combinat.crystals.letters import CrystalOfLetters
24
from sage.combinat.crystals.tensor_product import TensorProductOfCrystals, \
25
    TensorProductOfRegularCrystalsElement
26
from sage.combinat.crystals.littelmann_path import CrystalOfLSPaths
27

28

29
def HighestWeightCrystal(dominant_weight):
30
    r"""
31
    Returns an implementation of the highest weight crystal of highest weight `dominant_weight`.
32

33
    This is currently only implemented for crystals of type `E_6` and `E_7`.
34

35
    TODO: implement highest weight crystals for classical types `A_n`, `B_n`, `C_n`, `D_n` using tableaux.
36

37
    EXAMPLES::
38

39
        sage: C=CartanType(['E',6])
40
        sage: La=C.root_system().weight_lattice().fundamental_weights()
41
        sage: T = HighestWeightCrystal(La[1])
42
        sage: T.cardinality()
43
        27
44
        sage: T = HighestWeightCrystal(La[6])
45
        sage: T.cardinality()
46
        27
47
        sage: T = HighestWeightCrystal(La[2])
48
        sage: T.cardinality()
49
        78
50
        sage: T = HighestWeightCrystal(La[4])
51
        sage: T.cardinality()
52
        2925
53
        sage: T = HighestWeightCrystal(La[3])
54
        sage: T.cardinality()
55
        351
56
        sage: T = HighestWeightCrystal(La[5])
57
        sage: T.cardinality()
58
        351
59

60
        sage: C=CartanType(['E',7])
61
        sage: La=C.root_system().weight_lattice().fundamental_weights()
62
        sage: T = HighestWeightCrystal(La[1])
63
        sage: T.cardinality()
64
        133
65
        sage: T = HighestWeightCrystal(La[2])
66
        sage: T.cardinality()
67
        912
68
        sage: T = HighestWeightCrystal(La[3])
69
        sage: T.cardinality()
70
        8645
71
        sage: T = HighestWeightCrystal(La[4])
72
        sage: T.cardinality()
73
        365750
74
        sage: T = HighestWeightCrystal(La[5])
75
        sage: T.cardinality()
76
        27664
77
        sage: T = HighestWeightCrystal(La[6])
78
        sage: T.cardinality()
79
        1539
80
        sage: T = HighestWeightCrystal(La[7])
81
        sage: T.cardinality()
82
        56
83

84
        sage: C = CartanType(['C',2,1])
85
        sage: La = C.root_system().weight_lattice().fundamental_weights()
86
        sage: T = HighestWeightCrystal(La[1])
87
        sage: [p for p in T.subcrystal(max_depth=3)]
88
        [(Lambda[1],), (Lambda[0] - Lambda[1] + Lambda[2],), (-Lambda[0] + Lambda[1] + Lambda[2] - delta,),
89
        (Lambda[0] + Lambda[1] - Lambda[2],), (-Lambda[0] + 3*Lambda[1] - Lambda[2] - delta,), (2*Lambda[0] - Lambda[1],),
90
        (-Lambda[1] + 2*Lambda[2] - delta,)]
91
    """
92
    cartan_type = dominant_weight.parent().cartan_type()
93
    if cartan_type.is_finite() and cartan_type.type() in ['A','B','C','D']:
94
        raise NotImplementedError
95
    elif cartan_type == CartanType(['E',6]):
96
        return FiniteDimensionalHighestWeightCrystal_TypeE6(dominant_weight)
97
    elif cartan_type == CartanType(['E',7]):
98
        return FiniteDimensionalHighestWeightCrystal_TypeE7(dominant_weight)
99
    elif cartan_type.is_affine():
100
        return CrystalOfLSPaths(cartan_type,[dominant_weight[i] for i in cartan_type.index_set()])
101
    else:
102
        raise NotImplementedError
103

104
class FiniteDimensionalHighestWeightCrystal_TypeE(TensorProductOfCrystals):
105
    """
106
    Commonalities for all finite dimensional type E highest weight crystals
107

108
    Subclasses should setup an attribute column_crystal in their
109
    __init__ method before calling the __init__ method of this class.
110
    """
111

112
    def __init__(self, dominant_weight):
113
        """
114
        EXAMPLES::
115

116
            sage: C=CartanType(['E',6])
117
            sage: La=C.root_system().weight_lattice().fundamental_weights()
118
            sage: T = HighestWeightCrystal(2*La[2])
119
            sage: T.cartan_type()
120
            ['E', 6]
121
            sage: T.module_generators
122
            [[[(2, -1), (1,)], [(2, -1), (1,)]]]
123
            sage: T.cardinality()
124
            2430
125
            sage: T = HighestWeightCrystal(La[2])
126
            sage: T.cardinality()
127
            78
128
        """
129
        self._cartan_type = dominant_weight.parent().cartan_type()
130
        self._highest_weight = dominant_weight
131
        assert dominant_weight.is_dominant()
132
        self.rename("Finite dimensional highest weight crystal of type %s and highest weight %s"%(self._cartan_type, dominant_weight))
133
        Parent.__init__(self, category = ClassicalCrystals())
134
        self.module_generators = [self.module_generator()]
135

136
    Element = TensorProductOfRegularCrystalsElement
137

138
    def module_generator(self):
139
        """
140
        This yields the module generator (or highest weight element) of the classical
141
        crystal of given dominant weight in self.
142

143
        EXAMPLES::
144

145
            sage: C=CartanType(['E',6])
146
            sage: La=C.root_system().weight_lattice().fundamental_weights()
147
            sage: T = HighestWeightCrystal(La[2])
148
            sage: T.module_generator()
149
            [[(2, -1), (1,)]]
150
            sage: T = HighestWeightCrystal(0*La[2])
151
            sage: T.module_generator()
152
            []
153

154
            sage: C=CartanType(['E',7])
155
            sage: La=C.root_system().weight_lattice().fundamental_weights()
156
            sage: T = HighestWeightCrystal(La[1])
157
            sage: T.module_generator()
158
            [[(-7, 1), (7,)]]
159
        """
160
        dominant_weight = self._highest_weight
161
        tensor = sum(( [self.column_crystal[i]]*dominant_weight.coefficient(i) for i in dominant_weight.support()), [])
162
        return self._element_constructor_(*[B.module_generators[0] for B in tensor])
163

164
class FiniteDimensionalHighestWeightCrystal_TypeE6(FiniteDimensionalHighestWeightCrystal_TypeE):
165
    r"""
166
    Class of finite dimensional highest weight crystals of type `E_6`.
167

168
    EXAMPLES::
169

170
        sage: C=CartanType(['E',6])
171
        sage: La=C.root_system().weight_lattice().fundamental_weights()
172
        sage: T = HighestWeightCrystal(La[2]); T
173
        Finite dimensional highest weight crystal of type ['E', 6] and highest weight Lambda[2]
174
        sage: B1 = T.column_crystal[1]; B1
175
        The crystal of letters for type ['E', 6]
176
        sage: B6 = T.column_crystal[6]; B6
177
        The crystal of letters for type ['E', 6] (dual)
178
        sage: t = T(B6([-1]),B1([-1,3])); t
179
        [(-1,), (-1, 3)]
180
        sage: [t.epsilon(i) for i in T.index_set()]
181
        [2, 0, 0, 0, 0, 0]
182
        sage: [t.phi(i) for i in T.index_set()]
183
        [0, 0, 1, 0, 0, 0]
184
        sage: TestSuite(t).run()
185
    """
186

187
    def __init__(self, dominant_weight):
188
        """
189
        EXAMPLES::
190

191
            sage: C=CartanType(['E',6])
192
            sage: La=C.root_system().weight_lattice().fundamental_weights()
193
            sage: p2=2*La[2]
194
            sage: p1=La[2]
195
            sage: p0=0*La[2]
196
            sage: T = HighestWeightCrystal(0*La[2])
197
            sage: T.cardinality()
198
            1
199
            sage: T = HighestWeightCrystal(La[2])
200
            sage: T.cardinality()
201
            78
202
            sage: T = HighestWeightCrystal(2*La[2])
203
            sage: T.cardinality()
204
            2430
205
        """
206
        B1 = CrystalOfLetters(['E',6])
207
        B6 = CrystalOfLetters(['E',6], dual = True)
208
        self.column_crystal = {1 : B1, 6 : B6,
209
                               4 : TensorProductOfCrystals(B1,B1,B1,generators=[[B1([-3,4]),B1([-1,3]),B1([1])]]),
210
                               3 : TensorProductOfCrystals(B1,B1,generators=[[B1([-1,3]),B1([1])]]),
211
                               5 : TensorProductOfCrystals(B6,B6,generators=[[B6([5,-6]),B6([6])]]),
212
                               2 : TensorProductOfCrystals(B6,B1,generators=[[B6([2,-1]),B1([1])]])}
213
        FiniteDimensionalHighestWeightCrystal_TypeE.__init__(self, dominant_weight)
214

215

216
class FiniteDimensionalHighestWeightCrystal_TypeE7(FiniteDimensionalHighestWeightCrystal_TypeE):
217
    r"""
218
    Class of finite dimensional highest weight crystals of type `E_7`.
219

220
    EXAMPLES::
221

222
        sage: C=CartanType(['E',7])
223
        sage: La=C.root_system().weight_lattice().fundamental_weights()
224
        sage: T = HighestWeightCrystal(La[1])
225
        sage: T.cardinality()
226
        133
227
        sage: B7 = T.column_crystal[7]; B7
228
        The crystal of letters for type ['E', 7]
229
        sage: t = T(B7([-5, 6]), B7([-2, 3])); t
230
        [(-5, 6), (-2, 3)]
231
        sage: [t.epsilon(i) for i in T.index_set()]
232
        [0, 1, 0, 0, 1, 0, 0]
233
        sage: [t.phi(i) for i in T.index_set()]
234
        [0, 0, 1, 0, 0, 1, 0]
235
        sage: TestSuite(t).run()
236
    """
237

238
    def __init__(self, dominant_weight):
239
        """
240
        EXAMPLES::
241

242
            sage: C=CartanType(['E',7])
243
            sage: La=C.root_system().weight_lattice().fundamental_weights()
244
            sage: T = HighestWeightCrystal(0*La[1])
245
            sage: T.cardinality()
246
            1
247
            sage: T = HighestWeightCrystal(La[1])
248
            sage: T.cardinality()
249
            133
250
            sage: T = HighestWeightCrystal(2*La[1])
251
            sage: T.cardinality()
252
            7371
253
        """
254
        B = CrystalOfLetters(['E',7])
255
        self.column_crystal = {7 : B,
256
                               1 : TensorProductOfCrystals(B,B,generators=[[B([-7,1]),B([7])]]),
257
                               2 : TensorProductOfCrystals(B,B,B,generators=[[B([-1,2]),B([-7,1]),B([7])]]),
258
                               3 : TensorProductOfCrystals(B,B,B,B,generators=[[B([-2,3]),B([-1,2]),B([-7,1]),B([7])]]),
259
                               4 : TensorProductOfCrystals(B,B,B,B,generators=[[B([-5,4]),B([-6,5]),B([-7,6]),B([7])]]),
260
                               5 : TensorProductOfCrystals(B,B,B,generators=[[B([-6,5]),B([-7,6]),B([7])]]),
261
                               6 : TensorProductOfCrystals(B,B,generators=[[B([-7,6]),B([7])]])}
262
        FiniteDimensionalHighestWeightCrystal_TypeE.__init__(self, dominant_weight)
263

264
Product

Resources

Company
