def __init__(self, n, k):
"""
TESTS::
sage: LW23 = LyndonWords(2,3); LW23
Lyndon words from an alphabet of size 2 of length 3
sage: LW23== loads(dumps(LW23))
True
"""
self.n = Integer(n)
self.k = Integer(k)
alphabet = build_alphabet(range(1, self.n + 1))
super(LyndonWords_nk, self).__init__(alphabet, self.k)
def __init__(self, n, k):
"""
TESTS::
sage: LW23 = LyndonWords(2,3); LW23
Lyndon words from an alphabet of size 2 of length 3
sage: LW23== loads(dumps(LW23))
True
"""
self.n = Integer(n)
self.k = Integer(k)
alphabet = build_alphabet(range(1,self.n+1))
super(LyndonWords_nk,self).__init__(alphabet,self.k)
def __init__(self, pos, neg=None):
r"""
INPUT:
- ``pos`` - the alphabet of positive letters
- ``neg`` - the alphabet of negative letters
- ``bij`` - bijection between positive and negative letters
"""
Group.__init__(self, category=(Groups(),InfiniteEnumeratedSets()))
self._pos = pos
self._neg = neg
self._invert = {}
self._invert.update(zip(pos,neg))
self._invert.update(zip(neg,pos))
self._alphabet = build_alphabet(pos.list() + neg.list())
def build_alphabet_with_inverses(data, neg=None, names=None, name=None, negname=None):
r"""
Build two disjoint alphabets (i.e. sets) and a bijection between them from
the given data.
This is mainly used to build free groups.
EXAMPLES::
sage: build_alphabet_with_inverses('abc')
({'a', 'b', 'c'}, {'A', 'B', 'C'})
sage: build_alphabet(3, name='a')
({'a0', 'a1', 'a2'}, {'A0', 'A1', 'A2'})
TODO:
Fix conventions in order to fit with build_alphabet in
sage.combinat.words.alphabet
"""
if isinstance(data, (int,Integer)):
if name is None:
name = 'a'
if negname is None:
if name.islower():
negname = name.upper()
elif name.isupper():
negname = name.lower()
return build_alphabet([name+str(i) for i in xrange(data)]), build_alphabet([negname+str(i) for i in xrange(data)])
pos = build_alphabet(data)
if neg is None:
from sage.combinat.words.alphabet import set_of_letters
if all(letter in set_of_letters['lower'] for letter in pos):
neg = build_alphabet(''.join(pos).upper())
elif all(letter in set_of_letters['upper'] for letter in pos):
pos = build_alphabet(''.join(neg).lower())
else:
raise ValueError("not able to determine default inverse letters")
else:
neg = build_alphabet(neg)
assert pos.cardinality() == neg.cardinality()
for letter in pos:
if letter in neg:
raise ValueError("letter %s is both positive and negative"%letter)
for letter in neg:
if letter in pos:
raise ValueError("letter %s is both positive and negative"%letter)
return pos, neg
def polygon_labels(self):
from sage.combinat.words.alphabet import build_alphabet
return build_alphabet(self._polygons.keys())
def Words(alphabet=None, length=None, finite=True, infinite=True):
"""
Returns the combinatorial class of words of length k over an alphabet.
EXAMPLES::
sage: Words()
Words
sage: Words(length=7)
Words of length 7
sage: Words(5)
Words over {1, 2, 3, 4, 5}
sage: Words(5, 3)
Words of length 3 over {1, 2, 3, 4, 5}
sage: Words(5, infinite=False)
Words over {1, 2, 3, 4, 5}
sage: Words(5, finite=False)
Infinite Words over {1, 2, 3, 4, 5}
sage: Words('ab')
Words over {'a', 'b'}
sage: Words('ab', 2)
Words of length 2 over {'a', 'b'}
sage: Words('ab', infinite=False)
Words over {'a', 'b'}
sage: Words('ab', finite=False)
Infinite Words over {'a', 'b'}
sage: Words('positive integers', finite=False)
Infinite Words over Positive integers
sage: Words('natural numbers')
Words over Non negative integers
"""
if isinstance(alphabet, Words_all):
return alphabet
if alphabet is None:
if length is None:
if finite and infinite:
return Words_all()
elif finite:
raise NotImplementedError
else:
raise NotImplementedError
elif isinstance(length, (int,Integer)) and finite:
return Words_n(length)
else:
if isinstance(alphabet, (int,Integer)):
from sage.sets.integer_range import IntegerRange
alphabet = IntegerRange(1,alphabet+1)
elif alphabet == "integers" \
or alphabet == "positive integers" \
or alphabet == "natural numbers":
alphabet = build_alphabet(name=alphabet)
else:
alphabet = build_alphabet(data=alphabet)
if length is None:
if finite and infinite:
return Words_over_OrderedAlphabet(alphabet)
elif finite:
return FiniteWords_over_OrderedAlphabet(alphabet)
else:
return InfiniteWords_over_OrderedAlphabet(alphabet)
elif isinstance(length, (int,Integer)):
return FiniteWords_length_k_over_OrderedAlphabet(alphabet, length)
raise ValueError, "do not know how to make a combinatorial class of words from your input"
def Words(alphabet=None, length=None, finite=True, infinite=True):
"""
Returns the combinatorial class of words of length k over an alphabet.
EXAMPLES::
sage: Words()
Words
sage: Words(length=7)
Words of length 7
sage: Words(5)
Words over {1, 2, 3, 4, 5}
sage: Words(5, 3)
Words of length 3 over {1, 2, 3, 4, 5}
sage: Words(5, infinite=False)
Words over {1, 2, 3, 4, 5}
sage: Words(5, finite=False)
Infinite Words over {1, 2, 3, 4, 5}
sage: Words('ab')
Words over {'a', 'b'}
sage: Words('ab', 2)
Words of length 2 over {'a', 'b'}
sage: Words('ab', infinite=False)
Words over {'a', 'b'}
sage: Words('ab', finite=False)
Infinite Words over {'a', 'b'}
sage: Words('positive integers', finite=False)
Infinite Words over Positive integers
sage: Words('natural numbers')
Words over Non negative integers
"""
if isinstance(alphabet, Words_all):
return alphabet
if alphabet is None:
if length is None:
if finite and infinite:
return Words_all()
elif finite:
raise NotImplementedError
else:
raise NotImplementedError
elif isinstance(length, (int, Integer)) and finite:
return Words_n(length)
else:
if isinstance(alphabet, (int, Integer)):
from sage.sets.integer_range import IntegerRange
alphabet = IntegerRange(1, alphabet + 1)
elif alphabet == "integers" \
or alphabet == "positive integers" \
or alphabet == "natural numbers":
alphabet = build_alphabet(name=alphabet)
else:
alphabet = build_alphabet(data=alphabet)
if length is None:
if finite and infinite:
return Words_over_OrderedAlphabet(alphabet)
elif finite:
return FiniteWords_over_OrderedAlphabet(alphabet)
else:
return InfiniteWords_over_OrderedAlphabet(alphabet)
elif isinstance(length, (int, Integer)):
return FiniteWords_length_k_over_OrderedAlphabet(alphabet, length)
raise ValueError, "do not know how to make a combinatorial class of words from your input"
def build_alphabet_with_inverse(data, names=None, name=None, neg=None, inverse=None):
r"""
Returns a triple (positive_letters, negative_letters, involution on pos u
neg).
EXAMPLES::
sage: pos,neg,inverse = build_alphabet_with_inverse('abc')
sage: pos
{'a', 'b', 'c'}
sage: neg
{'A', 'B', 'C'}
sage: inverse('b')
'B'
sage: inverse('C')
'c'
sage: pos,neg,inverse=build_alphabet_with_inverse(3,'a')
sage: pos
{'a0', 'a1', 'a2'}
sage: neg
{'A0', 'A1', 'A2'}
sage: inverse('a0')
'A0'
sage: inverse('A0')
'a0'
"""
if data in Sets():
if neg in Sets():
assert data.cardinality() == neg.cardinality()
if inverse is not None:
return data,neg,inverse
else:
return data,neg,InverseFromRank(data,neg)
if isinstance(data, (int,long,Integer)):
if names is None:
from sage.sets.integer_range import IntegerRange
return IntegerRange(1,data+1), IntegerRange(-data,0), neg_operation
elif isinstance(names, str):
if is_lower_character(names):
pos = TotallyOrderedFiniteSet([names + '%d'%i for i in xrange(data)])
neg = TotallyOrderedFiniteSet([lower_upper(names) + '%d'%i for i in xrange(data)])
return pos,neg,fast_inverse_dictionnary(pos,neg)
raise ValueError("not possible")
if data is not None:
data = build_alphabet(data)
if neg is not None:
neg = build_alphabet(data)
assert data.cardinality() == neg.cardinality()
if data.is_finite():
return data,neg,fast_inverse_dictionnary(data,neg)
return data,neg,InverseFromRank(data,neg)
# now we want to build an inverse
if not data.is_finite():
raise ValueError("if ``pos`` is infinite you should provide ``neg``")
if all(is_lower_character(a) for a in data):
neg = build_alphabet([a.upper() for a in data])
inverse = lower_upper
elif all(is_positive_integer(a) for a in data):
neg = build_alphabet([-a for a in data])
inverse = neg_operation
else:
raise ValueError("does not know how to build ``neg`` from the given ``pos``")
return data,neg,inverse
def build_alphabet_with_inverse(data,
names=None,
name=None,
neg=None,
inverse=None):
r"""
Returns a triple (positive_letters, negative_letters, involution on pos u
neg).
EXAMPLES::
sage: pos,neg,inverse = build_alphabet_with_inverse('abc')
sage: pos
{'a', 'b', 'c'}
sage: neg
{'A', 'B', 'C'}
sage: inverse('b')
'B'
sage: inverse('C')
'c'
sage: pos,neg,inverse=build_alphabet_with_inverse(3,'a')
sage: pos
{'a0', 'a1', 'a2'}
sage: neg
{'A0', 'A1', 'A2'}
sage: inverse('a0')
'A0'
sage: inverse('A0')
'a0'
"""
if data in Sets():
if neg in Sets():
assert data.cardinality() == neg.cardinality()
if inverse is not None:
return data, neg, inverse
else:
return data, neg, InverseFromRank(data, neg)
if isinstance(data, (int, long, Integer)):
if names is None:
from sage.sets.integer_range import IntegerRange
return IntegerRange(1, data + 1), IntegerRange(-data,
0), neg_operation
elif isinstance(names, str):
if is_lower_character(names):
pos = TotallyOrderedFiniteSet(
[names + '%d' % i for i in xrange(data)])
neg = TotallyOrderedFiniteSet(
[lower_upper(names) + '%d' % i for i in xrange(data)])
return pos, neg, fast_inverse_dictionnary(pos, neg)
raise ValueError("not possible")
if data is not None:
data = build_alphabet(data)
if neg is not None:
neg = build_alphabet(data)
assert data.cardinality() == neg.cardinality()
if data.is_finite():
return data, neg, fast_inverse_dictionnary(data, neg)
return data, neg, InverseFromRank(data, neg)
# now we want to build an inverse
if not data.is_finite():
raise ValueError("if ``pos`` is infinite you should provide ``neg``")
if all(is_lower_character(a) for a in data):
neg = build_alphabet([a.upper() for a in data])
inverse = lower_upper
elif all(is_positive_integer(a) for a in data):
neg = build_alphabet([-a for a in data])
inverse = neg_operation
else:
raise ValueError(
"does not know how to build ``neg`` from the given ``pos``")
return data, neg, inverse
