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))
