passagemath-graphs 10.5.43__cp312-cp312-macosx_14_0_arm64.whl → 10.6.1rc2__cp312-cp312-macosx_14_0_arm64.whl

sage/graphs/weakly_chordal.pyx

@@ -38,6 +38,8 @@ Methods
 
 from memory_allocator cimport MemoryAllocator
 from sage.data_structures.bitset_base cimport *
+from sage.graphs.base.static_sparse_backend cimport StaticSparseCGraph
+from sage.graphs.base.static_sparse_backend cimport StaticSparseBackend
 from sage.graphs.base.static_sparse_graph cimport short_digraph
 from sage.graphs.base.static_sparse_graph cimport init_short_digraph
 from sage.graphs.base.static_sparse_graph cimport free_short_digraph
@@ -200,6 +202,17 @@ def is_long_hole_free(g, certificate=False):
 
         sage: graphs.EmptyGraph().is_long_hole_free()
         True
+
+    Immutable graphs::
+
+        sage: G = graphs.RandomGNP(10, .7)
+        sage: G._backend
+        <sage.graphs.base.sparse_graph.SparseGraphBackend ...>
+        sage: H = Graph(G, immutable=True)
+        sage: H._backend
+        <sage.graphs.base.static_sparse_backend.StaticSparseBackend ...>
+        sage: G.is_long_hole_free() == H.is_long_hole_free()
+        True
     """
     g._scream_if_not_simple()
 
@@ -212,9 +225,16 @@ def is_long_hole_free(g, certificate=False):
     # documented in the module sage.graphs.base.static_sparse_graph.
     # Vertices are relabeled in 0..n-1
     cdef int n = g.order()
-    cdef list id_label = list(g)
+    cdef list id_label
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd
-    init_short_digraph(sd, g, edge_labelled=False, vertex_list=id_label)
+    if isinstance(g, StaticSparseBackend):
+        cg = <StaticSparseCGraph> g._cg
+        sd = <short_digraph> cg.g
+        id_label = cg._vertex_to_labels
+    else:
+        id_label = list(g)
+        init_short_digraph(sd, g, edge_labelled=False, vertex_list=id_label)
 
     # Make a dense copy of the graph for quick adjacency tests
     cdef bitset_t dense_graph
@@ -258,7 +278,8 @@ def is_long_hole_free(g, certificate=False):
 
                     if not res:
                         # We release memory before returning the result
-                        free_short_digraph(sd)
+                        if not isinstance(g, StaticSparseBackend):
+                            free_short_digraph(sd)
                         bitset_free(dense_graph)
 
                         if certificate:
@@ -269,7 +290,8 @@ def is_long_hole_free(g, certificate=False):
         InPath[u] = -1
 
     # Release memory
-    free_short_digraph(sd)
+    if not isinstance(g, StaticSparseBackend):
+        free_short_digraph(sd)
     bitset_free(dense_graph)
 
     if certificate:
@@ -428,6 +450,17 @@ def is_long_antihole_free(g, certificate=False):
 
         sage: graphs.EmptyGraph().is_long_hole_free()
         True
+
+    Immutable graphs::
+
+        sage: G = graphs.RandomGNP(10, .7)
+        sage: G._backend
+        <sage.graphs.base.sparse_graph.SparseGraphBackend ...>
+        sage: H = Graph(G, immutable=True)
+        sage: H._backend
+        <sage.graphs.base.static_sparse_backend.StaticSparseBackend ...>
+        sage: G.is_long_antihole_free() == H.is_long_antihole_free()
+        True
     """
     g._scream_if_not_simple()
 
@@ -440,9 +473,16 @@ def is_long_antihole_free(g, certificate=False):
     # documented in the module sage.graphs.base.static_sparse_graph.
     # Vertices are relabeled in 0..n-1
     cdef int n = g.order()
-    cdef list id_label = list(g)
+    cdef list id_label
+    cdef StaticSparseCGraph cg
     cdef short_digraph sd
-    init_short_digraph(sd, g, edge_labelled=False, vertex_list=id_label)
+    if isinstance(g, StaticSparseBackend):
+        cg = <StaticSparseCGraph> g._cg
+        sd = <short_digraph> cg.g
+        id_label = cg._vertex_to_labels
+    else:
+        id_label = list(g)
+        init_short_digraph(sd, g, edge_labelled=False, vertex_list=id_label)
 
     # Make a dense copy of the graph for quick adjacency tests
     cdef bitset_t dense_graph
