passagemath-combinat 10.6.1__cp312-cp312-musllinux_1_2_aarch64.whl → 10.8.1a1__cp312-cp312-musllinux_1_2_aarch64.whl

sage/combinat/words/finite_word.py

@@ -1248,7 +1248,7 @@ class FiniteWord_class(Word_class):
         elif algorithm == 'naive':
             return ZZ(len(self.factor_set(n, algorithm='naive')))
         else:
-            raise ValueError(f'Unknown algorithm (={algorithm})')
+            raise ValueError(f'unknown algorithm (={algorithm})')
 
     def factor_iterator(self, n=None):
         r"""
@@ -1424,7 +1424,7 @@ class FiniteWord_class(Word_class):
                     S.add(self[i:i+n])
                 return Set(S)
         else:
-            raise ValueError(f'Unknown algorithm (={algorithm})')
+            raise ValueError(f'unknown algorithm (={algorithm})')
 
     def topological_entropy(self, n):
         r"""
@@ -1475,7 +1475,7 @@ class FiniteWord_class(Word_class):
             sage: w.topological_entropy(3)
             Traceback (most recent call last):
             ...
-            TypeError: The word must be defined over a finite alphabet
+            TypeError: the word must be defined over a finite alphabet
 
         The following is ok::
 
@@ -1486,7 +1486,7 @@ class FiniteWord_class(Word_class):
         """
         d = self.parent().alphabet().cardinality()
         if d is Infinity:
-            raise TypeError("The word must be defined over a finite alphabet")
+            raise TypeError("the word must be defined over a finite alphabet")
         if n == 0:
             return 1
         pn = self.number_of_factors(n)
@@ -1676,7 +1676,7 @@ class FiniteWord_class(Word_class):
         g = copy(self.rauzy_graph(n))
         # Otherwise it changes the rauzy_graph function.
         l = [v for v in g if g.in_degree(v) == 1 == g.out_degree(v)]
-        if g.num_verts() != 0 and len(l) == g.num_verts():
+        if len(l) == g.n_vertices() != 0:
             # In this case, the Rauzy graph is simply a cycle.
             g = DiGraph()
             g.allow_loops(True)
@@ -3583,13 +3583,9 @@ class FiniteWord_class(Word_class):
         """
         if p < 0:
             return False
-        elif p >= len(self):
-            return True
-        else:
-            for i in range(len(self) - p):
-                if self[i] != self[i + p]:
-                    return False
+        if p >= len(self):
             return True
+        return all(self[i] == self[i + p] for i in range(len(self) - p))
 
     def periods(self, divide_length=False):
         r"""
@@ -4155,71 +4151,6 @@ class FiniteWord_class(Word_class):
         d.update((letter, i) for i, letter in enumerate(self))
         return d
 
-    def _pos_in(self, other, p):
-        r"""
-        Return the position of the first occurrence of ``self`` starting at
-        position ``p`` in ``other``.
-
-        .. WARNING::
-
-            This method is deprecated since 2020 and will be removed in a
-            later version of SageMath.
-            Use :meth:`first_occurrence` instead.
-
-        EXAMPLES::
-
-            sage: Word('12')._pos_in(Word('131231'), 2)
-            doctest:warning
-            ...
-            DeprecationWarning: f._pos_in(w, start) is deprecated.
-            Use w.first_occurrence(f, start) instead.
-            See https://github.com/sagemath/sage/issues/30187 for details.
-            2
-            sage: Word('12')._pos_in(Word('131231'), 3) is None
-            True
-            sage: Word('32')._pos_in(Word('131231'), 0) is None
-            True
-
-        The empty word occurs in a word::
-
-            sage: Word('')._pos_in(Word('123'), 0)
-            0
-            sage: Word('')._pos_in(Word(''), 0)
-            0
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(30187, 'f._pos_in(w, start) is deprecated.'
-                    ' Use w.first_occurrence(f, start) instead.')
-        return other.first_occurrence(self, p)
-
-    def first_pos_in(self, other):
-        r"""
-        Return the position of the first occurrence of ``self`` in ``other``,
-        or ``None`` if ``self`` is not a factor of ``other``.
-
-        .. WARNING::
-
-            This method is deprecated since 2020 and will be removed in a
-            later version of SageMath.
-            Use :meth:`first_occurrence` instead.
-
-        EXAMPLES::
-
-            sage: Word('12').first_pos_in(Word('131231'))
-            doctest:warning
-            ...
-            DeprecationWarning: f.first_pos_in(w) is deprecated.
-            Use w.first_occurrence(f) instead.
-            See https://github.com/sagemath/sage/issues/30187 for details.
-            2
-            sage: Word('32').first_pos_in(Word('131231')) is None
-            True
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(30187, 'f.first_pos_in(w) is deprecated.'
-                    ' Use w.first_occurrence(f) instead.')
-        return other.first_occurrence(self)
-
     def find(self, sub, start=0, end=None):
         r"""
         Return the index of the first occurrence of ``sub`` in ``self``,
