def __init__(self, R, names): """ Initialize ``self``. EXAMPLES:: sage: D = ShuffleAlgebra(QQ, 'ab').dual_pbw_basis() sage: TestSuite(D).run() """ self._alphabet = names self._alg = ShuffleAlgebra(R, names) CombinatorialFreeModule.__init__(self, R, Words(names), prefix='S', category=(AlgebrasWithBasis(R), CommutativeAlgebras(R), CoalgebrasWithBasis(R)))
def __init__(self, w=ZZ_1, r=ZZ_2, h1=ZZ_1, h2=ZZ_1): from sage.combinat.words.words import Words field = Sequence([w, r, h1, h2]).universe() if not field.is_field(): field = field.fraction_field() self._w = field(w) self._r = field(r) self._h1 = field(h1) self._h2 = field(h2) self._words = Words('LR', finite=True, infinite=False) self._wL = self._words('L') self._wR = self._words('R') base_label = self.polygon_labels()._cartesian_product_of_elements( (self._words(''), 0)) Surface.__init__(self, field, base_label, finite=False)
def __init__(self, R, n, names): """ Initialize ``self``. EXAMPLES:: sage: Z.<x,y,z> = algebras.FreeZinbiel(QQ) sage: TestSuite(Z).run() """ if R not in Rings: raise TypeError("argument R must be a ring") indices = Words(Alphabet(n, names=names)) cat = MagmaticAlgebras(R).WithBasis() self._n = n CombinatorialFreeModule.__init__(self, R, indices, prefix='Z', category=cat) self._assign_names(names)
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]) TESTS:: sage: A = ShuffleAlgebra(ZZ,[0,1]) sage: A.algebra_generators() Family (B[word: 0], B[word: 1]) """ Words = self.basis().keys() return Family([self.monomial(Words([a])) for a in self._alphabet])
def from_finite_word(self, w): r""" Return the unique ordered set partition of `\{1, 2, \ldots, n\}` corresponding to a word `w` of length `n`. .. SEEALSO:: :meth:`Word.to_ordered_set_partition` EXAMPLES:: sage: A = OrderedSetPartitions().from_finite_word('abcabcabd'); A [{1, 4, 7}, {2, 5, 8}, {3, 6}, {9}] sage: B = OrderedSetPartitions().from_finite_word([1,2,3,1,2,3,1,2,4]) sage: A == B True """ # TODO: fix this if statement. # In fact, what we need is for the underlying alphabet to be sortable. if isinstance(w, (list, tuple, str, FiniteWord_class)): return self.element_class(self, Words()(w).to_ordered_set_partition()) else: raise ValueError("Something is wrong: `from_finite_word` expects an object of type list/tuple/str/Word representing a finite word, received {}.".format(str(w)))
def to_packed_word(self): r""" Return the packed word on alphabet `\{1,2,3,\ldots\}` corresponding to ``self``. A *packed word* on alphabet `\{1,2,3,\ldots\}` is any word whose maximum letter is the same as its total number of distinct letters. Let `P` be an ordered set partition of a set `X`. The corresponding packed word `w_1 w_2 \cdots w_n` is constructed by having letter `w_i = j` if the `i`-th smallest entry in `X` occurs in the `j`-th block of `P`. .. SEEALSO:: :meth:`Word.to_ordered_set_partition` .. WARNING:: This assumes there is a total order on the underlying set (``self._base_set``). EXAMPLES:: sage: S = OrderedSetPartitions() sage: x = S([[3,5], [2], [1,4,6]]) sage: x.to_packed_word() word: 321313 sage: x = S([['a', 'c', 'e'], ['b', 'd']]) sage: x.to_packed_word() word: 12121 """ X = sorted(self._base_set) out = {} for i in range(len(self)): for letter in self[i]: out[letter] = i return Words()([out[letter] + 1 for letter in X])
def __init__(self, parent=None): r""" Constructor. See documentation of WordDatatype_Kolakoski for more details. EXAMPLES:: sage: from slabbe import KolakoskiWord sage: K = KolakoskiWord() sage: K word: 1221121221221121122121121221121121221221... TESTS: Pickle is supported:: sage: K = KolakoskiWord() sage: loads(dumps(K)) word: 1221121221221121122121121221121121221221... """ if parent is None: from sage.combinat.words.words import Words parent = Words([1, 2]) WordDatatype_Kolakoski.__init__(self, parent)
def __init__(self, R, names): r""" Initialize ``self``. EXAMPLES:: sage: F = ShuffleAlgebra(QQ, 'xyz'); F Shuffle Algebra on 3 generators ['x', 'y', 'z'] over Rational Field sage: TestSuite(F).run() TESTS:: sage: ShuffleAlgebra(24, 'toto') Traceback (most recent call last): ... TypeError: argument R must be a ring """ if R not in Rings(): raise TypeError("argument R must be a ring") self._alphabet = names self.__ngens = self._alphabet.cardinality() CombinatorialFreeModule.__init__(self, R, Words(names, infinite=False), latex_prefix="", category=(AlgebrasWithBasis(R), CommutativeAlgebras(R), CoalgebrasWithBasis(R)))
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)
def Kautz(self, k, D, vertices='strings'): r""" Returns the Kautz digraph of degree `d` and diameter `D`. The Kautz digraph has been defined in [Kautz68]_. The Kautz digraph of degree `d` and diameter `D` has `d^{D-1}(d+1)` vertices. This digraph is build upon a set of vertices equal to the set of words of length `D` from an alphabet of `d+1` letters such that consecutive letters are differents. There is an arc from vertex `u` to vertex `v` if `v` can be obtained from `u` by removing the leftmost letter and adding a new letter, distinct from the rightmost letter of `u`, at the right end. The Kautz digraph of degree `d` and diameter `D` is isomorphic to the digraph of Imase and Itoh [II83]_ of degree `d` and order `d^{D-1}(d+1)`. See also the :wikipedia:`Wikipedia article on Kautz Graphs <Kautz_graph>`. INPUTS: - ``k`` -- Two possibilities for this parameter : - An integer equal to the degree of the digraph to be produced, that is the cardinality minus one of the alphabet to use. - An iterable object to be used as the set of letters. The degree of the resulting digraph is the cardinality of the set of letters minus one. - ``D`` -- An integer equal to the diameter of the digraph, and also to the length of a vertex label when ``vertices == 'strings'``. - ``vertices`` -- 'strings' (default) or 'integers', specifying whether the vertices are words build upon an alphabet or integers. EXAMPLES:: sage: K = digraphs.Kautz(2, 3) sage: K.is_isomorphic(digraphs.ImaseItoh(12, 2), certify = True) (True, {'010': 0, '012': 1, '020': 3, '021': 2, '101': 11, '102': 10, '120': 9, '121': 8, '201': 5, '202': 4, '210': 6, '212': 7}) sage: K = digraphs.Kautz([1,'a','B'], 2) sage: K.edges() [('1B', 'B1', '1'), ('1B', 'Ba', 'a'), ('1a', 'a1', '1'), ('1a', 'aB', 'B'), ('B1', '1B', 'B'), ('B1', '1a', 'a'), ('Ba', 'a1', '1'), ('Ba', 'aB', 'B'), ('a1', '1B', 'B'), ('a1', '1a', 'a'), ('aB', 'B1', '1'), ('aB', 'Ba', 'a')] sage: K = digraphs.Kautz([1,'aA','BB'], 2) sage: K.edges() [('1,BB', 'BB,1', '1'), ('1,BB', 'BB,aA', 'aA'), ('1,aA', 'aA,1', '1'), ('1,aA', 'aA,BB', 'BB'), ('BB,1', '1,BB', 'BB'), ('BB,1', '1,aA', 'aA'), ('BB,aA', 'aA,1', '1'), ('BB,aA', 'aA,BB', 'BB'), ('aA,1', '1,BB', 'BB'), ('aA,1', '1,aA', 'aA'), ('aA,BB', 'BB,1', '1'), ('aA,BB', 'BB,aA', 'aA')] TESTS: An exception is raised when the degree is less than one:: sage: G = digraphs.Kautz(0, 2) Traceback (most recent call last): ... ValueError: Kautz digraphs are defined for degree at least one. sage: G = digraphs.Kautz(['a'], 2) Traceback (most recent call last): ... ValueError: Kautz digraphs are defined for degree at least one. An exception is raised when the diameter of the graph is less than one:: sage: G = digraphs.Kautz(2, 0) Traceback (most recent call last): ... ValueError: Kautz digraphs are defined for diameter at least one. REFERENCE: .. [Kautz68] W. H. Kautz. Bounds on directed (d, k) graphs. Theory of cellular logic networks and machines, AFCRL-68-0668, SRI Project 7258, Final Rep., pp. 20-28, 1968. """ if D < 1: raise ValueError( "Kautz digraphs are defined for diameter at least one.") from sage.combinat.words.words import Words from sage.rings.integer import Integer my_alphabet = Words( [str(i) for i in range(k + 1)] if isinstance(k, Integer) else k, 1) if my_alphabet.size_of_alphabet() < 2: raise ValueError( "Kautz digraphs are defined for degree at least one.") if vertices == 'strings': # We start building the set of vertices V = [i for i in my_alphabet] for i in range(D - 1): VV = [] for w in V: VV += [w * a for a in my_alphabet if not w.has_suffix(a)] V = VV # We now build the set of arcs G = DiGraph() for u in V: for a in my_alphabet: if not u.has_suffix(a): G.add_edge(u.string_rep(), (u[1:] * a).string_rep(), a.string_rep()) else: d = my_alphabet.size_of_alphabet() - 1 G = digraphs.ImaseItoh((d + 1) * (d**(D - 1)), d) G.name("Kautz digraph (k=%s, D=%s)" % (k, D)) return G
def DeBruijn(self, k, n, vertices='strings'): r""" Returns the De Bruijn digraph with parameters `k,n`. The De Bruijn digraph with parameters `k,n` is built upon a set of vertices equal to the set of words of length `n` from a dictionary of `k` letters. In this digraph, there is an arc `w_1w_2` if `w_2` can be obtained from `w_1` by removing the leftmost letter and adding a new letter at its right end. For more information, see the :wikipedia:`Wikipedia article on De Bruijn graph <De_Bruijn_graph>`. INPUT: - ``k`` -- Two possibilities for this parameter : - An integer equal to the cardinality of the alphabet to use, that is the degree of the digraph to be produced. - An iterable object to be used as the set of letters. The degree of the resulting digraph is the cardinality of the set of letters. - ``n`` -- An integer equal to the length of words in the De Bruijn digraph when ``vertices == 'strings'``, and also to the diameter of the digraph. - ``vertices`` -- 'strings' (default) or 'integers', specifying whether the vertices are words build upon an alphabet or integers. EXAMPLES:: sage: db=digraphs.DeBruijn(2,2); db De Bruijn digraph (k=2, n=2): Looped digraph on 4 vertices sage: db.order() 4 sage: db.size() 8 TESTS:: sage: digraphs.DeBruijn(5,0) De Bruijn digraph (k=5, n=0): Looped multi-digraph on 1 vertex sage: digraphs.DeBruijn(0,0) De Bruijn digraph (k=0, n=0): Looped multi-digraph on 0 vertices """ from sage.combinat.words.words import Words from sage.rings.integer import Integer W = Words(range(k) if isinstance(k, Integer) else k, n) A = Words(range(k) if isinstance(k, Integer) else k, 1) g = DiGraph(loops=True) if vertices == 'strings': if n == 0: g.allow_multiple_edges(True) v = W[0] for a in A: g.add_edge(v.string_rep(), v.string_rep(), a.string_rep()) else: for w in W: ww = w[1:] for a in A: g.add_edge(w.string_rep(), (ww * a).string_rep(), a.string_rep()) else: d = W.size_of_alphabet() g = digraphs.GeneralizedDeBruijn(d**n, d) g.name("De Bruijn digraph (k=%s, n=%s)" % (k, n)) return g
def DeBruijn(self,k,n): r""" Returns the De Bruijn diraph with parameters `k,n`. The De Bruijn digraph with parameters `k,n` is built upon a set of vertices equal to the set of words of length `n` from a dictionary of `k` letters. In this digraph, there is an arc `w_1w_2` if `w_2` can be obtained from `w_1` by removing the leftmost letter and adding a new letter at its right end. For more information, see the `Wikipedia article on De Bruijn graph <http://en.wikipedia.org/wiki/De_Bruijn_graph>`_. INPUT: - ``k`` -- Two possibilities for this parameter : - an integer equal to the cardinality of the alphabet to use. - An iterable object to be used as the set of letters - ``n`` -- An integer equal to the length of words in the De Bruijn digraph. EXAMPLES:: sage: db=digraphs.DeBruijn(2,2); db De Bruijn digraph (k=2, n=2): Looped digraph on 4 vertices sage: db.order() 4 sage: db.size() 8 TESTS:: sage: digraphs.DeBruijn(5,0) De Bruijn digraph (k=5, n=0): Looped multi-digraph on 1 vertex sage: digraphs.DeBruijn(0,0) De Bruijn digraph (k=0, n=0): Looped multi-digraph on 0 vertices """ from sage.combinat.words.words import Words from sage.rings.integer import Integer W = Words(range(k) if isinstance(k, Integer) else k, n) A = Words(range(k) if isinstance(k, Integer) else k, 1) g = DiGraph(loops=True) if n == 0 : g.allow_multiple_edges(True) v = W[0] for a in A: g.add_edge(v.string_rep(), v.string_rep(), a.string_rep()) else: for w in W: ww = w[1:] for a in A: g.add_edge(w.string_rep(), (ww*a).string_rep(), a.string_rep()) g.name( "De Bruijn digraph (k=%s, n=%s)"%(k,n) ) return g