@@ -487,7 +527,8 @@ def is_long_antihole_free(g, certificate=False):
 
                     if not res:
                         # We release memory before returning the result
-                        free_short_digraph(sd)
+                        if not isinstance(g, StaticSparseBackend):
+                            free_short_digraph(sd)
                         bitset_free(dense_graph)
 
                         if certificate:
@@ -498,7 +539,8 @@ def is_long_antihole_free(g, certificate=False):
         InPath[u] = -1
 
     # Release memory
-    free_short_digraph(sd)
+    if not isinstance(g, StaticSparseBackend):
+        free_short_digraph(sd)
     bitset_free(dense_graph)
 
     if certificate:

sage/knots/free_knotinfo_monoid.py

@@ -16,15 +16,15 @@ AUTHORS:
 - Sebastian Oehms June 2024: initial version
 """
 
-##############################################################################
+# ############################################################################
 #       Copyright (C) 2024 Sebastian Oehms <seb.oehms@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 2 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-##############################################################################
+#                  https://www.gnu.org/licenses/
+# ############################################################################
 
 from sage.knots.knotinfo import SymmetryMutant
 from sage.monoids.indexed_free_monoid import (IndexedFreeAbelianMonoid,

sage/knots/knotinfo.py

@@ -16,7 +16,7 @@ package using
 - ``sage -f database_knotinfo`` (installs even if the current version is present)
 
 This will install a `Python wrapper <https://github.com/soehms/database_knotinfo#readme>`__
-for the original databases in Sage. This wrapper perfoms an automatic progress
+for the original databases in Sage. This wrapper performs an automatic progress
 of version numbers. For more details and further install instructions please see
 the corresponding web-page.
 
@@ -449,7 +449,7 @@ class SymmetryMutant(Enum):
             res.append(self.rev().mir())
         return res
 
-    def is_minimal(self, link):
+    def is_minimal(self, link) -> bool:
         r"""
         Return whether ``self`` is minimal among its matching mutants.
 
@@ -762,7 +762,7 @@ class KnotInfoBase(Enum):
 
             There has been a major change to braid representatives for
             proper links since version 2021.10.1. The former braid
-            reresentatives can be obtained by the column
+            representatives can be obtained by the column
             ``braid_notation_old`` (see the final example below).
 
         EXAMPLES::
@@ -926,7 +926,7 @@ class KnotInfoBase(Enum):
         .. NOTE::
 
            KnotInfo's value for the unknot ``0_1`` is zero. This is not
-           compatible whith Sage's result (the value of the Alexander
+           compatible with Sage's result (the value of the Alexander
            polynomial at -1). Since this method is needed to identify
            Sage links we take the according value in that case.
 
@@ -993,7 +993,7 @@ class KnotInfoBase(Enum):
         return knotinfo_int(self[self.items.signature])
 
     @cached_method
-    def is_knot(self):
+    def is_knot(self) -> bool:
         r"""
         Return whether ``self`` is a knot or a proper link.
 
@@ -1064,7 +1064,7 @@ class KnotInfoBase(Enum):
         return symmetry_type
 
     @cached_method
-    def is_reversible(self):
+    def is_reversible(self) -> bool:
         r"""
         Return whether ``self`` is reversible.
 
@@ -1097,7 +1097,7 @@ class KnotInfoBase(Enum):
         return None
 
     @cached_method
-    def is_amphicheiral(self, positive=False):
+    def is_amphicheiral(self, positive=False) -> bool:
         r"""
         Return whether ``self`` is amphicheiral.
 
@@ -1185,7 +1185,7 @@ class KnotInfoBase(Enum):
         return None
 
     @cached_method
-    def is_hyperbolic(self):
+    def is_hyperbolic(self) -> bool:
         r"""
         Return whether ``self`` is hyperbolic.
 
@@ -1202,7 +1202,7 @@ class KnotInfoBase(Enum):
         return False
 
     @cached_method
-    def is_alternating(self):
+    def is_alternating(self) -> bool:
         r"""
         Return whether ``self`` is alternating.
 
@@ -1214,7 +1214,7 @@ class KnotInfoBase(Enum):
         return knotinfo_bool(self[self.items.alternating])
 
     @cached_method
-    def is_almost_alternating(self):
+    def is_almost_alternating(self) -> bool:
         r"""
         Return whether ``self`` is almost alternating.
 