@@ -4413,138 +4344,6 @@ class FiniteWord_class(Word_class):
         """
         return other.first_occurrence(self) is not None
 
-    def factor_occurrences_in(self, other):
-        r"""
-        Return an iterator over all occurrences (including overlapping ones)
-        of ``self`` in ``other`` in their order of appearance.
-
-        .. WARNING::
-
-            This method is deprecated since 2020 and will be removed in a
-            later version of SageMath.
-            Use :meth:`factor_occurrences_iterator` instead.
-
-        EXAMPLES::
-
-            sage: u = Word('121')
-            sage: w = Word('121213211213')
-            sage: list(u.factor_occurrences_in(w))
-            doctest:warning
-            ...
-            DeprecationWarning: f.factor_occurrences_in(w) is deprecated.
-            Use w.factor_occurrences_iterator(f) instead.
-            See https://github.com/sagemath/sage/issues/30187 for details.
-            [0, 2, 8]
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(30187, 'f.factor_occurrences_in(w) is deprecated.'
-                    ' Use w.factor_occurrences_iterator(f) instead.')
-        return other.factor_occurrences_iterator(self)
-
-    def nb_factor_occurrences_in(self, other):
-        r"""
-        Return the number of times ``self`` appears as a factor
-        in ``other``.
-
-        .. WARNING::
-
-            This method is deprecated since 2020 and will be removed in a
-            later version of SageMath.
-            Use :meth:`number_of_factor_occurrences` instead.
-
-        EXAMPLES::
-
-            sage: Word('123').nb_factor_occurrences_in(Word('112332312313112332121123'))
-            doctest:warning
-            ...
-            DeprecationWarning: f.nb_factor_occurrences_in(w) is deprecated.
-            Use w.number_of_factor_occurrences(f) instead.
-            See https://github.com/sagemath/sage/issues/30187 for details.
-            4
-            sage: Word('321').nb_factor_occurrences_in(Word('11233231231311233221123'))
-            0
-
-        An error is raised for the empty word::
-
-            sage: Word().nb_factor_occurrences_in(Word('123'))
-            Traceback (most recent call last):
-            ...
-            NotImplementedError: The factor must be non empty
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(30187, 'f.nb_factor_occurrences_in(w) is deprecated.'
-                    ' Use w.number_of_factor_occurrences(f) instead.')
-        return other.number_of_factor_occurrences(self)
-
-    def nb_subword_occurrences_in(self, other):
-        r"""
-        Return the number of times ``self`` appears in ``other`` as a subword.
-
-        This corresponds to the notion of `binomial coefficient` of two
-        finite words whose properties are presented in the chapter of
-        Lothaire's book written by Sakarovitch and Simon [Lot1997]_.
-
-        .. WARNING::
-
-            This method is deprecated since 2020 and will be removed in a
-            later version of SageMath.
-            Use :meth:`number_of_subword_occurrences` instead.
-
-        INPUT:
-
-        - ``other`` -- finite word
-
-        EXAMPLES::
-
-            sage: tm = words.ThueMorseWord()
-
-            sage: u = Word([0,1,0,1])
-            sage: u.nb_subword_occurrences_in(tm[:1000])
-            doctest:warning
-            ...
-            DeprecationWarning: f.nb_subword_occurrences_in(w) is deprecated.
-            Use w.number_of_subword_occurrences(f) instead.
-            See https://github.com/sagemath/sage/issues/30187 for details.
-            2604124996
-
-            sage: u = Word([0,1,0,1,1,0])
-            sage: u.nb_subword_occurrences_in(tm[:100])
-            20370432
-
-        .. NOTE::
-
-            This code, based on [MSSY2001]_, actually compute the number of
-            occurrences of all prefixes of ``self`` as subwords in all
-            prefixes of ``other``.  In particular, its complexity is
-            bounded by ``len(self) * len(other)``.
-
-        TESTS::
-
-            sage: Word('').nb_subword_occurrences_in(Word(''))
-            1
-            sage: parent(_)
-            Integer Ring
-            sage: v,u = Word(), Word('123')
-            sage: v.nb_subword_occurrences_in(u)
-            1
-            sage: v,u = Word('123'), Word('1133432311132311112')
-            sage: v.nb_subword_occurrences_in(u)
-            11
-            sage: v,u = Word('4321'), Word('1132231112233212342231112')
-            sage: v.nb_subword_occurrences_in(u)
-            0
-            sage: v,u = Word('3'), Word('122332112321213')
-            sage: v.nb_subword_occurrences_in(u)
-            4
-            sage: v,u = Word([]), words.ThueMorseWord()[:1000]
-            sage: v.nb_subword_occurrences_in(u)
-            1
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(30187, 'f.nb_subword_occurrences_in(w) is deprecated.'
-                    ' Use w.number_of_subword_occurrences(f) instead.')
-        return other.number_of_subword_occurrences(self)
-
     def number_of_factor_occurrences(self, other):
         r"""
         Return the number of times ``other`` appears as a factor
@@ -4573,7 +4372,7 @@ class FiniteWord_class(Word_class):
             sage: Word('123').number_of_factor_occurrences(Word())
             Traceback (most recent call last):
             ...
-            NotImplementedError: The factor must be non empty
+            NotImplementedError: the factor must be non empty
         """
         return sum(1 for _ in self.factor_occurrences_iterator(other))
 
