def __init__(self):
r"""
TESTS::
sage: from sage.combinat.backtrack import PositiveIntegerSemigroup
sage: PP = PositiveIntegerSemigroup()
"""
RecursivelyEnumeratedSet_forest.__init__(
self,
facade=ZZ,
category=(InfiniteEnumeratedSets(),
CommutativeAdditiveSemigroups(), Monoids()))
def affine_grassmannian_elements_of_given_length(self, k):
"""
Return the affine Grassmannian elements of length `k`.
This is returned as a finite enumerated set.
EXAMPLES::
sage: W = WeylGroup(['A',3,1])
sage: [x.reduced_word() for x in W.affine_grassmannian_elements_of_given_length(3)]
[[2, 1, 0], [3, 1, 0], [2, 3, 0]]
.. SEEALSO::
:meth:`AffineWeylGroups.ElementMethods.is_affine_grassmannian`
"""
from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet_forest
def select_length(pair):
u, length = pair
if length == k:
return u
def succ(pair):
u, length = pair
for i in u.descents(positive=True, side="left"):
u1 = u.apply_simple_reflection(i, "left")
if (length < k and i == u1.first_descent(side="left") and
u1.is_affine_grassmannian()):
yield (u1, length + 1)
return
return RecursivelyEnumeratedSet_forest(((self.one(), 0),), succ, algorithm='breadth',
category=FiniteEnumeratedSets(),
post_process=select_length)
def __iter__(self):
r"""
TESTS::
sage: I = IntegerVectorsModPermutationGroup(PermutationGroup([[(1,2,3,4)]]),4)
sage: for i in I: i
[4, 0, 0, 0]
[3, 1, 0, 0]
[3, 0, 1, 0]
[3, 0, 0, 1]
[2, 2, 0, 0]
[2, 1, 1, 0]
[2, 1, 0, 1]
[2, 0, 2, 0]
[2, 0, 1, 1]
[1, 1, 1, 1]
sage: I = IntegerVectorsModPermutationGroup(PermutationGroup([[(1,2,3,4)]]), sum=7, max_part=3)
sage: for i in I: i
[3, 3, 1, 0]
[3, 3, 0, 1]
[3, 2, 2, 0]
[3, 2, 1, 1]
[3, 2, 0, 2]
[3, 1, 3, 0]
[3, 1, 2, 1]
[3, 1, 1, 2]
[3, 0, 2, 2]
[2, 2, 2, 1]
"""
if self._max_part < 0:
return self.elements_of_depth_iterator(self._sum)
else:
SF = RecursivelyEnumeratedSet_forest(
(self([0] * (self.n), check=False), ),
lambda x: [
self(y, check=False)
for y in canonical_children(self._sgs, x, self._max_part)
],
algorithm='breadth')
if self._sum is None:
return iter(SF)
else:
return SF.elements_of_depth_iterator(self._sum)
def __init__(self, ambient, predicate, maximal = False, element_class = Set_object_enumerated):
"""
TESTS::
sage: from sage.combinat.subsets_pairwise import PairwiseCompatibleSubsets
sage: def predicate(x,y): return gcd(x,y) == 1
sage: P = PairwiseCompatibleSubsets( [4,5,6,8,9], predicate); P
An enumerated set with a forest structure
sage: import __main__; __main__.predicate = predicate
sage: TestSuite(P).run()
"""
self._ambient = set(ambient)
self._roots = ( ((), tuple(reversed(ambient))), )
self._predicate = predicate
self._maximal = maximal
# TODO: use self.element_class for consistency
# At this point (2011/03) TestSuite fails if we do so
self._element_class = element_class
RecursivelyEnumeratedSet_forest.__init__(self, algorithm = 'depth', category = FiniteEnumeratedSets())
def __init__(self, G, sgs=None):
"""
TESTS::
sage: I = IntegerVectorsModPermutationGroup(PermutationGroup([[(1,2,3,4)]]))
sage: I
Integer vectors of length 4 enumerated up to the action of Permutation Group with generators [(1,2,3,4)]
sage: I.category()
Category of infinite enumerated quotients of sets
sage: TestSuite(I).run()
"""
RecursivelyEnumeratedSet_forest.__init__(
self,
algorithm='breadth',
category=InfiniteEnumeratedSets().Quotients())
self._permgroup = G
self.n = G.degree()
# self.sgs: strong_generating_system
if sgs is None:
self._sgs = G.strong_generating_system()
else:
self._sgs = [list(x) for x in list(sgs)]
def __init__(self, G, d, max_part, sgs=None):
r"""
TESTS::
sage: I = IntegerVectorsModPermutationGroup(PermutationGroup([[(1,2,3,4)]]), 6, max_part=4)
"""
RecursivelyEnumeratedSet_forest.__init__(
self,
algorithm='breadth',
category=(FiniteEnumeratedSets(),
FiniteEnumeratedSets().Quotients()))
self._permgroup = G
self.n = G.degree()
self._sum = d
if max_part is None:
self._max_part = -1
else:
self._max_part = max_part
# self.sgs: strong_generating_system
if sgs is None:
self._sgs = G.strong_generating_system()
else:
self._sgs = [list(x) for x in list(sgs)]