@@ -1227,7 +1227,7 @@ class KnotInfoBase(Enum):
         return knotinfo_bool(self[self.items.almost_alternating])
 
     @cached_method
-    def is_quasi_alternating(self):
+    def is_quasi_alternating(self) -> bool:
         r"""
         Return whether ``self`` is quasi alternating.
 
@@ -1240,7 +1240,7 @@ class KnotInfoBase(Enum):
         return knotinfo_bool(self[self.items.quasi_alternating])
 
     @cached_method
-    def is_adequate(self):
+    def is_adequate(self) -> bool:
         r"""
         Return whether ``self`` is adequate.
 
@@ -1253,7 +1253,7 @@ class KnotInfoBase(Enum):
         return knotinfo_bool(self[self.items.adequate])
 
     @cached_method
-    def is_positive(self):
+    def is_positive(self) -> bool:
         r"""
         Return whether ``self`` is positive.
 
@@ -1265,7 +1265,7 @@ class KnotInfoBase(Enum):
         return knotinfo_bool(self[self.items.positive])
 
     @cached_method
-    def is_quasipositive(self):
+    def is_quasipositive(self) -> bool:
         r"""
         Return whether ``self`` is quasi-positive.
 
@@ -1278,7 +1278,7 @@ class KnotInfoBase(Enum):
         return knotinfo_bool(self[self.items.quasipositive])
 
     @cached_method
-    def is_strongly_quasipositive(self):
+    def is_strongly_quasipositive(self) -> bool:
         r"""
         Return whether ``self`` is strongly quasi-positive.
 
@@ -1291,7 +1291,7 @@ class KnotInfoBase(Enum):
         return knotinfo_bool(self[self.items.strongly_quasipositive])
 
     @cached_method
-    def is_positive_braid(self):
+    def is_positive_braid(self) -> bool:
         r"""
         Return whether ``self`` is a positive braid.
 
@@ -1304,7 +1304,7 @@ class KnotInfoBase(Enum):
         return knotinfo_bool(self[self.items.positive_braid])
 
     @cached_method
-    def is_fibered(self):
+    def is_fibered(self) -> bool:
         r"""
         Return whether ``self`` is fibered.
 
@@ -1316,7 +1316,7 @@ class KnotInfoBase(Enum):
         return knotinfo_bool(self[self.items.fibered])
 
     @cached_method
-    def is_oriented(self):
+    def is_oriented(self) -> bool:
         r"""
         Return whether ``self`` is oriented.
 
@@ -1891,30 +1891,37 @@ class KnotInfoBase(Enum):
         return R(eval_knotinfo(conway_polynomial, locals=lc))
 
     @cached_method
