def strongly_finer(self):
"""
Return the set of ordered set partitions which are strongly
finer than ``self``.
See :meth:`is_strongly_finer` for the definition of "strongly
finer".
EXAMPLES::
sage: C = OrderedSetPartition([[1, 3], [2]]).strongly_finer()
sage: C.cardinality()
2
sage: C.list()
[[{1}, {3}, {2}], [{1, 3}, {2}]]
sage: OrderedSetPartition([]).strongly_finer()
{[]}
sage: W = OrderedSetPartition([[4, 9], [-1, 2]])
sage: W.strongly_finer().list()
[[{4}, {9}, {-1}, {2}],
[{4}, {9}, {-1, 2}],
[{4, 9}, {-1}, {2}],
[{4, 9}, {-1, 2}]]
"""
par = parent(self)
if not self:
return FiniteEnumeratedSet([self])
else:
buo = OrderedSetPartition.bottom_up_osp
return FiniteEnumeratedSet([par(sum((list(P) for P in C), []))
for C in cartesian_product([[buo(X, comp) for comp in Compositions(len(X))] for X in self])])
def basis(self):
r"""
Return the basis of ``self``.
EXAMPLES::
sage: g = LieAlgebra(QQ, cartan_type=['D',4,1])
sage: B = g.basis()
sage: al = RootSystem(['D',4]).root_lattice().simple_roots()
sage: B[al[1]+al[2]+al[4],4]
(E[alpha[1] + alpha[2] + alpha[4]])#t^4
sage: B[-al[1]-2*al[2]-al[3]-al[4],2]
(E[-alpha[1] - 2*alpha[2] - alpha[3] - alpha[4]])#t^2
sage: B[al[4],-2]
(E[alpha[4]])#t^-2
sage: B['c']
c
sage: B['d']
d
"""
K = cartesian_product([self._g.basis().keys(), ZZ])
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
c = FiniteEnumeratedSet(['c'])
if self._kac_moody:
d = FiniteEnumeratedSet(['d'])
keys = DisjointUnionEnumeratedSets([c, d, K])
else:
keys = DisjointUnionEnumeratedSets([c, K])
return Family(keys, self.monomial)
def __init__(self, s):
"""
TESTS::
sage: s = Subsets(Set([1]))
sage: e = s.first()
sage: isinstance(e, s.element_class)
True
In the following "_test_elements" is temporarily disabled
until :class:`sage.sets.set.Set_object_enumerated` objects
pass the category tests::
sage: S = Subsets([1,2,3])
sage: TestSuite(S).run(skip=["_test_elements"])
sage: S = sage.sets.set.Set_object_enumerated([1,2])
sage: TestSuite(S).run() # todo: not implemented
"""
Parent.__init__(self, category=EnumeratedSets().Finite())
if s not in EnumeratedSets():
from sage.misc.misc import uniq
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
s = list(s)
us = uniq(s)
if len(us) == len(s):
s = FiniteEnumeratedSet(s)
else:
s = FiniteEnumeratedSet(us)
self._s = s
def __init__(self, R, A):
"""
Initialize ``self``.
TESTS::
sage: C4 = graphs.CycleGraph(4)
sage: A = groups.misc.RightAngledArtin(C4)
sage: H = A.cohomology()
sage: TestSuite(H).run()
"""
if R not in Fields():
raise NotImplementedError(
"only implemented with coefficients in a field")
self._group = A
names = tuple(['e' + name[1:] for name in A.variable_names()])
from sage.graphs.independent_sets import IndependentSets
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
indices = [tuple(ind_set) for ind_set in IndependentSets(A._graph)]
indices = FiniteEnumeratedSet(indices)
cat = AlgebrasWithBasis(
R.category()).Super().Graded().FiniteDimensional()
CombinatorialFreeModule.__init__(self,
R,
indices,
category=cat,
prefix='H')
self._assign_names(names)
def _element_constructor_(self, data):
r"""
Build an element of that set from ``data``.
EXAMPLES::
sage: S1 = TotallyOrderedFiniteSet([1,2,3])
sage: x = S1(1); x # indirect doctest
1
sage: x.parent()
Integer Ring
sage: S2 = TotallyOrderedFiniteSet([3,2,1], facade=False)
sage: y = S2(1); y # indirect doctest
1
sage: y.parent()
{3, 2, 1}
sage: y in S2
True
sage: S2(y) is y
True
"""
if self._facade_elements is None:
return FiniteEnumeratedSet._element_constructor_(self, data)
try:
i = self._facade_elements.index(data)
except ValueError:
raise ValueError("%s not in %s"%(data, self))
return self._elements[i]
def strongly_fatter(self):
"""
Return the set of ordered set partitions which are strongly fatter
than ``self``.
See :meth:`strongly_finer` for the definition of "strongly fatter".
EXAMPLES::
sage: C = OrderedSetPartition([[2, 5], [1], [3, 4]]).strongly_fatter()
sage: C.cardinality()
2
sage: sorted(C)
[[{2, 5}, {1, 3, 4}],
[{2, 5}, {1}, {3, 4}]]
sage: OrderedSetPartition([[4, 9], [-1, 2]]).strongly_fatter().list()
[[{4, 9}, {-1, 2}]]
Some extreme cases::
sage: list(OrderedSetPartition([[5]]).strongly_fatter())
[[{5}]]
sage: list(OrderedSetPartition([]).strongly_fatter())
[[]]
sage: sorted(OrderedSetPartition([[1], [2], [3], [4]]).strongly_fatter())
[[{1, 2, 3, 4}],
[{1, 2, 3}, {4}],
[{1, 2}, {3, 4}],
[{1, 2}, {3}, {4}],
[{1}, {2, 3, 4}],
[{1}, {2, 3}, {4}],
[{1}, {2}, {3, 4}],
[{1}, {2}, {3}, {4}]]
sage: sorted(OrderedSetPartition([[1], [3], [2], [4]]).strongly_fatter())
[[{1, 3}, {2, 4}],
[{1, 3}, {2}, {4}],
[{1}, {3}, {2, 4}],
[{1}, {3}, {2}, {4}]]
sage: sorted(OrderedSetPartition([[4], [1], [5], [3]]).strongly_fatter())
[[{4}, {1, 5}, {3}], [{4}, {1}, {5}, {3}]]
"""
c = [sorted(X) for X in self]
l = len(c)
g = [-1] + [i
for i in range(l - 1) if c[i][-1] > c[i + 1][0]] + [l - 1]
# g lists the positions of the blocks that cannot be merged
# with their right neighbors.
subcomps = [
OrderedSetPartition(c[g[i] + 1:g[i + 1] + 1])
for i in range(len(g) - 1)
]
# Now, self is the concatenation of the entries of subcomps.
# We can fatten each of the ordered set partitions setcomps
# arbitrarily, and then concatenate the results.
fattenings = [list(subcomp.fatter()) for subcomp in subcomps]
return FiniteEnumeratedSet([
OrderedSetPartition(sum([list(gg) for gg in fattening], []))
for fattening in cartesian_product(fattenings)
])
def __init__(self, n, k, q, F):
r"""
Initialize ``self``.
EXAMPLES::
sage: Cl = algebras.QuantumClifford(1,2)
sage: TestSuite(Cl).run(elements=Cl.basis())
sage: Cl = algebras.QuantumClifford(1,3)
sage: TestSuite(Cl).run(elements=Cl.basis()) # long time
sage: Cl = algebras.QuantumClifford(3) # long time
sage: elts = Cl.some_elements() + list(Cl.algebra_generators()) # long time
sage: TestSuite(Cl).run(elements=elts) # long time
sage: Cl = algebras.QuantumClifford(2,4) # long time
sage: elts = Cl.some_elements() + list(Cl.algebra_generators()) # long time
sage: TestSuite(Cl).run(elements=elts) # long time
"""
self._n = n
self._k = k
self._q = q
self._psi = cartesian_product([(-1,0,1)]*n)
self._w_poly = PolynomialRing(F, n, 'w')
indices = [(tuple(psi), tuple(w))
for psi in self._psi
for w in product(*[list(range((4-2*abs(psi[i]))*k)) for i in range(n)])]
indices = FiniteEnumeratedSet(indices)
cat = Algebras(F).FiniteDimensional().WithBasis()
CombinatorialFreeModule.__init__(self, F, indices, category=cat)
self._assign_names(self.algebra_generators().keys())
def _element_constructor_(self, data):
r"""
Build an element of that set from ``data``.
EXAMPLES::
sage: S1 = TotallyOrderedFiniteSet([1,2,3])
sage: x = S1(1); x # indirect doctest
1
sage: x.parent()
Integer Ring
sage: S2 = TotallyOrderedFiniteSet([3,2,1], facade=False)
sage: y = S2(1); y # indirect doctest
1
sage: y.parent()
{3, 2, 1}
sage: y in S2
True
sage: S2(y) is y
True
"""
if self._facade_elements is None:
return FiniteEnumeratedSet._element_constructor_(self, data)
try:
i = self._facade_elements.index(data)
except ValueError:
raise ValueError("%s not in %s" % (data, self))
return self._elements[i]
def graded_component(self, grade):
r"""
Return the component with grade ``grade``.
EXAMPLES::
sage: N = SetsWithGrading().example()
sage: N.graded_component(65)
{65}
"""
return FiniteEnumeratedSet([grade])
def basis(self, reg=None):
if reg is None:
reg = region()
b = self._other.basis(reg + self._neg)
if b.cardinality() == 0:
return FiniteEnumeratedSet(())
x = next(iter(b))
dom = suspension(x.parent(), **self._kwargs)
mapfunc = lambda x: x.suspend(**self._kwargs)
unmapfunc = lambda x: x.suspend(
t=self._neg.t, e=self._neg.e, s=self._neg.s)
return SetOfElements(dom, b, b.cardinality(), mapfunc, unmapfunc)
def __classcall_private__(cls,
domain,
codomain=None,
action="left",
category=None):
"""
TESTS::
sage: FiniteSetMaps(3)
Maps from {0, 1, 2} to itself
sage: FiniteSetMaps(4, 2)
Maps from {0, 1, 2, 3} to {0, 1}
sage: FiniteSetMaps(4, ["a","b","c"])
Maps from {0, 1, 2, 3} to {'a', 'b', 'c'}
sage: FiniteSetMaps([1,2], ["a","b","c"])
Maps from {1, 2} to {'a', 'b', 'c'}
sage: FiniteSetMaps([1,2,4], 3)
Maps from {1, 2, 4} to {0, 1, 2}
"""
if codomain is None:
if isinstance(domain, (int, Integer)):
return FiniteSetEndoMaps_N(domain, action, category)
else:
if domain not in Sets():
domain = FiniteEnumeratedSet(domain)
return FiniteSetEndoMaps_Set(domain, action, category)
if isinstance(domain, (int, Integer)):
if isinstance(codomain, (int, Integer)):
return FiniteSetMaps_MN(domain, codomain, category)
else:
domain = IntegerRange(domain)
if isinstance(codomain, (int, Integer)):
codomain = IntegerRange(codomain)
if domain not in Sets():
domain = FiniteEnumeratedSet(domain)
if codomain not in Sets():
codomain = FiniteEnumeratedSet(codomain)
return FiniteSetMaps_Set(domain, codomain, category)
def __init__(self):
r"""
TESTS::
sage: from sage.rings.valuation.value_group import DiscreteValuationCodomain
sage: isinstance(QQ.valuation(2).codomain(), DiscreteValuationCodomain)
True
"""
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
from sage.categories.additive_monoids import AdditiveMonoids
UniqueRepresentation.__init__(self)
Parent.__init__(self, facade=(QQ, FiniteEnumeratedSet([infinity, -infinity])), category=AdditiveMonoids())
def __classcall__(cls, indices, prefix="F", **kwds):
"""
TESTS::
sage: F = FreeAbelianMonoid(index_set=['a','b','c'])
sage: G = FreeAbelianMonoid(index_set=('a','b','c'))
sage: H = FreeAbelianMonoid(index_set=tuple('abc'))
sage: F is G and F is H
True
sage: F = FreeAbelianMonoid(index_set=['a','b','c'], latex_bracket=['LEFT', 'RIGHT'])
sage: F.print_options()['latex_bracket']
('LEFT', 'RIGHT')
sage: F is G
False
sage: Groups.Commutative.free()
Traceback (most recent call last):
...
ValueError: no index set specified
"""
if isinstance(indices, str):
indices = FiniteEnumeratedSet(list(indices))
elif isinstance(indices, (list, tuple)):
indices = FiniteEnumeratedSet(indices)
elif indices is None:
if kwds.get('names', None) is None:
raise ValueError("no index set specified")
indices = FiniteEnumeratedSet(kwds['names'])
# bracket or latex_bracket might be lists, so convert
# them to tuples so that they're hashable.
bracket = kwds.get('bracket', None)
if isinstance(bracket, list):
kwds['bracket'] = tuple(bracket)
latex_bracket = kwds.get('latex_bracket', None)
if isinstance(latex_bracket, list):
kwds['latex_bracket'] = tuple(latex_bracket)
return super(IndexedMonoid, cls).__classcall__(cls, indices, prefix,
**kwds)
def __init__(self, R, cartan_matrix, wt, prefix):
"""
Initialize ``self``.
"""
self._cartan_matrix = cartan_matrix
self._weight = wt
self._d = sum(wt)
# Reduced words
#red_words = Family(Permutations(self._d), lambda p: tuple(p.reduced_word()))
red_words = FiniteEnumeratedSet([tuple(p.reduced_word())
for p in Permutations(self._d)])
red_words.rename("reduced words of S_{}".format(self._d))
# The monomials
M = FreeAbelianMonoid(self._d, names=['x%s'%i for i in range(1, self._d+1)])
# Idempotents (i.e. the colors of the strands)
index_set = self._cartan_matrix.index_set()
P = Permutations(sum([[index_set[i]]*v for i,v in enumerate(wt)],[]))
I = cartesian_product([red_words, M, P])
CombinatorialFreeModule.__init__(self, R, I, prefix=prefix,
monomial_key=KLRAlgebra._monomial_key,
category=Algebras(R).WithBasis().Graded())
def finer(self):
"""
Return the set of ordered set partitions which are finer
than ``self``.
See :meth:`is_finer` for the definition of "finer".
EXAMPLES::
sage: C = OrderedSetPartition([[1, 3], [2]]).finer()
sage: C.cardinality()
3
sage: C.list()
[[{1}, {3}, {2}], [{3}, {1}, {2}], [{1, 3}, {2}]]
sage: OrderedSetPartition([]).finer()
{[]}
sage: W = OrderedSetPartition([[4, 9], [-1, 2]])
sage: W.finer().list()
[[{9}, {4}, {2}, {-1}],
[{9}, {4}, {-1}, {2}],
[{9}, {4}, {-1, 2}],
[{4}, {9}, {2}, {-1}],
[{4}, {9}, {-1}, {2}],
[{4}, {9}, {-1, 2}],
[{4, 9}, {2}, {-1}],
[{4, 9}, {-1}, {2}],
[{4, 9}, {-1, 2}]]
"""
par = parent(self)
if not self:
return FiniteEnumeratedSet([self])
else:
return FiniteEnumeratedSet([
par(sum((list(i) for i in C), [])) for C in cartesian_product(
[OrderedSetPartitions(X) for X in self])
])
def __init__(self, R):
"""
Initialize ``self``.
EXAMPLES::
sage: O = lie_algebras.OnsagerAlgebra(QQ)
sage: TestSuite(O).run()
"""
cat = LieAlgebras(R).WithBasis()
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
IndexedGenerators.__init__(self, FiniteEnumeratedSet([0,1]))
LieAlgebraWithGenerators.__init__(self, R, index_set=self._indices,
names=('A0', 'A1'), category=cat)
def _indices(self):
r"""
Return the set of indices for the basis of ``self``.
EXAMPLES::
sage: L.<x,y,z> = LieAlgebra(QQ, abelian=True)
sage: S = L.subalgebra([x, y])
sage: S._indices
{0, 1}
sage: [S.basis()[k] for k in S._indices]
[x, y]
"""
return FiniteEnumeratedSet(self.basis().keys())
def __init__(self):
r"""
TESTS::
sage: sys.path.append(os.getcwd()); from mac_lane import * # optional: standalone
sage: isinstance(pAdicValuation(QQ, 2).codomain(), DiscreteValuationCodomain)
True
"""
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
from sage.categories.additive_monoids import AdditiveMonoids
UniqueRepresentation.__init__(self)
Parent.__init__(self,
facade=(QQ, FiniteEnumeratedSet([infinity,
-infinity])),
category=AdditiveMonoids())
def __classcall__(cls, *args):
"""
TESTS::
sage: from sage.sets.integer_range import IntegerRangeEmpty
sage: I = IntegerRangeEmpty(); I
{}
sage: I.category()
Category of facade finite enumerated sets
sage: TestSuite(I).run()
sage: I(0)
Traceback (most recent call last):
...
ValueError: 0 not in {}
"""
return FiniteEnumeratedSet.__classcall__(cls, ())
def __classcall__(cls, *args):
"""
TESTS::
sage: from sage.sets.integer_range import IntegerRangeEmpty
sage: I = IntegerRangeEmpty(); I
{}
sage: I.category()
Category of facade finite enumerated sets
sage: TestSuite(I).run()
sage: I(0)
Traceback (most recent call last):
...
ValueError: 0 not in {}
"""
return FiniteEnumeratedSet.__classcall__(cls, ())
def _domain(self):
r"""
The integers labeling the roots on which this Galois group acts.
EXAMPLES::
sage: R.<x> = ZZ[]
sage: K.<a> = NumberField(x^5-2)
sage: G = K.galois_group(gc_numbering=False); G
Galois group 5T3 (5:4) with order 20 of x^5 - 2
sage: G._domain
{1, 2, 3, 4, 5}
sage: G = K.galois_group(gc_numbering=True); G._domain
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
"""
return FiniteEnumeratedSet(range(1, self._deg + 1))
def __init__(self):
r"""
EXAMPLES::
sage: from sage.categories.examples.facade_sets import IntegersCompletion
sage: S = IntegersCompletion(); S
An example of a facade set: the integers completed by +-infinity
TESTS::
sage: TestSuite(S).run()
"""
# We can't use InfinityRing, because this ring contains 3
# elements besides +-infinity. We can't use Set either for the
# moment, because Set([1,2])(1) raises an error
Parent.__init__(self, facade = (ZZ, FiniteEnumeratedSet([-infinity, +infinity])), category = Sets())
def __init__(self, R):
r"""
Initialize ``self``.
EXAMPLES::
sage: L = lie_algebras.RankTwoHeisenbergVirasoro(QQ)
sage: TestSuite(L).run()
"""
cat = LieAlgebras(R).WithBasis()
self._KI = FiniteEnumeratedSet([1, 2, 3, 4])
self._V = ZZ**2
d = {'K': self._KI, 'E': self._V, 't': self._V}
indices = DisjointUnionEnumeratedSets(d, keepkey=True, facade=True)
InfinitelyGeneratedLieAlgebra.__init__(self,
R,
index_set=indices,
category=cat)
IndexedGenerators.__init__(self, indices, sorting_key=self._basis_key)
def T_all(self):
"""
Return the ring of characters of left/right-class modules
.. note:: This includes both regular and non regular
modules. So this is in general not isomorphic to
the other character rings, and the indexing set
may be completely unrelated.
.. todo:: add a good example, and find a good name
EXAMPLES::
"""
from sage_semigroups.monoids.character_ring import CharacterRing
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
return CharacterRing(self,
prefix="T",
modules="%s-class" % self.side(),
index_set=FiniteEnumeratedSet(
self.base().j_classes().keys()))
def simple_modules_index_set(self):
"""
Return an indexing set for the simple modules of ``self``
This indexing set is sorted decreasingly along `J`-order.
This default implementation uses the same indexing set as
for the j_classes, as given by::
:meth:`Semigroups.Finite.ParentMethods.regular_j_classes_keys`.
EXAMPLES::
sage: S = Monoids().HTrivial().Finite().example(5); S
The finite H-trivial monoid of order preserving maps on {1, 2, 3, 4, 5}
sage: S.simple_modules_index_set()
{0, 1, 2, 3, 4}
"""
result = self.j_transversal_of_idempotents().keys()
if isinstance(result, list):
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
result = FiniteEnumeratedSet(result)
return result
def __init__(self, R, n):
"""
Initialize ``self``.
EXAMPLES::
sage: g = lie_algebras.gl(QQ, 4)
sage: TestSuite(g).run()
TESTS:
Check that :trac:`23266` is fixed::
sage: gl2 = lie_algebras.gl(QQ, 2)
sage: isinstance(gl2.basis().keys(), FiniteEnumeratedSet)
True
sage: Ugl2 = gl2.pbw_basis()
sage: prod(Ugl2.gens())
PBW['E_0_0']*PBW['E_0_1']*PBW['E_1_0']*PBW['E_1_1']
"""
MS = MatrixSpace(R, n, sparse=True)
one = R.one()
names = []
gens = []
for i in range(n):
for j in range(n):
names.append('E_{0}_{1}'.format(i,j))
mat = MS({(i,j):one})
mat.set_immutable()
gens.append(mat)
self._n = n
category = LieAlgebras(R).FiniteDimensional().WithBasis()
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
index_set = FiniteEnumeratedSet(names)
LieAlgebraFromAssociative.__init__(self, MS, tuple(gens),
names=tuple(names),
index_set=index_set,
category=category)
def __init__(self, R, ct, e, f, h):
"""
Initialize ``self``.
EXAMPLES::
sage: g = lie_algebras.sl(QQ, 3, representation='matrix')
sage: TestSuite(g).run()
TESTS:
Check that :trac:`23266` is fixed::
sage: sl2 = lie_algebras.sl(QQ, 2, 'matrix')
sage: isinstance(sl2.indices(), FiniteEnumeratedSet)
True
"""
n = len(e)
names = ['e%s'%i for i in range(1, n+1)]
names += ['f%s'%i for i in range(1, n+1)]
names += ['h%s'%i for i in range(1, n+1)]
category = LieAlgebras(R).FiniteDimensional().WithBasis()
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
index_set = FiniteEnumeratedSet(names)
LieAlgebraFromAssociative.__init__(self, e[0].parent(),
gens=tuple(e + f + h),
names=tuple(names),
index_set=index_set,
category=category)
self._cartan_type = ct
gens = tuple(self.gens())
i_set = ct.index_set()
self._e = Family(dict( (i, gens[c]) for c,i in enumerate(i_set) ))
self._f = Family(dict( (i, gens[n+c]) for c,i in enumerate(i_set) ))
self._h = Family(dict( (i, gens[2*n+c]) for c,i in enumerate(i_set) ))
def polygon_labels(self):
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
from sage.categories.cartesian_product import cartesian_product
return cartesian_product(
[self._words, FiniteEnumeratedSet([0, 1, 2, 3])])
def standardize_names_index_set(names=None, index_set=None, ngens=None):
"""
Standardize the ``names`` and ``index_set`` inputs.
INPUT:
- ``names`` -- (optional) the variable names
- ``index_set`` -- (optional) the index set
- ``ngens`` -- (optional) the number of generators
If ``ngens`` is a negative number, then this does not check that
the number of variable names matches the size of the index set.
OUTPUT:
A pair ``(names_std, index_set_std)``, where ``names_std`` is either
``None`` or a tuple of strings, and where ``index_set_std`` is a finite
enumerated set.
The purpose of ``index_set_std`` is to index the generators of some object
(e.g., the basis of a module); the strings in ``names_std``, when they
exist, are used for printing these indices. The ``ngens``
If ``names`` contains exactly one name ``X`` and ``ngens`` is greater than
1, then ``names_std`` are ``Xi`` for ``i`` in ``range(ngens)``.
TESTS::
sage: from sage.structure.indexed_generators import standardize_names_index_set
sage: standardize_names_index_set('x,y')
(('x', 'y'), {'x', 'y'})
sage: standardize_names_index_set(['x','y'])
(('x', 'y'), {'x', 'y'})
sage: standardize_names_index_set(['x','y'], ['a','b'])
(('x', 'y'), {'a', 'b'})
sage: standardize_names_index_set('x,y', ngens=2)
(('x', 'y'), {'x', 'y'})
sage: standardize_names_index_set(index_set=['a','b'], ngens=2)
(None, {'a', 'b'})
sage: standardize_names_index_set('x', ngens=3)
(('x0', 'x1', 'x2'), {'x0', 'x1', 'x2'})
sage: standardize_names_index_set()
Traceback (most recent call last):
...
ValueError: the index_set, names, or number of generators must be specified
sage: standardize_names_index_set(['x'], ['a', 'b'])
Traceback (most recent call last):
...
IndexError: the number of names must equal the size of the indexing set
sage: standardize_names_index_set('x,y', ['a'])
Traceback (most recent call last):
...
IndexError: the number of names must equal the size of the indexing set
sage: standardize_names_index_set('x,y,z', ngens=2)
Traceback (most recent call last):
...
IndexError: the number of names must equal the number of generators
sage: standardize_names_index_set(index_set=['a'], ngens=2)
Traceback (most recent call last):
...
IndexError: the size of the indexing set must equal the number of generators
"""
if names is not None:
if ngens is None or ngens < 0:
names = normalize_names(-1, names)
else:
names = normalize_names(ngens, names)
if index_set is None:
if names is None:
# If neither is specified, we make range(ngens) the index set
if ngens is None:
raise ValueError("the index_set, names, or number of"
" generators must be specified")
index_set = tuple(range(ngens))
else:
# If only the names are specified, then we make the indexing set
# be the names
index_set = tuple(names)
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
if isinstance(index_set, dict): # dict of {name: index} -- not likely to be used
if names is not None:
raise ValueError("cannot give index_set as a dict and names")
names = normalize_names(-1, tuple(index_set.keys()))
index_set = FiniteEnumeratedSet([index_set[n] for n in names])
elif isinstance(index_set, str):
index_set = FiniteEnumeratedSet(list(index_set))
elif isinstance(index_set, (tuple, list)):
index_set = FiniteEnumeratedSet(index_set)
if ngens is None or ngens >= 0:
if names is not None:
if len(names) != index_set.cardinality():
raise IndexError("the number of names must equal"
" the size of the indexing set")
if ngens is not None and len(names) != ngens:
raise IndexError("the number of names must equal the"
" number of generators")
elif ngens is not None and index_set.cardinality() != ngens:
raise IndexError("the size of the indexing set must equal"
" the number of generators")
return (names, index_set)
def __init__(self, R, cartan_type):
r"""
Initialize ``self``.
TESTS::
sage: L = LieAlgebra(QQ, cartan_type=['A',2])
sage: TestSuite(L).run() # long time
"""
self._cartan_type = cartan_type
RL = cartan_type.root_system().root_lattice()
alpha = RL.simple_roots()
p_roots = list(RL.positive_roots_by_height())
n_roots = [-x for x in p_roots]
self._p_roots_index = {al: i for i,al in enumerate(p_roots)}
alphacheck = RL.simple_coroots()
roots = frozenset(RL.roots())
num_sroots = len(alpha)
one = R.one()
# Determine the signs for the structure coefficients from the root system
# We first create the special roots
sp_sign = {}
for i,a in enumerate(p_roots):
for b in p_roots[i+1:]:
if a + b not in p_roots:
continue
# Compute the sign for the extra special pair
x, y = (a + b).extraspecial_pair()
if (x, y) == (a, b): # If it already is an extra special pair
if (x, y) not in sp_sign:
# This swap is so the structure coefficients match with GAP
if (sum(x.coefficients()) == sum(y.coefficients())
and str(x) > str(y)):
y,x = x,y
sp_sign[(x, y)] = -one
sp_sign[(y, x)] = one
continue
if b - x in roots:
t1 = ((b-x).norm_squared() / b.norm_squared()
* sp_sign[(x, b-x)] * sp_sign[(a, y-a)])
else:
t1 = 0
if a - x in roots:
t2 = ((a-x).norm_squared() / a.norm_squared()
* sp_sign[(x, a-x)] * sp_sign[(b, y-b)])
else:
t2 = 0
if t1 - t2 > 0:
sp_sign[(a,b)] = -one
elif t2 - t1 > 0:
sp_sign[(a,b)] = one
sp_sign[(b,a)] = -sp_sign[(a,b)]
# Function to construct the structure coefficients (up to sign)
def e_coeff(r, s):
p = 1
while r - p*s in roots:
p += 1
return p
# Now we can compute all necessary structure coefficients
s_coeffs = {}
for i,r in enumerate(p_roots):
# [e_r, h_i] and [h_i, f_r]
for ac in alphacheck:
c = r.scalar(ac)
if c == 0:
continue
s_coeffs[(r, ac)] = {r: -c}
s_coeffs[(ac, -r)] = {-r: -c}
# [e_r, f_r]
s_coeffs[(r, -r)] = {alphacheck[j]: c
for j, c in r.associated_coroot()}
# [e_r, e_s] and [e_r, f_s] with r != +/-s
# We assume s is positive, as otherwise we negate
# both r and s and the resulting coefficient
for j, s in enumerate(p_roots[i+1:]):
j += i+1 # Offset
# Since h(s) >= h(r), we have s - r > 0 when s - r is a root
# [f_r, e_s]
if s - r in p_roots:
c = e_coeff(r, -s)
a, b = s-r, r
if self._p_roots_index[a] > self._p_roots_index[b]: # Note a != b
c *= -sp_sign[(b, a)]
else:
c *= sp_sign[(a, b)]
s_coeffs[(-r, s)] = {a: -c}
s_coeffs[(r, -s)] = {-a: c}
# [e_r, e_s]
a = r + s
if a in p_roots:
# (r, s) is a special pair
c = e_coeff(r, s) * sp_sign[(r, s)]
s_coeffs[(r, s)] = {a: c}
s_coeffs[(-r, -s)] = {-a: -c}
# Lastly, make sure a < b for all (a, b) in the coefficients and flip if necessary
for k in s_coeffs.keys():
a,b = k[0], k[1]
if self._basis_key(a) > self._basis_key(b):
s_coeffs[(b,a)] = [(index, -v) for index,v in s_coeffs[k].items()]
del s_coeffs[k]
else:
s_coeffs[k] = s_coeffs[k].items()
names = ['e{}'.format(i) for i in range(1, num_sroots+1)]
names += ['f{}'.format(i) for i in range(1, num_sroots+1)]
names += ['h{}'.format(i) for i in range(1, num_sroots+1)]
category = LieAlgebras(R).FiniteDimensional().WithBasis()
index_set = p_roots + list(alphacheck) + n_roots
names = tuple(names)
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
index_set = FiniteEnumeratedSet(index_set)
LieAlgebraWithStructureCoefficients.__init__(self, R, s_coeffs, names, index_set,
category, prefix='E', bracket='[',
sorting_key=self._basis_key)
def standardize_names_index_set(names=None, index_set=None, ngens=None):
"""
Standardize the ``names`` and ``index_set`` inputs.
INPUT:
- ``names`` -- (optional) the variable names
- ``index_set`` -- (optional) the index set
- ``ngens`` -- (optional) the number of generators
If ``ngens`` is a negative number, then this does not check that
the number of variable names matches the size of the index set.
OUTPUT:
A pair ``(names_std, index_set_std)``, where ``names_std`` is either
``None`` or a tuple of strings, and where ``index_set_std`` is a finite
enumerated set.
The purpose of ``index_set_std`` is to index the generators of some object
(e.g., the basis of a module); the strings in ``names_std``, when they
exist, are used for printing these indices. The ``ngens``
If ``names`` contains exactly one name ``X`` and ``ngens`` is greater than
1, then ``names_std`` are ``Xi`` for ``i`` in ``range(ngens)``.
TESTS::
sage: from sage.structure.indexed_generators import standardize_names_index_set
sage: standardize_names_index_set('x,y')
(('x', 'y'), {'x', 'y'})
sage: standardize_names_index_set(['x','y'])
(('x', 'y'), {'x', 'y'})
sage: standardize_names_index_set(['x','y'], ['a','b'])
(('x', 'y'), {'a', 'b'})
sage: standardize_names_index_set('x,y', ngens=2)
(('x', 'y'), {'x', 'y'})
sage: standardize_names_index_set(index_set=['a','b'], ngens=2)
(None, {'a', 'b'})
sage: standardize_names_index_set('x', ngens=3)
(('x0', 'x1', 'x2'), {'x0', 'x1', 'x2'})
sage: standardize_names_index_set()
Traceback (most recent call last):
...
ValueError: the index_set, names, or number of generators must be specified
sage: standardize_names_index_set(['x'], ['a', 'b'])
Traceback (most recent call last):
...
IndexError: the number of names must equal the size of the indexing set
sage: standardize_names_index_set('x,y', ['a'])
Traceback (most recent call last):
...
IndexError: the number of names must equal the size of the indexing set
sage: standardize_names_index_set('x,y,z', ngens=2)
Traceback (most recent call last):
...
IndexError: the number of names must equal the number of generators
sage: standardize_names_index_set(index_set=['a'], ngens=2)
Traceback (most recent call last):
...
IndexError: the size of the indexing set must equal the number of generators
"""
if names is not None:
if ngens is None or ngens < 0:
names = normalize_names(-1, names)
else:
names = normalize_names(ngens, names)
if index_set is None:
if names is None:
# If neither is specified, we make range(ngens) the index set
if ngens is None:
raise ValueError("the index_set, names, or number of"
" generators must be specified")
index_set = tuple(range(ngens))
else:
# If only the names are specified, then we make the indexing set
# be the names
index_set = tuple(names)
from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
if isinstance(index_set,
dict): # dict of {name: index} -- not likely to be used
if names is not None:
raise ValueError("cannot give index_set as a dict and names")
names = normalize_names(-1, tuple(index_set.keys()))
index_set = FiniteEnumeratedSet([index_set[n] for n in names])
elif isinstance(index_set, str):
index_set = FiniteEnumeratedSet(list(index_set))
elif isinstance(index_set, (tuple, list)):
index_set = FiniteEnumeratedSet(index_set)
if ngens is None or ngens >= 0:
if names is not None:
if len(names) != index_set.cardinality():
raise IndexError("the number of names must equal"
" the size of the indexing set")
if ngens is not None and len(names) != ngens:
raise IndexError("the number of names must equal the"
" number of generators")
elif ngens is not None and index_set.cardinality() != ngens:
raise IndexError("the size of the indexing set must equal"
" the number of generators")
return (names, index_set)
def Subwords(w, k=None, element_constructor=None):
"""
Return the set of subwords of ``w``.
INPUT:
- ``w`` -- a word (can be a list, a string, a tuple or a word)
- ``k`` -- an optional integer to specify the length of subwords
- ``element_constructor`` -- an optional function that will be used
to build the subwords
EXAMPLES::
sage: S = Subwords(['a','b','c']); S
Subwords of ['a', 'b', 'c']
sage: S.first()
[]
sage: S.last()
['a', 'b', 'c']
sage: S.list()
[[], ['a'], ['b'], ['c'], ['a', 'b'], ['a', 'c'], ['b', 'c'], ['a', 'b', 'c']]
The same example using string, tuple or a word::
sage: S = Subwords('abc'); S
Subwords of 'abc'
sage: S.list()
['', 'a', 'b', 'c', 'ab', 'ac', 'bc', 'abc']
sage: S = Subwords((1,2,3)); S
Subwords of (1, 2, 3)
sage: S.list()
[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
sage: w = Word([1,2,3])
sage: S = Subwords(w); S
Subwords of word: 123
sage: S.list()
[word: , word: 1, word: 2, word: 3, word: 12, word: 13, word: 23, word: 123]
Using word with specified length::
sage: S = Subwords(['a','b','c'], 2); S
Subwords of ['a', 'b', 'c'] of length 2
sage: S.list()
[['a', 'b'], ['a', 'c'], ['b', 'c']]
An example that uses the ``element_constructor`` argument::
sage: p = Permutation([3,2,1])
sage: Subwords(p, element_constructor=tuple).list()
[(), (3,), (2,), (1,), (3, 2), (3, 1), (2, 1), (3, 2, 1)]
sage: Subwords(p, 2, element_constructor=tuple).list()
[(3, 2), (3, 1), (2, 1)]
"""
if element_constructor is None:
datatype = type(w) # 'datatype' is the type of w
if datatype is list or datatype is tuple:
element_constructor = datatype
elif datatype is str:
element_constructor = _stringification
else:
from sage.combinat.words.words import Words
try:
alphabet = w.parent().alphabet()
element_constructor = Words(alphabet)
except AttributeError:
element_constructor = list
if k is None:
return Subwords_w(w, element_constructor)
if not isinstance(k, (int, Integer)):
raise ValueError("k should be an integer")
if k < 0 or k > len(w):
return FiniteEnumeratedSet([])
return Subwords_wk(w, k, element_constructor)