@@ -5102,14 +4901,14 @@ class FiniteWord_class(Word_class):
             {{-4, -2, 0, 2, 4}, {-5, -3, -1, 1, 3, 5}}
         """
         if not isinstance(delay, (int, Integer)):
-            raise TypeError("delay (=%s) must be an integer" % delay)
+            raise TypeError(f"delay (={delay}) must be an integer")
         elif delay < 0:
             return other.overlap_partition(self, -delay, p)
 
         from sage.sets.disjoint_set import DisjointSet_class
         if p is None:
             if self.parent().alphabet().cardinality() is Infinity:
-                raise ValueError("The alphabet of the parent must be finite")
+                raise ValueError("the alphabet of the parent must be finite")
             from sage.sets.disjoint_set import DisjointSet
             p = DisjointSet(self.parent().alphabet())
         elif not isinstance(p, DisjointSet_class):
@@ -5858,7 +5657,7 @@ class FiniteWord_class(Word_class):
                     desubstitued_word = desubstitued_word + w_running ** (current_run_length - min_run)
             return desubstitued_word.sturmian_desubstitute_as_possible()
 
-    def is_sturmian_factor(self):
+    def is_sturmian_factor(self) -> bool:
         r"""
         Tell whether ``self`` is a factor of a Sturmian word.
 
@@ -5916,7 +5715,7 @@ class FiniteWord_class(Word_class):
         """
         return self.sturmian_desubstitute_as_possible().is_empty()
 
-    def is_tangent(self):
+    def is_tangent(self) -> bool:
         r"""
         Tell whether ``self`` is a tangent word.
 
@@ -6495,7 +6294,7 @@ class FiniteWord_class(Word_class):
             res = res.delta_inv(s=tab[i])
         return res
 
