gh-39995: typing annotations for is_something in knots,quadratic_forms,quivers

add the annotation ` -> bool` where appropriate in the folders knots,
quadratic_forms and quivers

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.

URL: #39995
Reported by: Frédéric Chapoton
Reviewer(s): Travis Scrimshaw

Author: Release Manager

build/pkgs/configure/checksums.ini

@@ -1,3 +1,3 @@
 tarball=configure-VERSION.tar.gz
-sha1=db1650ff7b9bb3d07adbf2c6c1d4be2e39c22920
-sha256=7998f8b4ce7b527248461f87b305752f18d07460792d157447bd31b45b0dbc3d
+sha1=2e6074ff61726a445d66964f794ee43f9082ce0e
+sha256=e93d25a29dd55079c84dd06dffac60a66daa7c4691bea662ac9ff2b2db779ff3

build/pkgs/configure/package-version.txt

@@ -1 +1 @@
-f5f628fca5c3bb985701204784f089d176a7caa6
+61d4cb41ea2e999bc68447f988cd0c7140456092

src/sage/knots/knotinfo.py

@@ -448,7 +448,7 @@ def matches(self, link):
             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.
 
@@ -992,7 +992,7 @@ def signature(self):
         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.
 
@@ -1063,7 +1063,7 @@ class of an oriented pair, `K = (S_3, S_1)`, with `S_i`
         return symmetry_type
 
     @cached_method
-    def is_reversible(self):
+    def is_reversible(self) -> bool:
         r"""
         Return whether ``self`` is reversible.
 
@@ -1096,7 +1096,7 @@ def is_reversible(self):
         return None
 
     @cached_method
-    def is_amphicheiral(self, positive=False):
+    def is_amphicheiral(self, positive=False) -> bool:
         r"""
         Return whether ``self`` is amphicheiral.
 
@@ -1184,7 +1184,7 @@ def is_amphicheiral(self, positive=False):
         return None
 
     @cached_method
-    def is_hyperbolic(self):
+    def is_hyperbolic(self) -> bool:
         r"""
         Return whether ``self`` is hyperbolic.
 
@@ -1201,7 +1201,7 @@ def is_hyperbolic(self):
         return False
 
     @cached_method
-    def is_alternating(self):
+    def is_alternating(self) -> bool:
         r"""
         Return whether ``self`` is alternating.
 
@@ -1213,7 +1213,7 @@ def is_alternating(self):
         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.
 
@@ -1226,7 +1226,7 @@ def is_almost_alternating(self):
         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.
 
@@ -1239,7 +1239,7 @@ def is_quasi_alternating(self):
         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.
 
@@ -1252,7 +1252,7 @@ def is_adequate(self):
         return knotinfo_bool(self[self.items.adequate])
 
     @cached_method
-    def is_positive(self):
+    def is_positive(self) -> bool:
         r"""
         Return whether ``self`` is positive.
 
@@ -1264,7 +1264,7 @@ def is_positive(self):
         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.
 
@@ -1277,7 +1277,7 @@ def is_quasipositive(self):
         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.
 
@@ -1290,7 +1290,7 @@ def is_strongly_quasipositive(self):
         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.
 
@@ -1303,7 +1303,7 @@ def is_positive_braid(self):
         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.
 
@@ -1315,7 +1315,7 @@ def is_fibered(self):
         return knotinfo_bool(self[self.items.fibered])
 
     @cached_method
-    def is_oriented(self):
+    def is_oriented(self) -> bool:
         r"""
         Return whether ``self`` is oriented.
 
@@ -2229,7 +2229,7 @@ def link(self, use_item=db.columns().pd_notation, snappy=False):
         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.
 
@@ -2275,7 +2275,7 @@ def is_unique(self):
         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
@@ -2788,7 +2788,7 @@ def _name(self):
             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

src/sage/knots/link.py

@@ -1777,7 +1777,7 @@ def number_of_components(self):
             G.add_edge(c[3], c[1])
         return G.connected_components_number()
 
-    def is_knot(self):
+    def is_knot(self) -> bool:
         r"""
         Return ``True`` if ``self`` is a knot.
 
@@ -2147,7 +2147,7 @@ def determinant(self):
         m = V + V.transpose()
         return Integer(abs(m.det()))
 
-    def is_alternating(self):
+    def is_alternating(self) -> bool:
         r"""
         Return whether the given knot diagram is alternating.
 
@@ -3200,7 +3200,7 @@ def _coloring_matrix(self, n=None):
                     M[i, j] -= 1
         return M
 
-    def is_colorable(self, n=None):
+    def is_colorable(self, n=None) -> bool:
         r"""
         Return whether the link is ``n``-colorable.
 
@@ -4517,7 +4517,7 @@ def answer_list(l):
 
         return answer_list(l)
 
-    def is_isotopic(self, other):
+    def is_isotopic(self, other) -> bool:
         r"""
         Check whether ``self`` is isotopic to ``other``.
 

src/sage/quadratic_forms/binary_qf.py

@@ -1214,7 +1214,7 @@ def cycle(self, proper=False):
             self._cycle_list = C
         return self._cycle_list
 
