def elements(self): r""" Returns the elements of ``self`` Those are constructed as the elements below the maximal elements of ``self`` in Bruhat order. OUTPUT: a :class:`RecursivelyEnumeratedSet_generic` object EXAMPLES:: sage: PF = WeylGroup(['A',3]).pieri_factors() sage: [w.reduced_word() for w in PF.elements()] [[3, 2, 1], [2, 1], [1], [], [3, 1], [3], [3, 2], [2]] .. SEEALSO:: :meth:`maximal_elements` .. TODO:: Possibly remove this method and instead have this class inherit from :class:`RecursivelyEnumeratedSet_generic`. """ return RecursivelyEnumeratedSet(self.maximal_elements(), attrcall('bruhat_lower_covers'), structure=None, enumeration='naive')
def __iter__(self, index_set=None, max_depth=float("inf")): """ Returns the iterator of ``self``. INPUT: - ``index_set`` -- (Default: ``None``) The index set; if ``None`` then use the index set of the crystal - ``max_depth`` -- (Default: infinity) The maximum depth to build EXAMPLES:: sage: C = crystals.LSPaths(['A',2,1],[0,1,0]) sage: sorted([p for p in C.__iter__(max_depth=3)], key=str) [(-Lambda[0] + 2*Lambda[2] - delta,), (-Lambda[0] + Lambda[1] + 1/2*Lambda[2] - delta, Lambda[0] - 1/2*Lambda[2]), (1/2*Lambda[0] + Lambda[1] - Lambda[2] - 1/2*delta, -1/2*Lambda[0] + Lambda[2] - 1/2*delta), (2*Lambda[0] - Lambda[2],), (Lambda[0] - Lambda[1] + Lambda[2],), (Lambda[1],)] sage: [p for p in C.__iter__(index_set=[0, 1], max_depth=3)] [(Lambda[1],), (Lambda[0] - Lambda[1] + Lambda[2],), (-Lambda[0] + 2*Lambda[2] - delta,)] """ if index_set is None: index_set = self.index_set() from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet return RecursivelyEnumeratedSet( self.module_generators, lambda x: [x.f(i) for i in index_set], structure='graded', max_depth=max_depth).breadth_first_search_iterator()
def category_sample(): r""" Return a sample of categories. It is constructed by looking for all concrete category classes declared in ``sage.categories.all``, calling :meth:`Category.an_instance` on those and taking all their super categories. EXAMPLES:: sage: from sage.categories.category import category_sample sage: sorted(category_sample(), key=str) [Category of G-sets for Symmetric group of order 8! as a permutation group, Category of Hecke modules over Rational Field, Category of additive magmas, ..., Category of fields, ..., Category of graded hopf algebras with basis over Rational Field, ..., Category of modular abelian varieties over Rational Field, ..., Category of simplicial complexes, ..., Category of vector spaces over Rational Field, ..., Category of weyl groups,... """ import sage.categories.all abstract_classes_for_categories = [Category] seeds = { cls.an_instance() for cls in sage.categories.all.__dict__.values() if isinstance(cls, type) and issubclass(cls, Category) and cls not in abstract_classes_for_categories } return list(RecursivelyEnumeratedSet(seeds, related_categories))
def desubstitute(self, u): r""" EXAMPLES: Unique preimage:: sage: from slabbe.word_morphisms import desubstitute sage: s = WordMorphism({0:[0,1],1:[1,0]}) sage: desubstitute(s, Word([0,1,0,1,1,0])) [word: 001] Non-unique preimage:: sage: s = WordMorphism({0:[0,1],1:[1,0],2:[1,0]}) sage: desubstitute(s, Word([0,1,0,1,1,0])) [word: 001, word: 002] No preimage:: sage: s = WordMorphism({0:[0,1],1:[1,0]}) sage: desubstitute(s, Word([0,1,0,1,1,1])) [] Lot of preimages (computation is done in parallel with Florent's Hivert parallel map reduce code):: sage: s = WordMorphism({0:[0,1],1:[0,1]}) sage: w = Word([0,1]) ^ 10 sage: L = desubstitute(s, w) sage: len(L) 1024 """ morph = self._morph len_u = len(u) def successor(node): L, i = node if i == len_u: return [] else: ui = u[i:] return [(L + [k], i + len(v)) for k, v in morph.iteritems() if v.is_prefix(ui)] roots = [([], 0)] post_process = lambda node: node if node[1] == len_u else None from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet R = RecursivelyEnumeratedSet(roots, successor, structure='forest', post_process=post_process) W = self.domain() map_function = lambda node: [W(node[0])] reduce_function = lambda x, y: x + y reduce_init = [] return R.map_reduce(map_function, reduce_function, reduce_init)
def __iter__(self): r""" Naive algorithm to give the elements of the conjugacy class. .. TODO:: Implement a non-naive algorithm, cf. for instance G. Butler: "An Inductive Schema for Computing Conjugacy Classes in Permutation Groups", Math. of Comp. Vol. 62, No. 205 (1994) EXAMPLES: Groups of permutations:: sage: G = SymmetricGroup(3) sage: g = G((1,2)) sage: C = ConjugacyClass(G,g) sage: sorted(C) [(2,3), (1,2), (1,3)] It works for infinite groups:: sage: a = matrix(ZZ,2,[1,1,0,1]) sage: b = matrix(ZZ,2,[1,0,1,1]) sage: G = MatrixGroup([a,b]) # takes 1s sage: a = G(a) sage: C = ConjugacyClass(G, a) sage: it = iter(C) sage: [next(it) for _ in range(5)] # random (nothing guarantees enumeration order) [ [1 1] [ 2 1] [ 0 1] [ 3 1] [ 3 4] [0 1], [-1 0], [-1 2], [-4 -1], [-1 -1] ] We check that two matrices are in C:: sage: b = G(b) sage: m1 = b * a * ~b sage: m2 = ~b * a * b sage: any(x == m1 for x in C) True sage: any(x == m2 for x in C) True """ from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet g = self._representative gens = self._parent.monoid_generators() R = RecursivelyEnumeratedSet([g], lambda y: [c * y * c**-1 for c in gens], structure=None) return R.breadth_first_search_iterator()
def __iter__(self): """ Returns the iterator of ``self``. EXAMPLES:: sage: KRT = crystals.TensorProductOfKirillovReshetikhinTableaux(['A', 3, 1], [[2,1], [1,1]]) sage: g = KRT.__iter__() sage: next(g) [[2], [3]] (X) [[1]] sage: next(g) [[2], [4]] (X) [[1]] """ index_set = self._cartan_type.classical().index_set() from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet return RecursivelyEnumeratedSet(self.module_generators, lambda x: [x.f(i) for i in index_set], structure=None).naive_search_iterator()
def connected_component_iterator(self, roots=None): r""" Return an iterator over the connected component of the root. This method overwrites the methods :meth:`slabbe.discrete_subset.DiscreteSubset.connected_component_iterator`, because for billiard words, we go only in one direction in each axis which allows to use a forest structure for the enumeration. INPUT: - ``roots`` - list of some elements immutable in self EXAMPLES:: sage: from slabbe import BilliardCube sage: p = BilliardCube([1,pi,sqrt(7)]) sage: root = vector((0,0,0)) sage: root.set_immutable() sage: it = p.connected_component_iterator(roots=[root]) sage: [next(it) for _ in range(5)] [(0, 0, 0), (0, 1, 0), (0, 1, 1), (0, 2, 1), (1, 2, 1)] :: sage: p = BilliardCube([1,pi,7.45], start=(10.2,20.4,30.8)) sage: it = p.connected_component_iterator() sage: [next(it) for _ in range(5)] [(10.2000000000000, 20.4000000000000, 30.8000000000000), (10.2000000000000, 20.4000000000000, 31.8000000000000), (10.2000000000000, 21.4000000000000, 31.8000000000000), (10.2000000000000, 21.4000000000000, 32.8000000000000), (10.2000000000000, 21.4000000000000, 33.8000000000000)] """ roots = roots if roots else [self.an_element()] if not all(root in self for root in roots): raise ValueError("roots (=%s) must all be in self(=%s)" % (roots, self)) #for root in roots: # root.set_immutable() C = RecursivelyEnumeratedSet(seeds=roots, successors=self.children, structure='forest') return C.breadth_first_search_iterator()
def dominant_maximal_weights(self): r""" Return the dominant maximal weights of ``self``. A weight `\mu` is *maximal* if it has nonzero multiplicity but `\mu + \delta`` has multiplicity zero. There are a finite number of dominant maximal weights. Indeed, [Kac]_ Proposition 12.6 shows that the dominant maximal weights are in bijection with the classical weights in `k \cdot F` where `F` is the fundamental alcove and `k` is the level. The construction used in this method is based on that Proposition. EXAMPLES:: sage: Lambda = RootSystem(['C',3,1]).weight_lattice(extended=true).fundamental_weights() sage: IntegrableRepresentation(2*Lambda[0]).dominant_maximal_weights() (2*Lambda[0], Lambda[0] + Lambda[2] - delta, 2*Lambda[1] - delta, Lambda[1] + Lambda[3] - 2*delta, 2*Lambda[2] - 2*delta, 2*Lambda[3] - 3*delta) """ k = self.level() Lambda = self._P.fundamental_weights() def next_level(wt): return [ wt + Lambda[i] for i in self._index_set_classical if (wt + Lambda[i]).level() <= k ] R = RecursivelyEnumeratedSet([self._P.zero()], next_level) candidates = [x + (k - x.level()) * Lambda[0] for x in list(R)] ret = [] delta = self._Q.null_root() for x in candidates: if self._from_weight_helper(self._Lam - x, check=True): t = 0 while self.m(self.from_weight(x - t * delta)) == 0: t += 1 ret.append(x - t * delta) return tuple(ret)
def ideal(self, gens, side="twosided"): r""" Return the ``side``-sided ideal generated by ``gens``. This brute force implementation recursively multiplies the elements of ``gens`` by the distinguished generators of this semigroup. .. SEEALSO:: :meth:`semigroup_generators` INPUT: - ``gens`` -- a list (or iterable) of elements of ``self`` - ``side`` -- [default: "twosided"] "left", "right" or "twosided" EXAMPLES:: sage: S = FiniteSemigroups().example() sage: sorted(S.ideal([S('cab')], side="left")) ['abc', 'abcd', 'abdc', 'acb', 'acbd', 'acdb', 'adbc', 'adcb', 'bac', 'bacd', 'badc', 'bca', 'bcad', 'bcda', 'bdac', 'bdca', 'cab', 'cabd', 'cadb', 'cba', 'cbad', 'cbda', 'cdab', 'cdba', 'dabc', 'dacb', 'dbac', 'dbca', 'dcab', 'dcba'] sage: list(S.ideal([S('cab')], side="right")) ['cab', 'cabd'] sage: sorted(S.ideal([S('cab')], side="twosided")) ['abc', 'abcd', 'abdc', 'acb', 'acbd', 'acdb', 'adbc', 'adcb', 'bac', 'bacd', 'badc', 'bca', 'bcad', 'bcda', 'bdac', 'bdca', 'cab', 'cabd', 'cadb', 'cba', 'cbad', 'cbda', 'cdab', 'cdba', 'dabc', 'dacb', 'dbac', 'dbca', 'dcab', 'dcba'] sage: sorted(S.ideal([S('cab')])) ['abc', 'abcd', 'abdc', 'acb', 'acbd', 'acdb', 'adbc', 'adcb', 'bac', 'bacd', 'badc', 'bca', 'bcad', 'bcda', 'bdac', 'bdca', 'cab', 'cabd', 'cadb', 'cba', 'cbad', 'cbda', 'cdab', 'cdba', 'dabc', 'dacb', 'dbac', 'dbca', 'dcab', 'dcba'] """ from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet return RecursivelyEnumeratedSet(gens, self.succ_generators(side=side))
def __iter__(self): r""" Return an iterator over the elements of ``self``. This brute force implementation recursively multiplies together the distinguished semigroup generators. .. SEEALSO:: :meth:`semigroup_generators` EXAMPLES:: sage: S = FiniteSemigroups().example(alphabet=('x','y')) sage: it = S.__iter__() sage: list(it) ['x', 'y', 'yx', 'xy'] """ from sage.sets.recursively_enumerated_set import RecursivelyEnumeratedSet return iter(RecursivelyEnumeratedSet(self.semigroup_generators(), self.succ_generators(side="right"), enumeration='breadth'))
def branch(self, i=None, weyl_character_ring=None, sequence=None, depth=5): r""" Return the branching rule on ``self``. Removing any node from the extended Dynkin diagram of the affine Lie algebra results in the Dynkin diagram of a classical Lie algebra, which is therefore a Lie subalgebra. For example removing the `0` node from the Dynkin diagram of type ``[X, r, 1]`` produces the classical Dynkin diagram of ``[X, r]``. Thus for each `i` in the index set, we may restrict ``self`` to the corresponding classical subalgebra. Of course ``self`` is an infinite dimensional representation, but each weight `\mu` is assigned a grading by the number of times the simple root `\alpha_i` appears in `\Lambda-\mu`. Thus the branched representation is graded and we get sequence of finite-dimensional representations which this method is able to compute. OPTIONAL: - ``i`` -- (default: 0) an element of the index set - ``weyl_character_ring`` -- a WeylCharacterRing - ``sequence`` -- a dictionary - ``depth`` -- (default: 5) an upper bound for `k` determining how many terms to give In the default case where `i = 0`, you do not need to specify anything else, though you may want to increase the depth if you need more terms. EXAMPLES:: sage: Lambda = RootSystem(['A',2,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(2*Lambda[0]) sage: b = V.branch(); b [A2(0,0), A2(1,1), A2(0,0) + 2*A2(1,1) + A2(2,2), 2*A2(0,0) + 2*A2(0,3) + 4*A2(1,1) + 2*A2(3,0) + 2*A2(2,2), 4*A2(0,0) + 3*A2(0,3) + 10*A2(1,1) + 3*A2(3,0) + A2(1,4) + 6*A2(2,2) + A2(4,1), 6*A2(0,0) + 9*A2(0,3) + 20*A2(1,1) + 9*A2(3,0) + 3*A2(1,4) + 12*A2(2,2) + 3*A2(4,1) + A2(3,3)] If the parameter ``weyl_character_ring`` is omitted, the ring may be recovered as the parent of one of the branched coefficients:: sage: A2 = b[0].parent(); A2 The Weyl Character Ring of Type A2 with Integer Ring coefficients If `i` is not zero then you should specify the :class:`WeylCharacterRing` that you are branching to. This is determined by the Dynkin diagram:: sage: Lambda = RootSystem(['B',3,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(Lambda[0]) sage: V.cartan_type().dynkin_diagram() O 0 | | O---O=>=O 1 2 3 B3~ In this example, we observe that removing the `i=2` node from the Dynkin diagram produces a reducible diagram of type ``A1xA1xA1``. Thus we have a branching to `\mathfrak{sl}(2) \times \mathfrak{sl}(2) \times \mathfrak{sl}(2)`:: sage: A1xA1xA1 = WeylCharacterRing("A1xA1xA1",style="coroots") sage: V.branch(i=2,weyl_character_ring=A1xA1xA1) [A1xA1xA1(1,0,0), A1xA1xA1(0,1,2), A1xA1xA1(1,0,0) + A1xA1xA1(1,2,0) + A1xA1xA1(1,0,2), A1xA1xA1(2,1,2) + A1xA1xA1(0,1,0) + 2*A1xA1xA1(0,1,2), 3*A1xA1xA1(1,0,0) + 2*A1xA1xA1(1,2,0) + A1xA1xA1(1,2,2) + 2*A1xA1xA1(1,0,2) + A1xA1xA1(1,0,4) + A1xA1xA1(3,0,0), A1xA1xA1(2,1,0) + 3*A1xA1xA1(2,1,2) + 2*A1xA1xA1(0,1,0) + 5*A1xA1xA1(0,1,2) + A1xA1xA1(0,1,4) + A1xA1xA1(0,3,2)] If the nodes of the two Dynkin diagrams are not in the same order, you must specify an additional parameter, ``sequence`` which gives a dictionary to the affine Dynkin diagram to the classical one. EXAMPLES:: sage: Lambda = RootSystem(['F',4,1]).weight_lattice(extended=true).fundamental_weights() sage: V = IntegrableRepresentation(Lambda[0]) sage: V.cartan_type().dynkin_diagram() O---O---O=>=O---O 0 1 2 3 4 F4~ sage: A1xC3=WeylCharacterRing("A1xC3",style="coroots") sage: A1xC3.dynkin_diagram() O 1 O---O=<=O 2 3 4 A1xC3 Observe that removing the `i=1` node from the ``F4~`` Dynkin diagram gives the ``A1xC3`` diagram, but the roots are in a different order. The nodes `0, 2, 3, 4` of ``F4~`` correspond to ``1, 4, 3, 2`` of ``A1xC3`` and so we encode this in a dictionary:: sage: V.branch(i=1,weyl_character_ring=A1xC3,sequence={0:1,2:4,3:3,4:2}) # long time [A1xC3(1,0,0,0), A1xC3(0,0,0,1), A1xC3(1,0,0,0) + A1xC3(1,2,0,0), A1xC3(2,0,0,1) + A1xC3(0,0,0,1) + A1xC3(0,1,1,0), 2*A1xC3(1,0,0,0) + A1xC3(1,0,1,0) + 2*A1xC3(1,2,0,0) + A1xC3(1,0,2,0) + A1xC3(3,0,0,0), 2*A1xC3(2,0,0,1) + A1xC3(2,1,1,0) + A1xC3(0,1,0,0) + 3*A1xC3(0,0,0,1) + 2*A1xC3(0,1,1,0) + A1xC3(0,2,0,1)] The branch method gives a way of computing the graded dimension of the integrable representation:: sage: Lambda = RootSystem("A1~").weight_lattice(extended=true).fundamental_weights() sage: V=IntegrableRepresentation(Lambda[0]) sage: r = [x.degree() for x in V.branch(depth=15)]; r [1, 3, 4, 7, 13, 19, 29, 43, 62, 90, 126, 174, 239, 325, 435, 580] sage: oeis(r) # optional -- internet 0: A029552: Expansion of phi(x) / f(-x) in powers of x where phi(), f() are Ramanujan theta functions. """ if i is None: i = self._cartan_type.special_node() if i == self._cartan_type.special_node() or self._cartan_type.type( ) == 'A': if weyl_character_ring is None: weyl_character_ring = WeylCharacterRing( self._cartan_type.classical(), style="coroots") if weyl_character_ring.cartan_type( ) != self._cartan_type.classical(): raise ValueError( "Cartan type of WeylCharacterRing must be %s" % self.cartan_type().classical()) elif weyl_character_ring is None: raise ValueError( "the argument weyl_character_ring cannot be omitted if i != 0") if sequence is None: sequence = {} for j in self._index_set: if j < i: sequence[j] = j + 1 elif j > i: sequence[j] = j def next_level(x): ret = [] for j in self._index_set: t = list(x[0]) t[j] += 1 t = tuple(t) m = self.m(t) if m > 0 and t[i] <= depth: ret.append((t, m)) return ret hwv = (tuple([0 for j in self._index_set]), 1) terms = RecursivelyEnumeratedSet([hwv], next_level) fw = weyl_character_ring.fundamental_weights() P = self.weight_lattice() ret = [] for l in range(depth + 1): lterms = [x for x in terms if x[0][i] == l] ldict = {} for x in lterms: mc = P(self.to_weight(x[0])).monomial_coefficients() contr = sum(fw[sequence[j]] * mc.get(j, 0) for j in self._index_set if j != i).coerce_to_sl() if contr in ldict: ldict[contr] += x[1] else: ldict[contr] = x[1] ret.append(weyl_character_ring.char_from_weights(ldict)) return ret