def __init__(self): """ TESTS:: sage: sum(x**len(t) for t in ....: set(RootedTree(t) for t in OrderedTrees(6))) x^5 + x^4 + 3*x^3 + 6*x^2 + 9*x sage: sum(x**len(t) for t in RootedTrees(6)) x^5 + x^4 + 3*x^3 + 6*x^2 + 9*x sage: TestSuite(RootedTrees()).run() # long time """ DisjointUnionEnumeratedSets.__init__(self, Family(NonNegativeIntegers(), RootedTrees_size), facade=True, keepkey=False)
def algebra_generators(self): r""" Return the generators of this algebra. EXAMPLES:: sage: A = ShuffleAlgebra(ZZ,'fgh'); A Shuffle Algebra on 3 generators ['f', 'g', 'h'] over Integer Ring sage: A.algebra_generators() Family (B[word: f], B[word: g], B[word: h]) sage: A = ShuffleAlgebra(QQ, ['x1','x2']) sage: A.algebra_generators() Family (B[word: x1], B[word: x2]) """ Words = self.basis().keys() return Family([self.monomial(Words([a])) for a in self._alphabet])
def simple_reflections(self): """ EXAMPLES:: sage: WeylGroup(['A',2,1]).classical().simple_reflections() Finite family {1: [ 1 0 0] [ 1 -1 1] [ 0 0 1], 2: [ 1 0 0] [ 0 1 0] [ 1 1 -1]} Note: won't be needed, once the lattice will be a parabolic sub root system """ return Family( dict((i, self.from_morphism(self.domain().simple_reflection(i))) for i in self.index_set()))
def algebra_generators(self): """ Return the algebra generators of ``self``. EXAMPLES:: sage: O = algebras.QuantumGL(2) sage: O.algebra_generators() Finite family {(1, 2): x[1,2], 'c': c, (1, 1): x[1,1], (2, 1): x[2,1], (2, 2): x[2,2]} """ l = [(i, j) for i in range(1, self._n + 1) for j in range(1, self._n + 1)] l.append('c') G = self._indices.monoid_generators() one = self.base_ring().one() return Family(l, lambda x: self.element_class(self, {G[x]: one}))
def algebra_generators(self): """ Return the algebra generators of ``self``. EXAMPLES:: sage: L = lie_algebras.sl(QQ, 2) sage: PBW = L.pbw_basis() sage: PBW.algebra_generators() Finite family {-alpha[1]: PBW[-alpha[1]], alpha[1]: PBW[alpha[1]], alphacheck[1]: PBW[alphacheck[1]]} """ G = self._indices.gens() return Family(self._indices._indices, lambda x: self.monomial(G[x]), name="generator map")
def _standardize_s_coeff(s_coeff, index_set): """ Helper function to standardize ``s_coeff`` into the appropriate form (dictionary indexed by pairs, whose values are dictionaries). Strips items with coefficients of 0 and duplicate entries. This does not check the Jacobi relation (nor antisymmetry if the cardinality is infinite). EXAMPLES:: sage: from sage.algebras.lie_algebras.structure_coefficients import LieAlgebraWithStructureCoefficients sage: d = {('y','x'): {'x':-1}} sage: LieAlgebraWithStructureCoefficients._standardize_s_coeff(d, ('x', 'y')) Finite family {('x', 'y'): (('x', 1),)} """ # Try to handle infinite basis (once/if supported) #if isinstance(s_coeff, AbstractFamily) and s_coeff.cardinality() == infinity: # return s_coeff index_to_pos = {k: i for i,k in enumerate(index_set)} sc = {} # Make sure the first gen is smaller than the second in each key for k in s_coeff.keys(): v = s_coeff[k] if isinstance(v, dict): v = v.items() if index_to_pos[k[0]] > index_to_pos[k[1]]: key = (k[1], k[0]) vals = tuple((g, -val) for g, val in v if val != 0) else: if not index_to_pos[k[0]] < index_to_pos[k[1]]: if k[0] == k[1]: if not all(val == 0 for g, val in v): raise ValueError("elements {} are equal but their bracket is not set to 0".format(k)) continue key = tuple(k) vals = tuple((g, val) for g, val in v if val != 0) if key in sc.keys() and sorted(sc[key]) != sorted(vals): raise ValueError("two distinct values given for one and the same bracket") if vals: sc[key] = vals return Family(sc)
def basis(self): r""" Return the basis of ``self``. EXAMPLES:: sage: O = lie_algebras.OnsagerAlgebra(QQ) sage: O.basis() Lazy family (Onsager monomial(i))_{i in Disjoint union of Family (Integer Ring, Positive integers)} """ from sage.rings.all import ZZ from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets from sage.sets.positive_integers import PositiveIntegers I = DisjointUnionEnumeratedSets([ZZ, PositiveIntegers()], keepkey=True, facade=True) return Family(I, self.monomial, name='Onsager monomial')
def simple_roots(self): """ Return the simple roots of ``self``. EXAMPLES:: sage: W = WeylGroup(['A',4], implementation="permutation") sage: W.simple_roots() Finite family {1: (1, 0, 0, 0), 2: (0, 1, 0, 0), 3: (0, 0, 1, 0), 4: (0, 0, 0, 1)} """ Q = self._cartan_type.root_system().root_lattice() roots = [al.to_vector() for al in Q.simple_roots()] for v in roots: v.set_immutable() return Family(self._index_set, lambda i: roots[self._index_set_inverse[i]])
def algebra_generators(self): """ Return the algebra generators of ``self``. EXAMPLES:: sage: Q = QSystem(QQ, ['A',4]) sage: Q.algebra_generators() Finite family {1: Q^(1)[1], 2: Q^(2)[1], 3: Q^(3)[1], 4: Q^(4)[1]} sage: Q = QSystem(QQ, ['D',4,3], twisted=True) sage: Q.algebra_generators() Finite family {1: Q^(1)[1], 2: Q^(2)[1]} """ I = self._cm.index_set() d = {a: self.Q(a, 1) for a in I} return Family(I, d.__getitem__)
def algebra_generators(self): r""" Return generators of this group algebra (as an algebra). EXAMPLES:: sage: GroupAlgebras(QQ).example(SymmetricGroup(10)).algebra_generators() Finite family {(1,2): B[(1,2)], (1,2,3,4,5,6,7,8,9,10): B[(1,2,3,4,5,6,7,8,9,10)]} .. NOTE:: This function is overloaded for SymmetricGroupAlgebras to return Permutations and not Elements of the symmetric group. """ from sage.sets.family import Family return Family(self.group().gens(), self.term)
def algebra_generators(self): """ Return the algebra generators of ``self``. .. SEEALSO:: :meth:`variables`, :meth:`differentials` EXAMPLES:: sage: R.<x,y,z> = QQ[] sage: W = DifferentialWeylAlgebra(R) sage: W.algebra_generators() Finite family {'dz': dz, 'dx': dx, 'dy': dy, 'y': y, 'x': x, 'z': z} """ d = {x: self.gen(i) for i,x in enumerate(self.variable_names())} return Family(self.variable_names(), lambda x: d[x])
def reflections(self): """ Return the reflections of ``self``. The reflections of a Coxeter group `W` are the conjugates of the simple reflections. They are in bijection with the positive roots, for given a positive root, we may have the reflection in the hyperplane orthogonal to it. This method returns a family indexed by the positive roots taking values in the reflections. This requires ``self`` to be a finite Weyl group. .. NOTE:: Prior to :trac:`20027`, the reflections were the keys of the family and the values were the positive roots. EXAMPLES:: sage: W = WeylGroup("B2", prefix="s") sage: refdict = W.reflections(); refdict Finite family {(1, -1): s1, (1, 1): s2*s1*s2, (1, 0): s1*s2*s1, (0, 1): s2} sage: [r+refdict[r].action(r) for r in refdict.keys()] [(0, 0), (0, 0), (0, 0), (0, 0)] sage: W = WeylGroup(['A',2,1], prefix="s") sage: W.reflections() Lazy family (real root to reflection(i))_{i in Positive real roots of type ['A', 2, 1]} TESTS:: sage: CM = CartanMatrix([[2,-6],[-1,2]]) sage: W = WeylGroup(CM, prefix='s') sage: W.reflections() Traceback (most recent call last): ... NotImplementedError: only implemented for finite and affine Cartan types """ prr = self.domain().positive_real_roots() def to_elt(alp): ref = self.domain().reflection(alp) m = Matrix([ref(x).to_vector() for x in self.domain().basis()]) return self(m.transpose()) return Family(prr, to_elt, name="real root to reflection")
def variables(self): """ Return the variables of ``self``. .. SEEALSO:: :meth:`algebra_generators`, :meth:`differentials` EXAMPLES:: sage: W.<x,y,z> = DifferentialWeylAlgebra(QQ) sage: W.variables() Finite family {'y': y, 'x': x, 'z': z} """ N = self.variable_names()[:self._n] d = {x: self.gen(i) for i,x in enumerate(N) } return Family(N, lambda x: d[x])
def __init__(self, n, action="right"): ambient_monoid = FiniteSetMaps(range(1, n + 1), action=action) def pii(i): return ambient_monoid.from_dict( {j: j - 1 if j == i + 1 else j for j in range(1, n + 1)}) pi = Family(range(1, n), pii) category = Monoids().JTrivial().Finite() & Monoids().Transformation( ).Subobjects() AutomaticMonoid.__init__(self, pi, ambient_monoid, one=ambient_monoid.one(), mul=operator.mul, category=category)
def __init__(self, R, g): r""" Initialize ``self``. EXAMPLES:: sage: L = lie_algebras.SymplecticDerivation(QQ, 5) sage: TestSuite(L).run() """ if g < 4: raise ValueError("g must be at least 4") cat = LieAlgebras(R).WithBasis().Graded() self._g = g d = Family(NonNegativeIntegers(), lambda n: Partitions(n, min_length=2, max_part=2*g)) indices = DisjointUnionEnumeratedSets(d) InfinitelyGeneratedLieAlgebra.__init__(self, R, index_set=indices, category=cat) IndexedGenerators.__init__(self, indices, sorting_key=self._basis_key)
def differentials(self): """ Return the differentials of ``self``. .. SEEALSO:: :meth:`algebra_generators`, :meth:`variables` EXAMPLES:: sage: W.<x,y,z> = DifferentialWeylAlgebra(QQ) sage: W.differentials() Finite family {'dz': dz, 'dx': dx, 'dy': dy} """ N = self.variable_names()[self._n:] d = {x: self.gen(self._n+i) for i,x in enumerate(N) } return Family(N, lambda x: d[x])
def __init__(self, n): r""" Initializes the class of all standard super tableaux of size ``n``. TESTS:: sage: TestSuite( StandardSuperTableaux(4) ).run() """ StandardSuperTableaux.__init__(self) from sage.combinat.partition import Partitions_n DisjointUnionEnumeratedSets.__init__(self, Family( Partitions_n(n), StandardSuperTableaux_shape), category=FiniteEnumeratedSets(), facade=True, keepkey=False) self.size = Integer(n)
def simple_coroots(self): """ Returns the family `(\alpha^\vee_i)_{i\in I}` of the simple coroots. EXAMPLES:: sage: alphacheck = RootSystem(['A',3]).root_lattice().simple_coroots() sage: [alphacheck[i] for i in [1, 2, 3]] [alphacheck[1], alphacheck[2], alphacheck[3]] """ if not hasattr(self, "cache_simple_coroots"): self.cache_simple_coroots = Family(self.index_set(), self.simple_coroot) # Should we use rename to set a nice name for this family? # self.cache_simple_coroots.rename("alphacheck") # break some doctests return self.cache_simple_coroots
def orthogonal_idempotents_wrong(self): """ OUTPUT: -- A family of idempotents indexed by the idempotents of ``self`` Returns a (conjectural) maximal decomposition of the identity into orthogonal idempotents Does not work: the obtained idempotents are not orthogonal EXAMPLES:: sage: Semigroups().JTrivial().Finite().example().algebra(QQ).orthogonal_idempotents() # non deterministic Finite family {...} """ monoid = self.basis().keys() return Family(monoid.idempotents(), self.orthogonal_idempotent)
def algebra_generators(self): r""" Return the generators of this algebra. EXAMPLES:: sage: C = CombinatorialFreeModule(QQ, ['a','b','c']) sage: TA = TensorAlgebra(C) sage: TA.algebra_generators() Finite family {'a': B['a'], 'c': B['c'], 'b': B['b']} sage: m = SymmetricFunctions(QQ).m() sage: Tm = TensorAlgebra(m) sage: Tm.algebra_generators() Lazy family (generator(i))_{i in Partitions} """ return Family(self._indices.indices(), lambda i: self.monomial(self._indices.gen(i)), name='generator')
def group_generators(self): """ Return group generators for ``self``. This default implementation calls :meth:`gens`, for backward compatibility. EXAMPLES:: sage: A = AlternatingGroup(4) sage: A.group_generators() Family ((2,3,4), (1,2,3)) """ from sage.sets.family import Family try: return Family(self.gens()) except AttributeError: raise NotImplementedError("no generators are implemented for this group")
def fundamental_weights(self): """ Return the fundamental weights for ``self``. This is the dual basis to the basis of simple roots. The base ring must be a field. EXAMPLES:: sage: W = CoxeterGroup(['A',3], implementation='reflection') sage: W.fundamental_weights() Finite family {1: (3/2, 1, 1/2), 2: (1, 2, 1), 3: (1/2, 1, 3/2)} """ simple_weights = self.bilinear_form().inverse() I = self.index_set() D = {i: simple_weights[k] for k, i in enumerate(I)} return Family(I, D.__getitem__)
def basis(self): """ Return a basis of ``self``. The basis returned begins with the unity of `R` and continues with the standard basis of `M`. EXAMPLES:: sage: m = matrix([[0,1],[1,1]]) sage: J = JordanAlgebra(m) sage: J.basis() Family (1 + (0, 0), 0 + (1, 0), 0 + (0, 1)) """ R = self.base_ring() ret = (self.element_class(self, R.one(), self._M.zero()),) ret += tuple(map(lambda x: self.element_class(self, R.zero(), x), self._M.basis())) return Family(ret)
def cells(self): """ Return the cells of ``self``. EXAMPLES:: sage: from sage.categories.cw_complexes import CWComplexes sage: X = CWComplexes().example() sage: C = X.cells() sage: sorted((d, C[d]) for d in C.keys()) [(0, (0-cell v,)), (1, (0-cell e1, 0-cell e2)), (2, (2-cell f,))] """ d = {0: (self.element_class(self, 0, 'v'),)} d[1] = tuple([self.element_class(self, 0, 'e'+str(e)) for e in self._edges]) d[2] = (self.an_element(),) return Family(d)
def __init__(self): r""" Initializes the class of all standard super tableaux. TESTS:: sage: from sage.combinat.super_tableau import StandardSuperTableaux_all sage: SST = StandardSuperTableaux_all(); SST Standard super tableaux sage: TestSuite(SST).run() """ StandardSuperTableaux.__init__(self) DisjointUnionEnumeratedSets.__init__(self, Family( NonNegativeIntegers(), StandardSuperTableaux_size), facade=True, keepkey=False)
def _positive_roots_reflections(self): """ Return a family whose keys are the positive roots and values are the reflections. EXAMPLES:: sage: W = CoxeterGroup(['A', 2]) sage: F = W._positive_roots_reflections() sage: F.keys() [(1, 0), (1, 1), (0, 1)] sage: list(F) [ [-1 1] [ 0 -1] [ 1 0] [ 0 1], [-1 0], [ 1 -1] ] """ if not self.is_finite(): raise NotImplementedError('not available for infinite groups') word = self.long_element(as_word=True) N = len(word) from sage.modules.free_module import FreeModule simple_roots = FreeModule(self.base_ring(), self.ngens()).gens() refls = self.simple_reflections() resu = [] d = {} for i in range(1, N + 1): segment = word[:i] last = segment.pop() ref = refls[last] rt = simple_roots[last - 1] while segment: last = segment.pop() cr = refls[last] ref = cr * ref * cr rt = refls[last] * rt rt.set_immutable() resu += [rt] d[rt] = ref from sage.sets.family import Family return Family(resu, lambda rt: d[rt])
def _part_generators(self, positive=False): r""" Return the Lie algebra generators for the positive or negative half of ``self``. .. NOTE:: If the positive/negative generators correspond to the generators with (negative) simple roots, then this method will find them. If they do not, then this method *must* be overwritten. One should also overwrite this method in object classes when there is a better method to obtain them. Furthermore, this assumes that :meth:`lie_algebra_generators` is a finite set. INPUT: - ``positive`` -- boolean (default: ``False``); if ``True`` then return positive part generators, otherwise the return the negative part generators OUTPUT: A :func:`~sage.sets.family.Family` whose keys are the index set of ``self``. EXAMPLES:: sage: L = LieAlgebra(QQ, cartan_type=['E',6]) sage: list(L._part_generators(False)) [E[-alpha[1]], E[-alpha[2]], E[-alpha[3]], E[-alpha[4]], E[-alpha[5]], E[-alpha[6]]] """ I = self._cartan_type.index_set() P = self._cartan_type.root_system().root_lattice() ali = P.simple_roots().inverse_family() if positive: d = {ali[g.degree()]: g for g in self.lie_algebra_generators() if self._part(g) > 0} if not positive: d = {ali[-g.degree()]: g for g in self.lie_algebra_generators() if self._part(g) < 0} from sage.sets.family import Family return Family(I, d.__getitem__)
def semigroup_generators(self): """ Return the generators of ``self`` as a semigroup. The generators of a monoid `M` as a semigroup are the generators of `M` as a monoid and the unit. EXAMPLES:: sage: M = Monoids().free([1,2,3]) sage: M.semigroup_generators() Family (1, F[1], F[2], F[3]) """ G = self.monoid_generators() from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets if G not in FiniteEnumeratedSets(): raise NotImplementedError("currently only implemented for finitely generated monoids") from sage.sets.family import Family return Family((self.one(),) + tuple(G))
def basis(self): """ Return a basis of ``self``. EXAMPLES:: sage: d = lie_algebras.VirasoroAlgebra(QQ) sage: B = d.basis(); B Lazy family (basis map(i))_{i in Disjoint union of Family ({'c'}, Integer Ring)} sage: B['c'] c sage: B[3] d[3] sage: B[-15] d[-15] """ I = DisjointUnionEnumeratedSets([Set(['c']), ZZ]) return Family(I, self.monomial, name='basis map')
def distinguished_reflections(self): """ Return the reflections of ``self``. EXAMPLES:: sage: W = WeylGroup(['B',2], implementation="permutation") sage: W.distinguished_reflections() Finite family {1: (1,5)(2,4)(6,8), 2: (1,3)(2,6)(5,7), 3: (2,8)(3,7)(4,6), 4: (1,7)(3,5)(4,8)} """ Q = self._cartan_type.root_system().root_lattice() pos_roots = list(Q.positive_roots()) Phi = pos_roots + [-x for x in pos_roots] def build_elt(index): r = pos_roots[index] perm = [Phi.index(x.reflection(r))+1 for x in Phi] return self.element_class(perm, self, check=False) return Family(self.reflection_index_set(), lambda i: build_elt(i-1))