gh-40345: remove deprecated method in quaternion algebra
    
remove deprecation from #37100

also clean the modified file a little bit

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [x] I have updated the documentation and checked the documentation
preview.
    
URL: #40345
Reported by: Frédéric Chapoton
Reviewer(s):

Author: Release Manager

src/sage/algebras/quatalg/quaternion_algebra.py

@@ -90,7 +90,6 @@
 from sage.categories.number_fields import NumberFields
 
 from sage.structure.richcmp import richcmp_method
-from sage.libs.pari.all import pari
 from sage.combinat.words.word import Word
 
 ########################################################
@@ -366,7 +365,7 @@ def create_key(self, arg0, arg1=None, arg2=None, names='i,j,k'):
             K = arg0
             if K not in NumberFields():
                 raise ValueError("quaternion algebra construction via ramification only works over a number field")
-            if not set(arg2).issubset(set([0, QQ((1,2))])):
+            if not set(arg2).issubset(set([0, QQ((1, 2))])):
                 raise ValueError("list of local invariants specifying ramification should contain only 0 and 1/2")
 
             # Check that the finite ramification is given by prime ideals
@@ -417,7 +416,7 @@ def create_key(self, arg0, arg1=None, arg2=None, names='i,j,k'):
                 inv_arch_pari = [arg2[i-1] for i in perm]
 
                 # Compute the correct quaternion algebra over L in PARI
-                A = L.__pari__().alginit([2, [fin_places_pari, [QQ((1,2))] * len(fin_places_pari)],
+                A = L.__pari__().alginit([2, [fin_places_pari, [QQ((1, 2))] * len(fin_places_pari)],
                                           inv_arch_pari], flag=0)
 
                 # Obtain representation of A in terms of invariants in L
@@ -1008,7 +1007,7 @@ def maximal_order(self, take_shortcuts=True, order_basis=None):
         #  of such a form though)
         a, b = self.invariants()
         if (not order_basis and take_shortcuts and d_A.is_prime()
-            and a in ZZ and b in ZZ):
+                and a in ZZ and b in ZZ):
             a = ZZ(a)
             b = ZZ(b)
             i, j, k = self.gens()
@@ -1050,7 +1049,7 @@ def maximal_order(self, take_shortcuts=True, order_basis=None):
             d_R = R.discriminant()
         except (TypeError, ValueError):
             raise ValueError('order_basis is not a basis of an order of the'
-                            ' given quaternion algebra')
+                             ' given quaternion algebra')
 
         # Since Voight's algorithm only works for a starting basis having 1 as
         # its first vector, we derive such a basis from the given order basis
@@ -1127,7 +1126,7 @@ def maximal_order(self, take_shortcuts=True, order_basis=None):
                             e_n[3] = e_n[1]*g
 
                     else:   # t.valuation(p) > 0
-                        (y, z, w) = maxord_solve_aux_eq(a, b, p)
+                        y, z, w = maxord_solve_aux_eq(a, b, p)
                         g = 1/p*(1 + y*e_n[1] + z*e_n[2] + w*e_n[1]*e_n[2])
                         h = (z*b)*e_n[1] - (y*a)*e_n[2]
                         e_n[1:4] = [g, h, g * h]
@@ -1564,7 +1563,8 @@ def ramified_places(self, inf=True):
 
         # Over the number field F, first compute the finite ramified places
         ram_fin = [p for p in set(F.primes_above(2)).union(F.primes_above(a),
-                    F.primes_above(b)) if F.hilbert_symbol(a, b, p) == -1]
+                                                           F.primes_above(b))
+                   if F.hilbert_symbol(a, b, p) == -1]
 
         if not inf:
             return ram_fin
@@ -2750,7 +2750,7 @@ def ternary_quadratic_form(self, include_basis=False):
         Q = self.quaternion_algebra()
         # 2*R + ZZ
         twoR = self.free_module().scale(2)
-        Z = twoR.span([Q(1).coefficient_tuple()], ZZ)
+        Z = twoR.span([Q.one().coefficient_tuple()], ZZ)
         S = twoR + Z
         # Now we intersect with the trace 0 submodule
         v = [b.reduced_trace() for b in Q.basis()]
@@ -3614,7 +3614,7 @@ def norm(self):
             [16, 32, 32]
 
             sage: # optional - magma
-            sage: (a,b) = M.quaternion_algebra().invariants()
+            sage: a, b = M.quaternion_algebra().invariants()
             sage: magma.eval('A<i,j,k> := QuaternionAlgebra<Rationals() | %s, %s>' % (a,b))
             ''
             sage: magma.eval('O := QuaternionOrder(%s)' % str(list(C[0].right_order().basis())))
@@ -4016,24 +4016,21 @@ def pullback(self, J, side=None):
 
         raise ValueError('side must be "left", "right" or None')
 