-    def is_smooth_prefix(self):
+    def is_smooth_prefix(self) -> bool:
         r"""
         Return ``True`` if ``self`` is the prefix of a smooth word, and ``False``
         otherwise.
@@ -6601,18 +6400,18 @@ class FiniteWord_class(Word_class):
             sage: w.standard_factorization()
             Traceback (most recent call last):
             ...
-            ValueError: Standard factorization not defined on words of
+            ValueError: standard factorization not defined on words of
             length less than 2
             sage: w = Word('a')
             sage: w.standard_factorization()
             Traceback (most recent call last):
             ...
-            ValueError: Standard factorization not defined on words of
+            ValueError: standard factorization not defined on words of
             length less than 2
         """
         selflen = self.length()
         if selflen < 2:
-            raise ValueError("Standard factorization not defined on"
+            raise ValueError("standard factorization not defined on"
                              " words of length less than 2")
         for l in range(1, selflen):
             suff = self[l:]
@@ -6745,11 +6544,11 @@ class FiniteWord_class(Word_class):
             sage: Word(range(100)).colored_vector(cmap='jolies')                        # needs sage.plot
             Traceback (most recent call last):
             ...
-            RuntimeError: Color map jolies not known
+            RuntimeError: color map jolies not known
             sage: Word(range(100)).colored_vector(cmap='__doc__')                       # needs sage.plot
             Traceback (most recent call last):
             ...
-            RuntimeError: Color map __doc__ not known
+            RuntimeError: color map __doc__ not known
         """
         # Recognize the color map
         import matplotlib.cm as cm
@@ -6765,7 +6564,7 @@ class FiniteWord_class(Word_class):
                                       if isinstance(val, C))
             import sage.misc.verbose
             sage.misc.verbose.verbose("The possible color maps include: %s" % possibilities, level=0)
-            raise RuntimeError("Color map %s not known" % cmap)
+            raise RuntimeError(f"color map {cmap} not known")
 
         # Drawing the colored vector...
         from sage.plot.line import line
@@ -6814,7 +6613,7 @@ class FiniteWord_class(Word_class):
         rep.axes(False)
         return rep
 
-    def is_square(self):
+    def is_square(self) -> bool:
         r"""
         Return ``True`` if ``self`` is a square, and ``False`` otherwise.
 
@@ -6837,7 +6636,7 @@ class FiniteWord_class(Word_class):
             l = self.length() // 2
             return self[:l] == self[l:]
 
-    def is_square_free(self):
+    def is_square_free(self) -> bool:
         r"""
         Return ``True`` if ``self`` does not contain squares, and ``False``
         otherwise.
@@ -6884,7 +6683,7 @@ class FiniteWord_class(Word_class):
         T = DecoratedSuffixTree(self)
         return set(T.square_vocabulary(output='word'))
 
-    def is_cube(self):
+    def is_cube(self) -> bool:
         r"""
         Return ``True`` if ``self`` is a cube, and ``False`` otherwise.
 
@@ -6904,7 +6703,7 @@ class FiniteWord_class(Word_class):
         l = self.length() // 3
         return self[:l] == self[l:2*l] == self[2*l:]
 
-    def is_cube_free(self):
+    def is_cube_free(self) -> bool:
         r"""
         Return ``True`` if ``self`` does not contain cubes, and ``False`` otherwise.
 
@@ -6967,7 +6766,7 @@ class FiniteWord_class(Word_class):
         M = FreeMonoid(len(l), l)
         return M(self)
 
-    def is_christoffel(self):
+    def is_christoffel(self) -> bool:
         r"""
         Return ``True`` if ``self`` is a Christoffel word, and ``False`` otherwise.
 
@@ -7017,10 +6816,7 @@ class FiniteWord_class(Word_class):
         """
         if len(self) == 0 or len(self.letters()) > 2 or (self.is_palindrome() and len(self) > 1):
             return False
-        elif self.is_symmetric() and self[1:len(self) - 1].is_palindrome():
-            return True
-        else:
-            return False
+        return self.is_symmetric() and self[1:len(self) - 1].is_palindrome()
 
     def minimal_conjugate(self):
         r"""

sage/combinat/words/infinite_word.py

@@ -80,7 +80,7 @@ from sage.rings.infinity import Infinity
 
 
 class InfiniteWord_class(Word_class):
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 

sage/combinat/words/morphic.py

@@ -26,6 +26,8 @@ letter, see chapter 3 of the book [BR2010b]_::
     sage: w[10000000]                                                                   # needs sage.modules
     'b'
 """
+from collections.abc import Iterator
+from itertools import chain
 
 from sage.combinat.words.word_infinite_datatypes import WordDatatype_callable
 from sage.misc.lazy_import import lazy_import
@@ -39,7 +41,8 @@ class WordDatatype_morphic(WordDatatype_callable):
     Datatype for a morphic word defined by a morphism, a starting letter
     and a coding.
     """
-    def __init__(self, parent, morphism, letter, coding=None, length=Infinity):
+    def __init__(self, parent, morphism, letter,
+                 coding=None, length=Infinity) -> None:
         r"""
         INPUT:
 
@@ -128,7 +131,7 @@ class WordDatatype_morphic(WordDatatype_callable):
         else:
             self._coding = coding
 
-    def __reduce__(self):
+    def __reduce__(self) -> tuple:
         r"""
         EXAMPLES::
 
@@ -157,7 +160,7 @@ class WordDatatype_morphic(WordDatatype_callable):
         return self.__class__, (self._parent, self._morphism, self._letter,
                                 self._coding, self._len)
 
-    def representation(self, n):
+    def representation(self, n) -> list:
         r"""
         Return the representation of the integer n in the numeration system
         associated to the morphism.
@@ -202,16 +205,16 @@ class WordDatatype_morphic(WordDatatype_callable):
             sage: w.representation(5)                                                   # needs sage.modules
             [1, 0, 0, 0]
         """
-        letters_to_int = {a:i for (i,a) in enumerate(self._alphabet)}
+        letters_to_int = {a: i for i, a in enumerate(self._alphabet)}
         position = letters_to_int[self._letter]
         M = self._morphism.incidence_matrix()
-        vMk = vector([1]*len(self._alphabet))
+        vMk = vector([1] * len(self._alphabet))
         length_of_images = []
         while vMk[position] <= n:
             length_of_images.append(vMk)
-            vMk_next = vMk*M
+            vMk_next = vMk * M
             if vMk[position] == vMk_next[position]:
-                raise IndexError('index (={}) out of range, the fixed point is finite and has length {}'.format(n,vMk[position]))
+                raise IndexError(f'index (={n}) out of range, the fixed point is finite and has length {vMk[position]}')
             vMk = vMk_next
         k = len(length_of_images)
         letter_k = self._letter
@@ -224,10 +227,10 @@ class WordDatatype_morphic(WordDatatype_callable):
             while S <= n_k:
                 a = m_letter_k[j]
                 i = letters_to_int[a]
-                pile_length = length_of_images[k-1][i]
+                pile_length = length_of_images[k - 1][i]
                 S += pile_length
                 j += 1
-            path.append(j-1)
+            path.append(j - 1)
             n_k -= S - pile_length
             letter_k = a
             k -= 1
@@ -270,11 +273,9 @@ class WordDatatype_morphic(WordDatatype_callable):
         letter = self._letter
         for a in self.representation(key):
             letter = (self._morphism(letter))[a]
-        if key == 0:
-            return self._coding[letter]
         return self._coding[letter]
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator:
         r"""
         Return an iterator of the letters of the fixed point of ``self``
         starting with ``letter``.
@@ -339,7 +340,6 @@ class WordDatatype_morphic(WordDatatype_callable):
             sage: (s^7).reversal().fixed_points()
             []
         """
-        from itertools import chain
         w = iter(self._morphism.image(self._letter))
         while True:
             try:

sage/combinat/words/morphism.py

@@ -1325,10 +1325,7 @@ class WordMorphism(SageObject):
             sage: WordMorphism('').is_erasing()
             False
         """
-        for image in self.images():
-            if image.is_empty():
-                return True
-        return False
+        return any(image.is_empty() for image in self.images())
 
     def is_identity(self):
         r"""
@@ -1548,10 +1545,7 @@ class WordMorphism(SageObject):
         """
         dom_alphabet = set(self.domain().alphabet())
 
-        for image in self.images():
-            if not dom_alphabet <= set(image):
-                return False
-        return True
+        return all(dom_alphabet <= set(image) for image in self.images())
 
     def is_primitive(self):
         r"""
@@ -2423,10 +2417,7 @@ class WordMorphism(SageObject):
             sage: (fibo^2).has_conjugate_in_classP()
             True
         """
-        for k in self.list_of_conjugates():
-            if k.is_in_classP(f=f):
-                return True
-        return False
+        return any(k.is_in_classP(f=f) for k in self.list_of_conjugates())
 
     def dual_map(self, k=1):
         r"""

sage/combinat/words/paths.py

@@ -314,11 +314,11 @@ def WordPaths(alphabet, steps=None):
         sage: WordPaths(range(5))
         Traceback (most recent call last):
         ...
-        TypeError: Unable to make a class WordPaths from {0, 1, 2, 3, 4}
+        TypeError: unable to make a class WordPaths from {0, 1, 2, 3, 4}
         sage: WordPaths('abAB', steps='square_gridd')
         Traceback (most recent call last):
         ...
-        TypeError: Unknown type of steps : square_gridd
+        TypeError: unknown type of steps : square_gridd
     """
     # Construction of the alphabet
     alphabet = build_alphabet(alphabet)
@@ -332,26 +332,25 @@ def WordPaths(alphabet, steps=None):
         elif alphabet.cardinality() == 6:
             steps = 'hexagonal_grid'
         else:
-            raise TypeError("Unable to make a class WordPaths from %s" % alphabet)
+            raise TypeError("unable to make a class WordPaths from %s" % alphabet)
 
     # Return the class of WordPaths according to the given type of paths
     if isinstance(steps, str):
         if steps in ('square_grid', 'square'):
             return WordPaths_square_grid(alphabet=alphabet)
-        elif steps in ('triangle_grid', 'triangle'):
+        if steps in ('triangle_grid', 'triangle'):
             return WordPaths_triangle_grid(alphabet=alphabet)
-        elif steps in ('hexagonal_grid', 'hexagon'):
+        if steps in ('hexagonal_grid', 'hexagon'):
             return WordPaths_hexagonal_grid(alphabet=alphabet)
-        elif steps in ('cube_grid', 'cube'):
+        if steps in ('cube_grid', 'cube'):
             return WordPaths_cube_grid(alphabet=alphabet)
-        elif steps in ('north_east', 'ne', 'NE'):
+        if steps in ('north_east', 'ne', 'NE'):
             return WordPaths_north_east(alphabet=alphabet)
-        elif steps == 'dyck':
+        if steps == 'dyck':
             return WordPaths_dyck(alphabet=alphabet)
-        else:
-            raise TypeError("Unknown type of steps : %s" % steps)
-    else:
-        return WordPaths_all(alphabet=alphabet, steps=steps)
+        raise TypeError(f"unknown type of steps : {steps}")
+
+    return WordPaths_all(alphabet=alphabet, steps=steps)
 
 
 #######################################################################
@@ -1205,16 +1204,14 @@ class FiniteWordPath_all(SageObject):
             sage: P('aabdee').is_simple()
             False
         """
-        n = 0
         s = set()
         include_last = not self.is_closed()
-        for p in self.points(include_last=include_last):
+        for n, p in enumerate(self.points(include_last=include_last), start=1):
             # We need the elements to have a common parent,
             # so we convert the points to immutable vectors.
             v = vector(p)
             v.set_immutable()
             s.add(v)
-            n += 1
             if len(s) != n:
                 return False
         return True
@@ -1408,7 +1405,7 @@ class FiniteWordPath_all(SageObject):
         if letters is None:
             letters = self.parent().alphabet()
         if color is None:
-            from sage.plot.all import hue
+            from sage.plot.colors import hue
             A = self.parent().alphabet()
             color = {a: hue(A.rank(a) / float(A.cardinality())) for a in A}
         it = self.projected_point_iterator(v, ring=ring)
@@ -1674,7 +1671,9 @@ class FiniteWordPath_2d(FiniteWordPath_all):
 
             See www.imagemagick.org, for example.
         """
-        from sage.plot.all import line, polygon, animate
+        from sage.plot.line import line
+        from sage.plot.polygon import polygon
+        from sage.plot.animate import animate
 
         pts = list(self.points())