-    def is_positive_definite(self):
+    def is_positive_definite(self) -> bool:
         """
         Return ``True`` if ``self`` is positive definite, i.e., has
         negative discriminant with `a > 0`.
@@ -1232,7 +1232,7 @@ def is_positive_definite(self):
 
     is_posdef = is_positive_definite
 
-    def is_negative_definite(self):
+    def is_negative_definite(self) -> bool:
         """
         Return ``True`` if ``self`` is negative definite, i.e., has
         negative discriminant with `a < 0`.
@@ -1249,7 +1249,7 @@ def is_negative_definite(self):
 
     is_negdef = is_negative_definite
 
-    def is_indefinite(self):
+    def is_indefinite(self) -> bool:
         """
         Return whether ``self`` is indefinite, i.e., has positive discriminant.
 
@@ -1263,7 +1263,7 @@ def is_indefinite(self):
 
     is_indef = is_indefinite
 
-    def is_singular(self):
+    def is_singular(self) -> bool:
         """
         Return whether ``self`` is singular, i.e., has zero discriminant.
 
@@ -1278,7 +1278,7 @@ def is_singular(self):
         """
         return self.discriminant().is_zero()
 
-    def is_nonsingular(self):
+    def is_nonsingular(self) -> bool:
         """
         Return whether this form is nonsingular, i.e., has nonzero discriminant.
 
@@ -1293,7 +1293,7 @@ def is_nonsingular(self):
         """
         return not self.discriminant().is_zero()
 
-    def is_equivalent(self, other, proper=True):
+    def is_equivalent(self, other, proper=True) -> bool:
         """
         Return whether ``self`` is equivalent to ``other``.
 
@@ -1423,7 +1423,7 @@ def is_equivalent(self, other, proper=True):
         return False
 
     @cached_method
-    def is_reduced(self):
+    def is_reduced(self) -> bool:
         r"""
         Return whether ``self`` is reduced.
 

src/sage/quadratic_forms/bqf_class_group.py

@@ -569,7 +569,7 @@ def __lt__(self, other):
         """
         return self._form < other._form
 
-    def __bool__(self):
+    def __bool__(self) -> bool:
         r"""
         Return ``True`` if this form class is *not* the principal class
         and ``False`` otherwise.
@@ -584,7 +584,7 @@ def __bool__(self):
         """
         return self != self.parent().zero()
 
-    def is_zero(self):
+    def is_zero(self) -> bool:
         r"""
         Return ``True`` if this form class is the principal class and
         ``False`` otherwise.
@@ -599,7 +599,7 @@ def is_zero(self):
         """
         return not self
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         r"""
         Return a string representation of this form class.
 

src/sage/quadratic_forms/extras.py

@@ -8,7 +8,7 @@
 from sage.rings.integer_ring import ZZ
 
 
-def is_triangular_number(n, return_value=False):
+def is_triangular_number(n, return_value=False) -> bool | tuple:
     """
     Return whether ``n`` is a triangular number.
 

src/sage/quadratic_forms/genera/genus.py

@@ -942,9 +942,9 @@ def p_adic_symbol(A, p, val):
     return [[s[0]+m0] + s[1:] for s in sym + p_adic_symbol(A, p, val)]
 
 
-def is_even_matrix(A):
+def is_even_matrix(A) -> tuple[bool, int]:
     r"""
-    Determines if the integral symmetric matrix `A` is even
+    Determine if the integral symmetric matrix `A` is even
     (i.e. represents only even numbers).  If not, then it returns the
     index of an odd diagonal entry.  If it is even, then we return the
     index `-1`.
@@ -1914,7 +1914,7 @@ def prime(self):
         """
         return self._prime
 
-    def is_even(self):
+    def is_even(self) -> bool:
         r"""
         Return if the underlying `p`-adic lattice is even.
 

src/sage/quadratic_forms/quadratic_form__equivalence_testing.py

@@ -5,6 +5,8 @@
 
 - Anna Haensch (2014-12-01): added test for rational isometry
 """
+from typing import Any
+
 from sage.arith.misc import (hilbert_symbol,
                              GCD,
                              is_prime,
@@ -20,7 +22,7 @@
 # (For now, we require both forms to be positive definite.)                  #
 ##############################################################################
 
-def is_globally_equivalent_to(self, other, return_matrix=False):
+def is_globally_equivalent_to(self, other, return_matrix=False) -> bool | Any:
     r"""
     Determine if the current quadratic form is equivalent to the
     given form over `\ZZ`.
@@ -114,7 +116,8 @@ def is_globally_equivalent_to(self, other, return_matrix=False):
         return True
 
 
-def is_locally_equivalent_to(self, other, check_primes_only=False, force_jordan_equivalence_test=False):
+def is_locally_equivalent_to(self, other, check_primes_only=False,
+                             force_jordan_equivalence_test=False) -> bool:
     r"""
     Determine if the current quadratic form (defined over `\ZZ`) is
     locally equivalent to the given form over the real numbers and the
@@ -298,7 +301,7 @@ def has_equivalent_Jordan_decomposition_at_prime(self, other, p):
         raise TypeError("this should not have happened")
 
 
-def is_rationally_isometric(self, other, return_matrix=False):
+def is_rationally_isometric(self, other, return_matrix=False) -> bool | Any:
     """
     Determine if two regular quadratic forms over a number field are isometric.