-    def is_equivalent(self, J, B=10, certificate=False, side=None):
+    def is_left_equivalent(self, J, B=10, certificate=False) -> bool | tuple:
         r"""
-        Check whether ``self`` and ``J`` are equivalent as ideals.
-        Tests equivalence as right ideals by default. Requires the underlying
-        rational quaternion algebra to be definite.
+        Check whether ``self`` and ``J`` are equivalent as left ideals.
+
+        This requires the underlying rational quaternion algebra
+        to be definite.
 
         INPUT:
 
-        - ``J`` -- a fractional quaternion ideal with same order as ``self``
+        - ``J`` -- a fractional quaternion left ideal with same order as ``self``
 
         - ``B`` -- a bound to compute and compare theta series before
           doing the full equivalence test
 
-        - ``certificate`` -- if ``True`` returns an element alpha such that
-          alpha*J = I or J*alpha = I for right and left ideals respectively
-
-        - ``side`` -- if ``'left'`` performs left equivalence test. If ``'right'
-          ``or ``None`` performs right ideal equivalence test
+        - ``certificate`` -- if ``True`` returns an element alpha such that J*alpha=I
 
         OUTPUT: boolean, or (boolean, alpha) if ``certificate`` is ``True``
 
@@ -4043,48 +4040,22 @@ def is_equivalent(self, J, B=10, certificate=False, side=None):
             2
             sage: OO = R[0].left_order()
             sage: S = OO.right_ideal([3*a for a in R[0].basis()])
-            sage: R[0].is_equivalent(S)
-            doctest:...: DeprecationWarning: is_equivalent is deprecated,
-            please use is_left_equivalent or is_right_equivalent
-            accordingly instead
-            See https://github.com/sagemath/sage/issues/37100 for details.
+            sage: R[0].is_left_equivalent(S)
             True
         """
-        from sage.misc.superseded import deprecation
-        deprecation(37100, 'is_equivalent is deprecated, please use is_left_equivalent'
-                            ' or is_right_equivalent accordingly instead')
-        if side == 'left':
-            return self.is_left_equivalent(J, B, certificate)
-        # If None, assume right ideals, for backwards compatibility
-        return self.is_right_equivalent(J, B, certificate)
-
-    def is_left_equivalent(self, J, B=10, certificate=False):
-        r"""
-        Check whether ``self`` and ``J`` are equivalent as left ideals.
-        Requires the underlying rational quaternion algebra to be definite.
-
-        INPUT:
-
-        - ``J`` -- a fractional quaternion left ideal with same order as ``self``
-
-        - ``B`` -- a bound to compute and compare theta series before
-          doing the full equivalence test
-
-        - ``certificate`` -- if ``True`` returns an element alpha such that J*alpha=I
-
-        OUTPUT: boolean, or (boolean, alpha) if ``certificate`` is ``True``
-        """
         if certificate:
             is_equiv, cert = self.conjugate().is_right_equivalent(J.conjugate(), B, True)
             if is_equiv:
                 return True, cert.conjugate()
             return False, None
         return self.conjugate().is_right_equivalent(J.conjugate(), B, False)
 
-    def is_right_equivalent(self, J, B=10, certificate=False):
+    def is_right_equivalent(self, J, B=10, certificate=False) -> bool | tuple:
         r"""
         Check whether ``self`` and ``J`` are equivalent as right ideals.
-        Requires the underlying rational quaternion algebra to be definite.
+
+        This requires the underlying rational quaternion algebra
+        to be definite.
 
         INPUT:
 
@@ -4128,14 +4099,14 @@ def is_right_equivalent(self, J, B=10, certificate=False):
         """
         if not isinstance(J, QuaternionFractionalIdeal_rational):
             raise TypeError('J must be a fractional ideal'
-                          ' in a rational quaternion algebra')
+                            ' in a rational quaternion algebra')
 
         if self.right_order() != J.right_order():
             raise ValueError('self and J must be right ideals over the same order')
 
         if not self.quaternion_algebra().is_definite():
             raise NotImplementedError('equivalence test of ideals not implemented'
-                                    ' for indefinite quaternion algebras')
+                                      ' for indefinite quaternion algebras')
 
         # Just test theta series first; if the theta series are
         # different, the ideals are definitely not equivalent
@@ -4184,7 +4155,7 @@ def is_principal(self, certificate=False):
         """
         if not self.quaternion_algebra().is_definite():
             raise NotImplementedError('principality test not implemented in'
-                                    ' indefinite quaternion algebras')
+                                      ' indefinite quaternion algebras')
 
         c = self.theta_series_vector(2)[1]
         if not certificate:
@@ -4414,10 +4385,12 @@ def primitive_decomposition(self):
 
         Check that randomly generated ideals decompose as expected::
 
-            sage: for d in ( m for m in range(400, 750) if is_squarefree(m) ):        # long time (7s)
+            sage: for d in range(400, 650):   # long time (7s)
+            ....:     if not is_squarefree(d):
+            ....:         continue
             ....:     A = QuaternionAlgebra(d)
             ....:     O = A.maximal_order()
-            ....:     for _ in range(10):
+            ....:     for _ in range(8):
             ....:         a = O.random_element()
             ....:         if not a.is_constant(): # avoids a = 0
             ....:             I = a*O + a.reduced_norm()*O
@@ -4712,7 +4685,7 @@ def maxord_solve_aux_eq(a, b, p):
         sage: from sage.algebras.quatalg.quaternion_algebra import maxord_solve_aux_eq
         sage: for a in [1,3]:
         ....:     for b in [1,2,3]:
-        ....:         (y,z,w) = maxord_solve_aux_eq(a, b, 2)
+        ....:         y, z, w = maxord_solve_aux_eq(a, b, 2)
         ....:         assert mod(y, 4) == 1 or mod(y, 4) == 3
         ....:         assert mod(1 - a*y^2 - b*z^2 + a*b*w^2, 4) == 0
     """