-    def khovanov_polynomial(self, var1='q', var2='t', base_ring=ZZ, original=False, reduced=False, odd=False, KhoHo=False):
+    def khovanov_polynomial(self, var1='q', var2='t', torsion='T', ring=None, original=False,
+                            reduced=False, odd=False, base_ring=None):
         r"""
-        Return the Khovanov polynomial according to the value of column
-        ``khovanov_polynomial`` for this knot or link as an instance of
+        Return the Khovanov polynomial according to the value of columns
+        ``khovanov_*`` for this knot or link as an instance of
         :class:`~sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_mpair`.
 
         INPUT:
 
-        - ``var1`` -- (default: ``'q'``) the first variable
-        - ``var2`` -- (default: ``'t'``) the second variable
-        - ``base_ring`` -- (default: ``ZZ``) the ring of the polynomial's
-          coefficients
+        - ``var1`` -- (default: ``'q'``) the first variable; its exponents
+          correspond to the height of Khovanov homology
+        - ``var2`` -- (default: ``'t'``) the second variable; its exponents
+          correspond to the degree of Khovanov homology
+        - ``torsion`` -- (default: ``'T'``) additional variable to indicate
+          the torsion of the integral homology group corresponding to the
+          monomial; monomials without it correspond to torsion free ``ring``
+          modules; if it appears, its exponents stands for the modulus of
+          the torsion
+        - ``ring`` -- (default: ``ZZ`` for knots and ``QQ`` for proper links)
+          the ring for the homology
         - ``original`` -- boolean (default: ``False``); if set to
           ``True`` the original table entry is returned as a string
         - ``reduced`` -- boolean (default: ``False``); if set to ``True``
           the reduced version of the homology is used
         - ``odd`` -- boolean (default: ``False``); if set to ``True``
           the odd version of the homology is used
-        - ``KhoHo`` -- boolean (deprecated). The corresponding values have
-          disappeared from the database since January 2024
 
         OUTPUT:
 
-        A Laurent polynomial over the integers, more precisely an instance of
+        A two or three (for integral homology) variate Laurent polynomial over
+        ``ZZ``, more precisely an instance of
         :class:`~sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_mpair`.
         If ``original`` is set to ``True`` then a string is returned.
 
@@ -1931,11 +1938,9 @@ class KnotInfoBase(Enum):
 
             sage: K = KnotInfo.K6_3
             sage: Kk = K.khovanov_polynomial(); Kk
-            q^7*t^3 + q^5*t^2 + q^3*t^2 + q^3*t + q*t + 2*q + 2*q^-1 + q^-1*t^-1
-            + q^-3*t^-1 + q^-3*t^-2 + q^-5*t^-2 + q^-7*t^-3
-            sage: Kk2 = K.khovanov_polynomial(var1='p', base_ring=GF(2)); Kk2
-            p^7*t^3 + p^5*t^3 + p^5*t^2 + p^3*t + p^-1 + p^-1*t^-1 + p^-3*t^-2 + p^-7*t^-3
-
+            q^7*t^3 + q^5*t^3*T^2 + q^5*t^2 + q^3*t^2*T^2 + q^3*t^2 + q^3*t + q*t*T^2 + q*t
+             + 2*q + q^-1*T^2 + 2*q^-1 + q^-1*t^-1 + q^-3*t^-1*T^2 + q^-3*t^-1 + q^-3*t^-2
+             + q^-5*t^-2*T^2 + q^-5*t^-2 + q^-7*t^-3
             sage: L = KnotInfo.L5a1_0
             sage: Lk = L.khovanov_polynomial(); Lk
             q^4*t^2 + t + 2 + 2*q^-2 + q^-2*t^-1 + q^-4*t^-2 + q^-6*t^-2 + q^-8*t^-3
@@ -1946,10 +1951,10 @@ class KnotInfoBase(Enum):
 
             sage: Kkr = K.khovanov_polynomial(reduced=True); Kkr
             q^6*t^3 + 2*q^4*t^2 + 2*q^2*t + 3 + 2*q^-2*t^-1 + 2*q^-4*t^-2 + q^-6*t^-3
-            sage: K.khovanov_polynomial(base_ring=QQ, reduced=True) == Kkr
+            sage: K.khovanov_polynomial(ring=QQ, reduced=True) == Kkr
             True
-            sage: Kkr2 = K.khovanov_polynomial(base_ring=GF(2), reduced=True); Kkr2
-            q^6*t^3 + 1 + q^-6*t^-3
+            sage: Kkr2 = K.khovanov_polynomial(var1='p', ring=GF(2), reduced=True); Kkr2
+            p^6*t^3 + 2*p^4*t^2 + 2*p^2*t + 3 + 2*p^-2*t^-1 + 2*p^-4*t^-2 + p^-6*t^-3
             sage: KnotInfo.K8_19.inject()                               # optional database_knotinfo
             Defining K8_19
             sage: K8kr = K8_19.khovanov_polynomial(reduced=True); K8kr  # optional database_knotinfo
@@ -1959,23 +1964,27 @@ class KnotInfoBase(Enum):
 
             sage: K.khovanov_polynomial(odd=True) == Kkr
             True
-            sage: K.khovanov_polynomial(base_ring=QQ, odd=True) == Kkr
+            sage: K.khovanov_polynomial(ring=QQ, odd=True) == Kkr
             True
-            sage: K.khovanov_polynomial(base_ring=GF(2), odd=True) == Kkr2
+            sage: K.khovanov_polynomial(var1='p', ring=GF(2), odd=True) == Kkr2
             True
             sage: K8ko = K8_19.khovanov_polynomial(odd=True); K8ko     # optional database_knotinfo
-            q^16*t^5 + q^10*t^2 + q^6
+            q^14*t^5*T^3 + q^16*t^5 + q^12*t^4*T^2 + q^10*t^2 + q^6
             sage: K8kr == K8ko                                         # optional database_knotinfo
             False
 
+        Caution::
+
+            sage: Kk2 = K.khovanov_polynomial(ring=GF(2))
+            Traceback (most recent call last):
+            ...
+            NotImplementedError: unreduced Khovanov polynomial available only for integral homology
 
         Comparison to Sage's results::
 
             sage: Kk == K.link().khovanov_polynomial()
             True
-            sage: Kk2 == K.link().khovanov_polynomial(var1='p', base_ring=GF(2))
-            True
-            sage: Lk == L.link().khovanov_polynomial()
+            sage: Lk == L.link().khovanov_polynomial(ring=QQ)
             True
 
         TESTS::
@@ -1988,36 +1997,47 @@ class KnotInfoBase(Enum):
             1
             sage: K0_1.khovanov_polynomial(odd=True)
             1
-            sage: K0_1.khovanov_polynomial(base_ring=GF(3), reduced=True)
+            sage: K0_1.khovanov_polynomial(ring=GF(3), reduced=True)
             Traceback (most recent call last):
             ...
-            ValueError: characteristic 3 of base ring is not valid
-            sage: K0_1.khovanov_polynomial(base_ring=GF(3), odd=True)
+            ValueError: characteristic 3 of ring is not valid
+            sage: K0_1.khovanov_polynomial(ring=GF(3), odd=True)
             Traceback (most recent call last):
             ...
-            ValueError: characteristic 3 of base ring is not valid
-            sage: L.khovanov_polynomial(base_ring=GF(2))
+            ValueError: characteristic 3 of ring is not valid
+            sage: L.khovanov_polynomial(ring=GF(2))
             Traceback (most recent call last):
             ...
-            NotImplementedError: Khovanov polynomial available only for knots in characteristic 2
+            NotImplementedError: Khovanov polynomial not available for multi-component links for this ring
 
         REFERENCES:
 
         - :wikipedia:`Khovanov_homology`
         - :wikipedia:`Reduced_homology`
         - [ORS2013]_
+        - `KnotInfo <https://knotinfo.math.indiana.edu/descriptions/khovanov_unreduced_integral_polynomial.html>`__
         """
