def __init__(self, set, function, name=None):
"""
TESTS::
sage: from sage.sets.family import LazyFamily
sage: f = LazyFamily([3,4,7], lambda i: 2*i); f
Lazy family (<lambda>(i))_{i in [3, 4, 7]}
sage: TestSuite(f).run()
Check for :trac:`5538`::
sage: l = [3,4,7]
sage: f = LazyFamily(l, lambda i: 2*i)
sage: l[1] = 18
sage: f
Lazy family (<lambda>(i))_{i in [3, 4, 7]}
"""
if set in FiniteEnumeratedSets():
category = FiniteEnumeratedSets()
elif set in InfiniteEnumeratedSets():
category = InfiniteEnumeratedSets()
elif isinstance(set, (list, tuple, range, CombinatorialClass)):
category = FiniteEnumeratedSets()
else:
category = EnumeratedSets()
Parent.__init__(self, category=category)
self.set = copy(set)
self.function = function
self.function_name = name
def __init__(self, set, function, name=None):
"""
TESTS::
sage: from sage.sets.family import LazyFamily
sage: f = LazyFamily([3,4,7], lambda i: 2*i); f
Lazy family (<lambda>(i))_{i in [3, 4, 7]}
sage: TestSuite(f).run() # __contains__ is not implemented
Failure ...
The following tests failed: _test_an_element, _test_enumerated_set_contains, _test_some_elements
Check for bug #5538::
sage: l = [3,4,7]
sage: f = LazyFamily(l, lambda i: 2*i);
sage: l[1] = 18
sage: f
Lazy family (<lambda>(i))_{i in [3, 4, 7]}
"""
from sage.combinat.combinat import CombinatorialClass # workaround #12482
if set in FiniteEnumeratedSets():
category = FiniteEnumeratedSets()
elif set in InfiniteEnumeratedSets():
category = InfiniteEnumeratedSets()
elif isinstance(set, (list, tuple, CombinatorialClass)):
category = FiniteEnumeratedSets()
else:
category = EnumeratedSets()
Parent.__init__(self, category=category)
from copy import copy
self.set = copy(set)
self.function = function
self.function_name = name
def __init_18449__(self, set, function, name=None):
"""
patched __init__ function from ticket #18449
"""
from sage.combinat.combinat import CombinatorialClass # workaround #12482
from sage.structure.parent import Parent
category = EnumeratedSets()
if set in FiniteEnumeratedSets():
category = FiniteEnumeratedSets()
elif set in InfiniteEnumeratedSets():
category = InfiniteEnumeratedSets()
elif isinstance(set, (list, tuple)):
category = FiniteEnumeratedSets()
elif isinstance(set, CombinatorialClass):
try:
if set.is_finite():
category = FiniteEnumeratedSets()
except NotImplementedError:
pass
Parent.__init__(self, category=category)
from copy import copy
self.set = copy(set)
self.function = function
self.function_name = name
def __init__(self, family, facade=True, keepkey=False, category=None):
"""
TESTS::
sage: U = DisjointUnionEnumeratedSets({1: FiniteEnumeratedSet([1,2,3]),
....: 2: FiniteEnumeratedSet([4,5,6])})
sage: TestSuite(U).run()
sage: X = DisjointUnionEnumeratedSets({i: Partitions(i) for i in range(5)})
sage: TestSuite(X).run()
"""
self._family = family
self._facade = facade
if facade:
if family in FiniteEnumeratedSets():
self._facade_for = tuple(family)
else:
# This allows the test suite to pass its tests by essentially
# stating that this is a facade for any parent. Technically
# this is wrong, but in practice, it will not have much
# of an effect.
self._facade_for = True
self._keepkey = keepkey
if self._is_category_initialized():
return
if category is None:
# try to guess if the result is infinite or not.
if self._family in InfiniteEnumeratedSets():
category = InfiniteEnumeratedSets()
elif self._family.last().cardinality() == Infinity:
category = InfiniteEnumeratedSets()
else:
category = FiniteEnumeratedSets()
Parent.__init__(self, facade=facade, category=category)
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 basis(self, reg=None):
from sage.sets.set import Set
assert hasattr(self, "_domain")
from functools import partial
from sage.sets.set_from_iterator import EnumeratedSetFromIterator
if reg is None:
reg = region()
reg = reg.intersect(self.bbox())
reg2 = (reg + self._totaloff).var_mult(
dict(list(zip(("t", "e", "s"), self._signs))))
iterfunc = partial(self.__degree_walker_tc,
idx=len(self._factors) - 1,
elems=[],
reg=reg2)
sz = 0
for var in ("t", "e", "s"):
ma, mi = reg.max(var), reg.min(var)
if mi > ma:
return Set(())
sz += ma - mi
category = (FiniteEnumeratedSets()
if sz < +Infinity else InfiniteEnumeratedSets())
return EnumeratedSetFromIterator(
iterfunc,
category=category,
cache=False,
name="basis in %s of %s" % (reg, self._domain),
)
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, 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, begin, end, step=Integer(1), middle_point=Integer(1)):
r"""
TESTS::
sage: from sage.sets.integer_range import IntegerRangeFromMiddle
sage: I = IntegerRangeFromMiddle(-100,100,10,0)
sage: I.category()
Category of facade finite enumerated sets
sage: TestSuite(I).run()
sage: I = IntegerRangeFromMiddle(Infinity,-Infinity,-37,0)
sage: I.category()
Category of facade infinite enumerated sets
sage: TestSuite(I).run()
sage: IntegerRange(0, 5, 1, -3)
Traceback (most recent call last):
...
ValueError: middle_point is not in the interval
"""
self._begin = begin
self._end = end
self._step = step
self._middle_point = middle_point
if not middle_point in self:
raise ValueError("middle_point is not in the interval")
if (begin != Infinity and begin != -Infinity) and \
(end != Infinity and end != -Infinity):
Parent.__init__(self,
facade=IntegerRing(),
category=FiniteEnumeratedSets())
else:
Parent.__init__(self,
facade=IntegerRing(),
category=InfiniteEnumeratedSets())
def __init__(self, weights):
"""
TESTS::
sage: C = WeightedIntegerVectors([2,1,3])
sage: C.__class__
<class 'sage.combinat.integer_vector_weighted.WeightedIntegerVectors_all_with_category'>
sage: C.category()
Join of Category of sets with grading and Category of infinite enumerated sets
sage: TestSuite(C).run()
"""
self._weights = weights
from sage.sets.all import Family, NonNegativeIntegers
# Use "partial" to make the basis function (with the weights
# argument specified) pickleable. Otherwise, it seems to
# cause problems...
from functools import partial
F = Family(NonNegativeIntegers(),
partial(WeightedIntegerVectors, weight=weights))
DisjointUnionEnumeratedSets.__init__(
self,
F,
facade=True,
keepkey=False,
category=(SetsWithGrading(), InfiniteEnumeratedSets()))
def __init__(self, crystals, weight, P):
"""
Initialize ``self``.
EXAMPLES::
sage: B = crystals.KirillovReshetikhin(['A',2,1], 1,1)
sage: La = RootSystem(['A',2,1]).weight_lattice().fundamental_weights()
sage: C = crystals.KyotoPathModel(B, La[0])
sage: TestSuite(C).run() # long time
"""
Parent.__init__(self,
category=(HighestWeightCrystals(),
InfiniteEnumeratedSets()))
self._cartan_type = crystals[0].cartan_type()
self._weight = weight
if weight.parent().is_extended():
# public for TensorProductOfCrystals
self.crystals = tuple([C.affinization() for C in crystals])
self._epsilon_dicts = [{
b.Epsilon(): self.crystals[i](b, 0)
for b in B
} for i, B in enumerate(crystals)]
self._phi_dicts = [{b.Phi(): self.crystals[i](b, 0)
for b in B} for i, B in enumerate(crystals)]
else:
# public for TensorProductOfCrystals
self.crystals = tuple(crystals)
self._epsilon_dicts = [{b.Epsilon(): b
for b in B} for B in crystals]
self._phi_dicts = [{b.Phi(): b for b in B} for B in crystals]
self.module_generators = (self.element_class(
self, [self._phi_dicts[0][weight]]), )
def super_categories(self):
r"""
EXAMPLES::
sage: AffineWeylGroups().super_categories()
[Category of weyl groups, Category of infinite enumerated sets]
"""
return [WeylGroups(), InfiniteEnumeratedSets()]
def __init__(self):
r"""
TESTS::
sage: from sage.combinat.backtrack import PositiveIntegerSemigroup
sage: PP = PositiveIntegerSemigroup()
"""
SearchForest.__init__(self, facade = ZZ, category=(InfiniteEnumeratedSets(), CommutativeAdditiveSemigroups(), Monoids()))
def __init__(self, family, facade=True, keepkey=False):
"""
TESTS::
sage: U = DisjointUnionEnumeratedSets({1: FiniteEnumeratedSet([1,2,3]),
... 2: FiniteEnumeratedSet([4,5,6])})
sage: TestSuite(U).run()
"""
self._family = family
self._facade = facade
self._keepkey = keepkey
# try to guess if the result is infinite or not.
if self._family.cardinality() == Infinity:
Parent.__init__(self, category=InfiniteEnumeratedSets())
elif self._family.last().cardinality() == Infinity:
Parent.__init__(self, category=InfiniteEnumeratedSets())
else:
Parent.__init__(self, category=FiniteEnumeratedSets())
def __init__(self):
"""
TESTS::
sage: PF = ParkingFunctions()
sage: TestSuite(PF).run()
"""
cat = InfiniteEnumeratedSets() & SetsWithGrading()
Parent.__init__(self, category=cat)
def __init__(self):
"""
TESTS::
sage: PF = NonDecreasingParkingFunctions()
sage: PF == loads(dumps(PF))
True
"""
Parent.__init__(self, category=InfiniteEnumeratedSets())
def __init__(self, k):
"""
TESTS::
sage: IV = IntegerVectors(k=2)
sage: TestSuite(IV).run()
"""
self.k = k
IntegerVectors.__init__(self, category=InfiniteEnumeratedSets())
def __init__(self):
"""
Initialize ``self``.
EXAMPLES::
sage: IV = IntegerVectors()
sage: TestSuite(IV).run()
"""
IntegerVectors.__init__(self, category=InfiniteEnumeratedSets())
def basis(self, region=None):
# this assumes a _basis_walker method in the subquotient object
wk = self._sq._basis_walker(region)
if self._am.graded_basis(region).cardinality() < Infinity:
cat = FiniteEnumeratedSets()
else:
cat = InfiniteEnumeratedSets()
res = Family(wk, lambda i: i, lazy=True)
res._refine_category_(cat)
return res
def __init__(self):
"""
Initialize ``self``.
EXAMPLES::
sage: OS = OrderedSetPartitions()
sage: TestSuite(OS).run() # long time
"""
Parent.__init__(self, category=InfiniteEnumeratedSets())
def __init__(self, ambient, iterable, size, mapfunc, unmapfunc):
if size < Infinity:
category = FiniteEnumeratedSets()
else:
category = InfiniteEnumeratedSets()
Parent.__init__(self, ZZ, category=category)
self.size = size
self.fmap = mapfunc
self.funm = unmapfunc
self.keys = iterable
self.am = ambient
def __init__(self):
r"""
TESTS::
sage: NN = NonNegativeIntegerSemiring(); NN
Non negative integer semiring
sage: NN.category()
Join of Category of semirings and Category of commutative monoids and Category of infinite enumerated sets and Category of facade sets
sage: TestSuite(NN).run()
"""
NonNegativeIntegers.__init__(self, category=(Semirings().Commutative(), InfiniteEnumeratedSets()) )
def __init__(self):
r"""
Initializes the class of all semistandard super tableaux.
TESTS::
sage: from sage.combinat.super_tableau import SemistandardSuperTableaux_all
sage: SST = SemistandardSuperTableaux_all(); SST
Semistandard super tableaux
"""
Parent.__init__(self, category=InfiniteEnumeratedSets())
SemistandardSuperTableaux.__init__(self)
def __init__(self):
"""
TESTS::
sage: NN = InfiniteEnumeratedSets().example()
sage: NN
An example of an infinite enumerated set: the non negative integers
sage: NN.category()
Category of infinite enumerated sets
sage: TestSuite(NN).run()
"""
Parent.__init__(self, category = InfiniteEnumeratedSets())
def __init__(self, n, category):
r"""
EXAMPLES::
sage: Yinf = crystals.infinity.GeneralizedYoungWalls(3)
sage: TestSuite(Yinf).run()
"""
self._cartan_type = CartanType(['A', n, 1])
if category is None:
category = (HighestWeightCrystals(), InfiniteEnumeratedSets())
Parent.__init__(self, category=category)
self.module_generators = (self.element_class(self, []), )
def __init__(self, family, facade=True, keepkey=False, category = None):
"""
TESTS::
sage: U = DisjointUnionEnumeratedSets({1: FiniteEnumeratedSet([1,2,3]),
....: 2: FiniteEnumeratedSet([4,5,6])})
sage: TestSuite(U).run()
"""
self._family = family
self._facade = facade
self._keepkey = keepkey
if self._is_category_initialized():
return
if category is None:
# try to guess if the result is infinite or not.
if self._family in InfiniteEnumeratedSets():
category = InfiniteEnumeratedSets()
elif self._family.last().cardinality() == Infinity:
category = InfiniteEnumeratedSets()
else:
category = FiniteEnumeratedSets()
Parent.__init__(self, category = category)
def __init__(self, category=None):
"""
TESTS::
sage: NN = NonNegativeIntegers()
sage: NN
Non negative integers
sage: NN.category()
Category of facade infinite enumerated sets
sage: TestSuite(NN).run()
"""
from sage.rings.integer_ring import ZZ
Parent.__init__(self, facade = ZZ, category = InfiniteEnumeratedSets().or_subcategory(category) )
def __init__(self, is_infinite=False):
"""
Initialize ``self``.
EXAMPLES::
sage: C = Compositions()
sage: TestSuite(C).run()
"""
if is_infinite:
Parent.__init__(self, category=InfiniteEnumeratedSets())
else:
Parent.__init__(self, category=FiniteEnumeratedSets())
def __init__(self, cartan_type):
"""
Initialize ``self``.
EXAMPLES::
sage: B = crystals.infinity.Tableaux(['A',2])
sage: TestSuite(B).run() # long time
"""
Parent.__init__( self, category=(HighestWeightCrystals(), InfiniteEnumeratedSets()) )
self._cartan_type = cartan_type
self.letters = CrystalOfLetters(cartan_type)
self.module_generators = (self.module_generator(),)
def __init__(self, category=None):
"""
Initialize ``self``.
EXAMPLES::
sage: S = StandardRibbonShapedTableaux()
sage: TestSuite(S).run()
"""
if category is None:
category = InfiniteEnumeratedSets()
StandardSkewTableaux.__init__(self, category=category)
