def __init__(self, crystals, **options):
"""
TESTS::
sage: from sage.combinat.crystals.tensor_product import FullTensorProductOfCrystals
sage: C = crystals.Letters(['A',2])
sage: T = crystals.TensorProduct(C,C)
sage: isinstance(T, FullTensorProductOfCrystals)
True
sage: TestSuite(T).run()
"""
category = Category.meet([crystal.category() for crystal in crystals])
category = category.TensorProducts()
if any(c in Sets().Infinite() for c in crystals):
category = category.Infinite()
Parent.__init__(self, category=category)
self.crystals = crystals
if 'cartan_type' in options:
self._cartan_type = CartanType(options['cartan_type'])
else:
if not crystals:
raise ValueError("you need to specify the Cartan type if the tensor product list is empty")
else:
self._cartan_type = crystals[0].cartan_type()
self.cartesian_product = cartesian_product(self.crystals)
self.module_generators = self
def __init__(self, crystals, **options):
"""
TESTS::
sage: from sage.combinat.crystals.tensor_product import FullTensorProductOfCrystals
sage: C = crystals.Letters(['A',2])
sage: T = crystals.TensorProduct(C,C)
sage: isinstance(T, FullTensorProductOfCrystals)
True
sage: TestSuite(T).run()
"""
category = Category.meet([crystal.category() for crystal in crystals])
category = category.TensorProducts()
if any(c in Sets().Infinite() for c in crystals):
category = category.Infinite()
Parent.__init__(self, category=category)
self.crystals = crystals
if 'cartan_type' in options:
self._cartan_type = CartanType(options['cartan_type'])
else:
if not crystals:
raise ValueError(
"you need to specify the Cartan type if the tensor product list is empty"
)
else:
self._cartan_type = crystals[0].cartan_type()
self.cartesian_product = cartesian_product(self.crystals)
self.module_generators = self
def __init__(self, crystals, **options):
"""
TESTS::
sage: from sage.combinat.crystals.tensor_product import FullTensorProductOfCrystals
sage: C = CrystalOfLetters(['A',2])
sage: T = TensorProductOfCrystals(C,C)
sage: isinstance(T, FullTensorProductOfCrystals)
True
sage: TestSuite(T).run()
"""
crystals = list(crystals)
category = Category.meet([crystal.category() for crystal in crystals])
Parent.__init__(self, category = category)
self.rename("Full tensor product of the crystals %s"%(crystals,))
self.crystals = crystals
if options.has_key('cartan_type'):
self._cartan_type = CartanType(options['cartan_type'])
else:
if len(crystals) == 0:
raise ValueError, "you need to specify the Cartan type if the tensor product list is empty"
else:
self._cartan_type = crystals[0].cartan_type()
self.cartesian_product = CartesianProduct(*self.crystals)
self.module_generators = self
def __init__(self, crystals, **options):
"""
TESTS::
sage: from sage.combinat.crystals.tensor_product import FullTensorProductOfCrystals
sage: C = CrystalOfLetters(['A',2])
sage: T = TensorProductOfCrystals(C,C)
sage: isinstance(T, FullTensorProductOfCrystals)
True
sage: TestSuite(T).run()
"""
crystals = list(crystals)
category = Category.meet([crystal.category() for crystal in crystals])
Parent.__init__(self, category = category)
self.rename("Full tensor product of the crystals %s"%(crystals,))
self.crystals = crystals
if options.has_key('cartan_type'):
self._cartan_type = CartanType(options['cartan_type'])
else:
if len(crystals) == 0:
raise ValueError, "you need to specify the Cartan type if the tensor product list is empty"
else:
self._cartan_type = crystals[0].cartan_type()
self.cartesian_product = CartesianProduct(*self.crystals)
self.module_generators = self
def category_from_categories(self, categories):
"""
Return the category of `F(A,B,...)` for `A,B,...` parents in
the given categories.
INPUT:
- ``self``: a functor `F`
- ``categories``: a non empty tuple of categories
EXAMPLES::
sage: Cat1 = Rings()
sage: Cat2 = Groups()
sage: cartesian_product.category_from_categories((Cat1, Cat1, Cat1))
Join of Category of rings and ...
and Category of Cartesian products of semigroups and ...
and Category of Cartesian products of commutative additive groups
sage: cartesian_product.category_from_categories((Cat1, Cat2))
Join of Category of monoids
and Category of Cartesian products of semigroups
and Category of Cartesian products of unital magmas
"""
assert(len(categories) > 0)
return self.category_from_category(Category.meet(categories))
def __classcall_private__(cls, crystals, facade=True, keepkey=False, category=None):
"""
Normalization of arguments; see :class:`UniqueRepresentation`.
TESTS:
We check that direct sum of crystals have unique representation::
sage: B = crystals.Tableaux(['A',2], shape=[2,1])
sage: C = crystals.Letters(['A',2])
sage: D1 = crystals.DirectSum([B, C])
sage: D2 = crystals.DirectSum((B, C))
sage: D1 is D2
True
sage: D3 = crystals.DirectSum([B, C, C])
sage: D4 = crystals.DirectSum([D1, C])
sage: D3 is D4
True
"""
if not isinstance(facade, bool) or not isinstance(keepkey, bool):
raise TypeError
# Normalize the facade-keepkey by giving keepkey dominance
facade = not keepkey
# We expand out direct sums of crystals
ret = []
for x in Family(crystals):
if isinstance(x, DirectSumOfCrystals):
ret += list(x.crystals)
else:
ret.append(x)
category = Category.meet([Category.join(c.categories()) for c in ret])
return super(DirectSumOfCrystals, cls).__classcall__(cls,
Family(ret), facade=facade, keepkey=keepkey, category=category)
def __init__(self, crystals, generators, cartan_type):
"""
EXAMPLES::
sage: C = crystals.Letters(['A',2])
sage: T = crystals.TensorProduct(C,C,C,generators=[[C(2),C(1),C(1)]])
sage: TestSuite(T).run()
"""
assert isinstance(crystals, tuple)
assert isinstance(generators, tuple)
category = Category.meet([crystal.category() for crystal in crystals])
Parent.__init__(self, category=category)
self.crystals = crystals
self._cartan_type = cartan_type
self.module_generators = tuple([self(*x) for x in generators])
def __init__(self, crystals, generators, cartan_type):
"""
EXAMPLES::
sage: C = crystals.Letters(['A',2])
sage: T = crystals.TensorProduct(C,C,C,generators=[[C(2),C(1),C(1)]])
sage: TestSuite(T).run()
"""
assert isinstance(crystals, tuple)
assert isinstance(generators, tuple)
category = Category.meet([crystal.category() for crystal in crystals])
Parent.__init__(self, category = category)
self.crystals = crystals
self._cartan_type = cartan_type
self.module_generators = tuple([self(*x) for x in generators])
def __init__(self, crystals, **options):
"""
TESTS::
sage: C = crystals.Letters(['A',2])
sage: B = crystals.DirectSum([C,C], keepkey=True)
sage: B
Direct sum of the crystals Family (The crystal of letters for type ['A', 2], The crystal of letters for type ['A', 2])
sage: B.cartan_type()
['A', 2]
sage: from sage.combinat.crystals.direct_sum import DirectSumOfCrystals
sage: isinstance(B, DirectSumOfCrystals)
True
"""
if 'keepkey' in options:
keepkey = options['keepkey']
else:
keepkey = False
# facade = options['facade']
if keepkey:
facade = False
else:
facade = True
category = Category.meet(
[Category.join(crystal.categories()) for crystal in crystals])
Parent.__init__(self, category=category)
DisjointUnionEnumeratedSets.__init__(self,
crystals,
keepkey=keepkey,
facade=facade)
self.rename("Direct sum of the crystals %s" % (crystals, ))
self._keepkey = keepkey
self.crystals = crystals
if len(crystals) == 0:
raise ValueError("The direct sum is empty")
else:
assert (crystal.cartan_type() == crystals[0].cartan_type()
for crystal in crystals)
self._cartan_type = crystals[0].cartan_type()
if keepkey:
self.module_generators = [
self(tuple([i, b])) for i in range(len(crystals))
for b in crystals[i].module_generators
]
else:
self.module_generators = sum(
(list(B.module_generators) for B in crystals), [])
def __classcall_private__(cls,
crystals,
facade=True,
keepkey=False,
category=None):
"""
Normalization of arguments; see :class:`UniqueRepresentation`.
TESTS:
We check that direct sum of crystals have unique representation::
sage: B = crystals.Tableaux(['A',2], shape=[2,1])
sage: C = crystals.Letters(['A',2])
sage: D1 = crystals.DirectSum([B, C])
sage: D2 = crystals.DirectSum((B, C))
sage: D1 is D2
True
sage: D3 = crystals.DirectSum([B, C, C])
sage: D4 = crystals.DirectSum([D1, C])
sage: D3 is D4
True
"""
if not isinstance(facade, bool) or not isinstance(keepkey, bool):
raise TypeError
# Normalize the facade-keepkey by giving keepkey dominance
if keepkey:
facade = False
else:
facade = True
# We expand out direct sums of crystals
ret = []
for x in Family(crystals):
if isinstance(x, DirectSumOfCrystals):
ret += list(x.crystals)
else:
ret.append(x)
category = Category.meet([Category.join(c.categories()) for c in ret])
return super(DirectSumOfCrystals, cls).__classcall__(cls,
Family(ret),
facade=facade,
keepkey=keepkey,
category=category)
def __init__(self, crystals, **options):
"""
TESTS::
sage: C = crystals.Letters(['A',2])
sage: B = crystals.DirectSum([C,C], keepkey=True)
sage: B
Direct sum of the crystals Family (The crystal of letters for type ['A', 2], The crystal of letters for type ['A', 2])
sage: B.cartan_type()
['A', 2]
sage: from sage.combinat.crystals.direct_sum import DirectSumOfCrystals
sage: isinstance(B, DirectSumOfCrystals)
True
"""
if "keepkey" in options:
keepkey = options["keepkey"]
else:
keepkey = False
# facade = options['facade']
if keepkey:
facade = False
else:
facade = True
category = Category.meet([Category.join(crystal.categories()) for crystal in crystals])
Parent.__init__(self, category=category)
DisjointUnionEnumeratedSets.__init__(self, crystals, keepkey=keepkey, facade=facade)
self.rename("Direct sum of the crystals %s" % (crystals,))
self._keepkey = keepkey
self.crystals = crystals
if len(crystals) == 0:
raise ValueError("The direct sum is empty")
else:
assert (crystal.cartan_type() == crystals[0].cartan_type() for crystal in crystals)
self._cartan_type = crystals[0].cartan_type()
if keepkey:
self.module_generators = [
self(tuple([i, b])) for i in range(len(crystals)) for b in crystals[i].module_generators
]
else:
self.module_generators = sum((list(B.module_generators) for B in crystals), [])
def category_from_categories(self, categories):
"""
Returns the category of `F(A,B,C)` for `A,B,C` parents in the given categories
INPUT:
- ``self``: a functor `F`
- ``categories``: a non empty tuple of categories
EXAMPLES::
sage: Cat1 = Rings()
sage: Cat2 = Groups()
sage: cartesian_product.category_from_categories((Cat1, Cat1, Cat1))
Category of Cartesian products of monoids
sage: cartesian_product.category_from_categories((Cat1, Cat2))
Category of Cartesian products of monoids
"""
assert(len(categories) > 0)
return self.category_from_category(Category.meet(categories))