-        ch = base_ring.characteristic()
-        integral = ch == 0 and base_ring.is_field()
+        if not ring:
+            if self.is_knot():
+                ring = ZZ
+            else:
+                from sage.rings.rational_field import QQ
+                ring = QQ
+
+        if base_ring:
+            ring = base_ring
+            from sage.misc.superseded import deprecation
+            deprecation(40149, "base_ring is deprecated, use argument ring instead.")
+
+        ch = ring.characteristic()
+        integral = (ch == 0) and (not ring.is_field())
         if not self.is_knot():
             # KnotJob calculated results only available for knots
-            khovanov_polynomial = self[self.items.khovanov_polynomial]
-            KhoHo = True
+            if ch == 0 and ring.is_field():
+                khovanov_polynomial = self[self.items.khovanov_polynomial]
+            else:
+                raise NotImplementedError('Khovanov polynomial not available for multi-component links for this ring')
         else:
-            if KhoHo:
-                KhoHo = False
-                from sage.misc.superseded import deprecation
-                deprecation(37014, "the KhoHo option is deprecated and ignored.")
             if reduced:
                 if integral:
                     khovanov_polynomial = self[self.items.khovanov_reduced_integral_polynomial]
@@ -2026,7 +2046,7 @@ class KnotInfoBase(Enum):
                 elif ch == 2:
                     khovanov_polynomial = self[self.items.khovanov_reduced_mod2_polynomial]
                 else:
-                    raise ValueError('characteristic %s of base ring is not valid' % ch)
+                    raise ValueError('characteristic %s of ring is not valid' % ch)
             elif odd:
                 if integral:
                     khovanov_polynomial = self[self.items.khovanov_odd_integral_polynomial]
@@ -2035,30 +2055,32 @@ class KnotInfoBase(Enum):
                 elif ch == 2:
                     khovanov_polynomial = self[self.items.khovanov_odd_mod2_polynomial]
                 else:
-                    raise ValueError('characteristic %s of base ring is not valid' % ch)
+                    raise ValueError('characteristic %s of ring is not valid' % ch)
             else:
