def __init__(self, cartan_type, shapes):
"""
Construct the crystal of all tableaux of the given shapes.
INPUT:
- ``cartan_type`` -- (data coercible into) a Cartan type
- ``shapes`` -- a list (or iterable) of shapes
- ``shape`` -- a shape
Shapes themselves are lists (or iterable) of integers.
EXAMPLES::
sage: T = crystals.Tableaux(['A',3], shape = [2,2])
sage: TestSuite(T).run()
"""
# super(CrystalOfTableaux, self).__init__(category = FiniteEnumeratedSets())
Parent.__init__(self, category=ClassicalCrystals())
self.letters = CrystalOfLetters(cartan_type)
self.shapes = shapes
self.module_generators = tuple(
self.module_generator(la) for la in shapes)
self.rename("The crystal of tableaux of type %s and shape(s) %s" %
(cartan_type, list(list(shape) for shape in shapes)))
def __init__(self, ct, La):
r"""
EXAMPLES::
sage: La = RootSystem(['A',2]).weight_lattice().fundamental_weights()
sage: M = crystals.NakajimaMonomials(['A',2], La[1]+La[2])
sage: TestSuite(M).run()
sage: La = RootSystem(['C',2,1]).weight_lattice(extended=True).fundamental_weights()
sage: M = crystals.NakajimaMonomials(['C',2,1], La[0])
sage: TestSuite(M).run(max_runs=100)
"""
if ct.is_finite():
cat = ClassicalCrystals()
else:
cat = (RegularCrystals(), HighestWeightCrystals(),
InfiniteEnumeratedSets())
InfinityCrystalOfNakajimaMonomials.__init__(
self, ct, cat, CrystalOfNakajimaMonomialsElement)
self._cartan_type = ct
self.hw = La
gen = {}
for j in range(len(La.support())):
gen[(La.support()[j], 0)] = La.coefficients()[j]
self.module_generators = (self.element_class(self, gen), )
def __init__(self, ct, element_class, case):
"""
EXAMPLES::
sage: E = CrystalOfSpinsMinus(['D',4])
sage: TestSuite(E).run()
"""
self._cartan_type = CartanType(ct)
if case == "spins":
self.rename("The crystal of spins for type %s"%ct)
elif case == "plus":
self.rename("The plus crystal of spins for type %s"%ct)
else:
self.rename("The minus crystal of spins for type %s"%ct)
self.Element = element_class
# super(GenericCrystalOfSpins, self).__init__(category = FiniteEnumeratedSets())
Parent.__init__(self, category = ClassicalCrystals())
if case == "minus":
generator = [1]*(ct[1]-1)
generator.append(-1)
else:
generator = [1]*ct[1]
self.module_generators = [self(generator)]
self._list = list(self)
# self._digraph = ClassicalCrystal.digraph(self)
self._digraph = super(GenericCrystalOfSpins, self).digraph()
self._digraph_closure = self.digraph().transitive_closure()
def __init__(self, dominant_weight):
"""
EXAMPLES::
sage: C=CartanType(['E',6])
sage: La=C.root_system().weight_lattice().fundamental_weights()
sage: T = HighestWeightCrystal(2*La[2])
sage: T.cartan_type()
['E', 6]
sage: T.module_generators
[[[[2, -1], [1]], [[2, -1], [1]]]]
sage: T.cardinality()
2430
sage: T = HighestWeightCrystal(La[2])
sage: T.cardinality()
78
"""
self._cartan_type = dominant_weight.parent().cartan_type()
self._highest_weight = dominant_weight
assert dominant_weight.is_dominant()
self.rename(
"Finite dimensional highest weight crystal of type %s and highest weight %s"
% (self._cartan_type, dominant_weight))
Parent.__init__(self, category=ClassicalCrystals())
self.module_generators = [self.module_generator()]
def __init__(self, wt, WLR):
r"""
Initialize ``self``.
EXAMPLES::
sage: La = RootSystem(['A', 2]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(La[1] + La[2])
sage: TestSuite(RC).run()
sage: La = RootSystem(['A', 2, 1]).weight_lattice().fundamental_weights()
sage: RC = crystals.RiggedConfigurations(La[0])
sage: TestSuite(RC).run() # long time
"""
self._cartan_type = WLR.cartan_type()
self._wt = wt
self._rc_index = self._cartan_type.index_set()
self._rc_index_inverse = {i: ii for ii, i in enumerate(self._rc_index)}
# We store the Cartan matrix for the vacancy number calculations for speed
self._cartan_matrix = self._cartan_type.cartan_matrix()
if self._cartan_type.is_finite():
category = ClassicalCrystals()
else:
category = (RegularCrystals(), HighestWeightCrystals(),
InfiniteEnumeratedSets())
Parent.__init__(self, category=category)
n = self._cartan_type.rank() #== len(self._cartan_type.index_set())
self.module_generators = (self.element_class(
self, partition_list=[[] for i in range(n)]), )
def __init__(self, w, n, x=None):
r"""
EXAMPLES::
sage: B = crystals.AffineFactorization([[3,2],[2]],4,x=0,k=3)
Traceback (most recent call last):
...
ValueError: x cannot be in reduced word of s0*s3*s2
sage: B = crystals.AffineFactorization([[3,2],[2]],4,k=3)
sage: B.x
1
sage: B.w
s0*s3*s2
sage: B.k
3
sage: B.n
4
TESTS::
sage: W = WeylGroup(['A',3,1], prefix='s')
sage: w = W.from_reduced_word([2,3,2,1])
sage: B = crystals.AffineFactorization(w,3)
sage: TestSuite(B).run()
"""
Parent.__init__(self, category=ClassicalCrystals())
self.n = n
self.k = w.parent().n - 1
self.w = w
cartan_type = CartanType(['A', n - 1])
self._cartan_type = cartan_type
from sage.combinat.sf.sf import SymmetricFunctions
from sage.rings.rational_field import QQ
Sym = SymmetricFunctions(QQ)
s = Sym.schur()
support = s(w.stanley_symmetric_function()).support()
support = [[0] * (n - len(mu)) +
[mu[len(mu) - i - 1] for i in range(len(mu))]
for mu in support]
generators = [
tuple(p) for mu in support
for p in affine_factorizations(w, n, mu)
]
#generators = [tuple(p) for p in affine_factorizations(w, n)]
self.module_generators = [self(t) for t in generators]
if x is None:
if generators:
x = min(
set(range(self.k + 1)).difference(
set(sum([i.reduced_word() for i in generators[0]],
[]))))
else:
x = 0
if x in set(w.reduced_word()):
raise ValueError("x cannot be in reduced word of {}".format(w))
self.x = x
def __init__(self, n=3):
"""
EXAMPLES::
sage: C = sage.categories.examples.crystals.HighestWeightCrystalOfTypeA(n=4)
sage: C == Crystals().example(n=4)
True
"""
Parent.__init__(self, category=ClassicalCrystals())
self.n = n
self._cartan_type = CartanType(['A', n])
self.module_generators = [self(1)]
def __init__(self, starting_weight):
"""
EXAMPLES::
sage: C = crystals.LSPaths(['A',2,1],[-1,0,1]); C
The crystal of LS paths of type ['A', 2, 1] and weight -Lambda[0] + Lambda[2]
sage: C.R
Root system of type ['A', 2, 1]
sage: C.weight
-Lambda[0] + Lambda[2]
sage: C.weight.parent()
Extended weight space over the Rational Field of the Root system of type ['A', 2, 1]
sage: C.module_generators
[(-Lambda[0] + Lambda[2],)]
TESTS::
sage: C = crystals.LSPaths(['A',2,1], [-1,0,1])
sage: TestSuite(C).run() # long time
sage: C = crystals.LSPaths(['E',6], [1,0,0,0,0,0])
sage: TestSuite(C).run()
"""
cartan_type = starting_weight.parent().cartan_type()
self.R = RootSystem(cartan_type)
self.weight = starting_weight
if not self.weight.parent().base_ring().has_coerce_map_from(QQ):
raise ValueError(
"Please use the weight space, rather than weight lattice for your weights"
)
self._cartan_type = cartan_type
self._name = "The crystal of LS paths of type %s and weight %s" % (
cartan_type, starting_weight)
if cartan_type.is_affine():
if all(i >= 0 for i in starting_weight.coefficients()):
Parent.__init__(self,
category=(RegularCrystals(),
HighestWeightCrystals(),
InfiniteEnumeratedSets()))
elif starting_weight.parent().is_extended():
Parent.__init__(self,
category=(RegularCrystals(),
InfiniteEnumeratedSets()))
else:
Parent.__init__(self,
category=(RegularCrystals(), FiniteCrystals()))
else:
Parent.__init__(self, category=ClassicalCrystals())
if starting_weight == starting_weight.parent().zero():
initial_element = self(tuple([]))
else:
initial_element = self(tuple([starting_weight]))
self.module_generators = [initial_element]
def __init__(self, cartan_type):
r"""
Initialize ``self``.
EXAMPLES::
sage: B = crystals.elementary.Component("D4")
sage: TestSuite(B).run()
"""
Parent.__init__(self, category=ClassicalCrystals())
self._cartan_type = cartan_type
self.module_generators = (self.element_class(self), )
def __init__(self):
"""
EXAMPLES::
sage: C = sage.categories.examples.crystals.NaiveCrystal()
sage: C == Crystals().example(choice='naive')
True
"""
Parent.__init__(self, category = ClassicalCrystals())
self.n = 2
self._cartan_type = CartanType(['A',2])
self.G = DiGraph(5)
self.G.add_edges([ [0,1,1], [1,2,1], [2,3,1], [3,5,1], [0,4,2], [4,5,2] ])
self.module_generators = [ self(0) ]
def __init__(self, w, factors, excess):
"""
Initialize a crystal for ``self`` given reduced word ``w`` in the symmetric group,
number of factors ``factors`` and``excess`` extra letters.
EXAMPLES::
sage: S = SymmetricGroup(3+1)
sage: w = S.from_reduced_word([1, 3, 2])
sage: B = crystals.FullyCommutativeStableGrothendieck(w, 3, 2)
sage: B.w
(1, 3, 2)
sage: B.factors
3
sage: B.excess
2
sage: B.H
0-Hecke monoid of the Symmetric group of order 4! as a permutation group
The reduced word ``w`` should be fully commutative, that is, its
associated permutation should avoid the pattern 321::
sage: S = SymmetricGroup(3+1)
sage: w = S.from_reduced_word([1, 2, 1])
sage: B = crystals.FullyCommutativeStableGrothendieck(w, 4, 2)
Traceback (most recent call last):
...
ValueError: w should be fully commutative
TESTS::
sage: S = SymmetricGroup(3+1)
sage: w = S.from_reduced_word([2, 3, 1])
sage: B = crystals.FullyCommutativeStableGrothendieck(w, 4, 2)
sage: TestSuite(B).run()
"""
# Check if w is fully commutative
word = w.reduced_word()
p = permutation.from_reduced_word(word)
if p.has_pattern([3, 2, 1]):
raise ValueError("w should be fully commutative")
Parent.__init__(self, category=ClassicalCrystals())
self.w = tuple(word)
self.factors = factors
self.H = w.parent()
self.max_value = len(self.H.gens())
self.excess = excess
self._cartan_type = CartanType(['A', self.factors - 1])
def __init__(self, ct, La, c):
r"""
EXAMPLES::
sage: La = RootSystem(['A',2]).weight_lattice().fundamental_weights()
sage: M = crystals.NakajimaMonomials(['A',2], La[1]+La[2])
sage: TestSuite(M).run()
sage: La = RootSystem(['C',2,1]).weight_lattice(extended=True).fundamental_weights()
sage: M = crystals.NakajimaMonomials(['C',2,1], La[0])
sage: TestSuite(M).run(max_runs=100)
"""
if ct.is_finite():
cat = ClassicalCrystals()
else:
cat = (RegularCrystals(), HighestWeightCrystals(), InfiniteEnumeratedSets())
InfinityCrystalOfNakajimaMonomials.__init__(self, ct, c, cat)
self._cartan_type = ct
self.hw = La
gen = {(i,0): c for i,c in La}
self.module_generators = (self.element_class(self, gen, {}),)
def __init__(self, cartan_type, highest_weight):
"""
EXAMPLES::
sage: C = ClassicalCrystalOfAlcovePaths(['A',3],[1,0,0])
sage: C.list()
[[], [0], [0, 1], [0, 1, 2]]
sage: TestSuite(C).run()
"""
Parent.__init__(self, category=ClassicalCrystals())
self._cartan_type = CartanType(cartan_type)
self._name = "The crystal of alcove paths for type %s" % cartan_type
self.chain_cache = {}
self.endweight_cache = {}
self.R = RootSystem(cartan_type)
alpha = self.R.root_space().simple_roots()
Lambda = self.R.weight_space().basis()
self.positive_roots = sorted(self.R.root_space().positive_roots())
self.weight = Lambda[Integer(1)] - Lambda[Integer(1)]
offset = self.R.index_set()[Integer(0)]
for j in self.R.index_set():
self.weight = self.weight + highest_weight[j - offset] * Lambda[j]
self.initial_element = self([])
self.initial_element.chain = self.get_initial_chain(self.weight)
rho = (Integer(1) / Integer(2)) * sum(self.positive_roots)
self.initial_element.endweight = rho
self.chain_cache[str([])] = self.initial_element.chain
self.endweight_cache[str([])] = self.initial_element.endweight
self.module_generators = [self.initial_element]
self._list = super(ClassicalCrystalOfAlcovePaths, self).list()
self._digraph = super(ClassicalCrystalOfAlcovePaths, self).digraph()
self._digraph_closure = self.digraph().transitive_closure()
def __init__(self, dominant_weight):
"""
EXAMPLES::
sage: C = CartanType(['E',6])
sage: La = C.root_system().weight_lattice().fundamental_weights()
sage: T = crystals.HighestWeight(2*La[2])
sage: T.cartan_type()
['E', 6]
sage: T.module_generators
[[[(2, -1), (1,)], [(2, -1), (1,)]]]
sage: T.cardinality()
2430
sage: T = crystals.HighestWeight(La[2])
sage: T.cardinality()
78
"""
self._cartan_type = dominant_weight.parent().cartan_type()
self._highest_weight = dominant_weight
assert dominant_weight.is_dominant()
self.rename()
Parent.__init__(self, category = ClassicalCrystals())
self.module_generators = [self.module_generator()]
def __init__(self, ct, element_class, case):
"""
EXAMPLES::
sage: E = crystals.SpinsMinus(['D',4])
sage: TestSuite(E).run()
"""
self._cartan_type = CartanType(ct)
if case == "spins":
self.rename("The crystal of spins for type %s" % ct)
elif case == "plus":
self.rename("The plus crystal of spins for type %s" % ct)
else:
self.rename("The minus crystal of spins for type %s" % ct)
self.Element = element_class
Parent.__init__(self, category=ClassicalCrystals())
if case == "minus":
generator = [1] * (ct[1] - 1)
generator.append(-1)
else:
generator = [1] * ct[1]
self.module_generators = (self.element_class(self, tuple(generator)), )
def __init__(self, ct, shape, format):
"""
EXAMPLES::
sage: C = crystals.FastRankTwo(['A',2],shape=[4,1]); C
The fast crystal for A2 with shape [4,1]
sage: TestSuite(C).run()
"""
Parent.__init__(self, category = ClassicalCrystals())
# super(FastCrystal, self).__init__(category = FiniteEnumeratedSets())
self._cartan_type = ct
if ct[1] != 2:
raise NotImplementedError
l1 = shape[0]
l2 = shape[1]
# For safety, delpat and gampat should be immutable
self.delpat = []
self.gampat = []
if ct[0] == 'A':
self._type_a_init(l1, l2)
elif ct[0] == 'B' or ct[0] == 'C':
self._type_bc_init(l1, l2)
else:
raise NotImplementedError
self.format = format
self.size = len(self.delpat)
self._rootoperators = []
self.shape = shape
for i in range(self.size):
target = [x for x in self.delpat[i]]
target[0] = target[0]-1
e1 = None if target not in self.delpat else self.delpat.index(target)
target[0] = target[0]+1+1
f1 = None if target not in self.delpat else self.delpat.index(target)
target = [x for x in self.gampat[i]]
target[0] = target[0]-1
e2 = None if target not in self.gampat else self.gampat.index(target)
target[0] = target[0]+1+1
f2 = None if target not in self.gampat else self.gampat.index(target)
self._rootoperators.append([e1,f1,e2,f2])
if int(2*l1)%2 == 0:
l1_str = "%d"%l1
l2_str = "%d"%l2
else:
assert self._cartan_type[0] == 'B' and int(2*l2)%2 == 1
l1_str = "%d/2"%int(2*l1)
l2_str = "%d/2"%int(2*l2)
self.rename("The fast crystal for %s2 with shape [%s,%s]"%(ct[0],l1_str,l2_str))
self.module_generators = [self(0)]
# self._list = ClassicalCrystal.list(self)
self._list = super(FastCrystal, self).list()
# self._digraph = ClassicalCrystal.digraph(self)
self._digraph = super(FastCrystal, self).digraph()
self._digraph_closure = self.digraph().transitive_closure()