-                khovanov_polynomial = self[self.items.khovanov_unreduced_integral_polynomial]
+                if integral:
+                    khovanov_polynomial = self[self.items.khovanov_unreduced_integral_polynomial]
+                else:
+                    raise NotImplementedError('unreduced Khovanov polynomial available only for integral homology')
 
         if original:
             return khovanov_polynomial
 
         from sage.rings.polynomial.laurent_polynomial_ring import LaurentPolynomialRing
-        var_names = [var1, var2]
-        R = LaurentPolynomialRing(base_ring, var_names)
+        if integral:
+            var_names = [var1, var2, torsion]
+        else:
+            var_names = [var1, var2]
+
+        R = LaurentPolynomialRing(ZZ, var_names)
 
         if not khovanov_polynomial and self.crossing_number() == 0:
             if reduced or odd:
                 return R.one()
             else:
-                return R({(1, 0): 1, (-1, 0): 1})
-
-        if ch == 2:
-            if not self.is_knot():
-                raise NotImplementedError('Khovanov polynomial available only for knots in characteristic 2')
-            if KhoHo:
-                khovanov_torsion_polynomial = self[self.items.khovanov_torsion_polynomial]
-                khovanov_torsion_polynomial = khovanov_torsion_polynomial.replace('Q', 'q')
-                khovanov_polynomial = '%s + %s' % (khovanov_polynomial, khovanov_torsion_polynomial)
+                if integral:
+                    return R({(1, 0, 0): 1, (-1, 0, 0): 1})
+                else:
+                    return R({(1, 0): 1, (-1, 0): 1})
 
         if not khovanov_polynomial:
             # given just for links with less than 12 crossings
@@ -2075,10 +2097,8 @@ class KnotInfoBase(Enum):
         lc = {}
         lc['q'] = gens[var1]
         lc['t'] = gens[var2]
-        if ch == 2:
-            lc['T'] = 1
-        else:
-            lc['T'] = 0
+        if integral:
+            lc['T'] = gens[torsion]
 
         return R(eval_knotinfo(khovanov_polynomial, locals=lc))
 
@@ -2230,7 +2250,7 @@ class KnotInfoBase(Enum):
         raise ValueError('link construction using %s not possible' % use_item)
 
     @cached_method
-    def is_unique(self):
+    def is_unique(self) -> bool:
         r"""
         Return whether there is no other isotopic link in the database or not.
 
@@ -2276,7 +2296,7 @@ class KnotInfoBase(Enum):
         return None
 
     @cached_method
-    def is_recoverable(self, unique=True):
+    def is_recoverable(self, unique=True) -> bool:
         r"""
         Return if ``self`` can be recovered from its conversion to Sage links
         using the ``pd_notation`` and the ``braid_notation`` and their
@@ -2555,17 +2575,17 @@ class KnotInfoSeries(UniqueRepresentation, SageObject):
           keyword has to be set to ``True``.
 
         - ``comp`` -- (default: ``None``) if given an integer for this
-          keyword the list is restriced to links having the according number
+          keyword the list is restricted to links having the according number
           of components. This keyword implies ``oriented=True``.
 
         - ``det`` -- (default: ``None``) if given an integer for this
-          keyword the list is restriced to links having the according value
+          keyword the list is restricted to links having the according value
           for its determinant. This keyword implies ``oriented=True``.
 
         - ``homfly`` -- (default: ``None``) if given a HOMFLY-PT polynomial
-          having ``normalization='vz'`` for this keyword the list is restriced to
-          links having the according value for its HOMFLY-PT polynomial. This
-          keyword implies ``oriented=True``.
+          having ``normalization='vz'`` for this keyword the list is restricted
+          to links having the according value for its HOMFLY-PT
+          polynomial. This keyword implies ``oriented=True``.
 
         EXAMPLES::
 
@@ -2789,7 +2809,7 @@ class KnotInfoSeries(UniqueRepresentation, SageObject):
             res = 'L%s%s' % (cross_nr, alt)
         return res
 
-    def is_recoverable(self, unique=True, max_samples=8):
+    def is_recoverable(self, unique=True, max_samples=8) -> bool:
         r"""
         Return if all items of ``self`` can be recovered from its conversion to
         Sage links using the ``pd_notation`` and the ``braid_notation`` and their