Trac #26866: remove various old deprecated stuff

from #15808 #15560 #15095 #15601

URL: https://trac.sagemath.org/26866
Reported by: chapoton
Ticket author(s): Frédéric Chapoton
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/categories/classical_crystals.py

@@ -1,12 +1,12 @@
 r"""
 Classical Crystals
 """
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2010    Anne Schilling <anne at math.ucdavis.edu>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#******************************************************************************
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
 
 from sage.misc.cachefunc import cached_method
 from sage.categories.category_singleton import Category_singleton
@@ -16,6 +16,7 @@
 from sage.categories.highest_weight_crystals import HighestWeightCrystals
 from sage.categories.tensor import TensorProductsCategory
 
+
 class ClassicalCrystals(Category_singleton):
     """
     The category of classical crystals, that is crystals of finite Cartan type.
@@ -76,7 +77,7 @@ def super_categories(self):
         """
         return [RegularCrystals(), FiniteCrystals(), HighestWeightCrystals()]
 
-    def example(self, n = 3):
+    def example(self, n=3):
         """
         Returns an example of highest weight crystals, as per
         :meth:`Category.example`.
@@ -108,28 +109,9 @@ def additional_structure(self):
 
     class ParentMethods:
 
-        def opposition_automorphism(self):
-            r"""
-            Deprecated in :trac:`15560`. Use the corresponding method in
-            Cartan type.
-
-            EXAMPLES::
-
-                sage: T = crystals.Tableaux(['A',5],shape=[1])
-                sage: T.opposition_automorphism()
-                doctest:...: DeprecationWarning: opposition_automorphism is deprecated.
-                Use opposition_automorphism from the Cartan type instead.
-                See http://trac.sagemath.org/15560 for details.
-                Finite family {1: 5, 2: 4, 3: 3, 4: 2, 5: 1}
-            """
-            from sage.misc.superseded import deprecation
-            deprecation(15560, 'opposition_automorphism is deprecated. Use'
-                               ' opposition_automorphism from the Cartan type instead.')
-            return self.cartan_type().opposition_automorphism()
-
         def demazure_character(self, w, f = None):
             r"""
-            Returns the Demazure character associated to ``w``.
+            Return the Demazure character associated to ``w``.
 
             INPUT:
 
@@ -190,7 +172,6 @@ def demazure_character(self, w, f = None):
             """
             from sage.misc.misc_c import prod
             from sage.rings.integer_ring import ZZ
-            from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
             if hasattr(w, 'reduced_word'):
                 word = w.reduced_word()
             else:
@@ -204,7 +185,7 @@ def demazure_character(self, w, f = None):
                 # TODO: use P.linear_combination when PolynomialRing will be a ModulesWithBasis
                 return sum((coeff*prod((x[i]**(c.weight()[i]) for i in range(n)), P.one()) for c, coeff in u), P.zero())
             else:
-                return sum((coeff*f(c)) for c, coeff in u)
+                return sum(coeff * f(c) for c, coeff in u)
 
         def character(self, R=None):
             """

src/sage/functions/transcendental.py

@@ -2,7 +2,7 @@
 Number-Theoretic Functions
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2005 William Stein <[email protected]>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -14,8 +14,8 @@
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 import sys
 import sage.rings.complex_field as complex_field
@@ -27,7 +27,6 @@
 from sage.symbolic.function import GinacFunction, BuiltinFunction
 
 import sage.libs.mpmath.utils as mpmath_utils
-from sage.misc.superseded import deprecation
 from sage.combinat.combinat import bernoulli_polynomial
 
 from .gamma import psi
@@ -261,20 +260,20 @@ def _derivative_(self, s, x, diff_param):
 hurwitz_zeta_func = Function_HurwitzZeta()
 
 
-def hurwitz_zeta(s, x, prec=None, **kwargs):
+def hurwitz_zeta(s, x, **kwargs):
     r"""
     The Hurwitz zeta function `\zeta(s, x)`, where `s` and `x` are complex.
 
     The Hurwitz zeta function is one of the many zeta functions. It
-    defined as
+    is defined as
 
     .. MATH::
 
              \zeta(s, x) = \sum_{k=0}^{\infty} (k + x)^{-s}.
 
 
     When `x = 1`, this coincides with Riemann's zeta function.
-    The Dirichlet L-functions may be expressed as a linear combination
+    The Dirichlet L-functions may be expressed as linear combinations
     of Hurwitz zeta functions.
 
     EXAMPLES:
@@ -307,11 +306,6 @@ def hurwitz_zeta(s, x, prec=None, **kwargs):
 
     - :wikipedia:`Hurwitz_zeta_function`
     """
-    if prec:
-        deprecation(15095, 'the syntax hurwitz_zeta(s, x, prec) has been '
-                           'deprecated. Use hurwitz_zeta(s, x).n(digits=prec) '
-                           'instead.')
-        return hurwitz_zeta_func(s, x).n(digits=prec)
     return hurwitz_zeta_func(s, x, **kwargs)
 
 

src/sage/interfaces/genus2reduction.py

@@ -21,16 +21,16 @@
 and for people to modify the C source code however they want.
 """
 
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2006 William Stein <[email protected]>
 #       Copyright (C) 2014 Jeroen Demeyer <[email protected]>
 #
 # 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 __future__ import print_function
 
 from sage.structure.sage_object import SageObject
@@ -359,76 +359,6 @@ def _repr_(self):
         """
         return "Genus 2 reduction PARI interface"
 
-    def raw(self, Q, P):
-        r"""
-        Return a string emulating the raw output of running the old
-        ``genus2reduction`` program on the hyperelliptic curve
-        `y^2 + Q(x)y = P(x)`.
-
-        INPUT:
-
-        -  ``Q`` - something coercible to a univariate
-           polynomial over Q.
-
-        -  ``P`` - something coercible to a univariate
-           polynomial over Q.
-
-        OUTPUT:
-
-        -  ``string`` - raw output
-
-        -  ``Q`` - what Q was actually input to auxiliary
-           genus2reduction program
-
-        -  ``P`` - what P was actually input to auxiliary
-           genus2reduction program
-
-        EXAMPLES::
-
-            sage: x = QQ['x'].0
-            sage: print(genus2reduction.raw(x^3 - 2*x^2 - 2*x + 1, -5*x^5)[0])
-            doctest:...: DeprecationWarning: the raw() method is provided for backwards compatibility only, use the result of the genus2reduction() call instead of parsing strings
-            See http://trac.sagemath.org/15808 for details.
-            a minimal equation over Z[1/2] is :
-            y^2 = x^6-240*x^4-2550*x^3-11400*x^2-24100*x-19855
-            <BLANKLINE>
-            factorization of the minimal (away from 2) discriminant :
-            [2,3;5,5;2267,1]
-            <BLANKLINE>
-            p=2
-            (potential) stable reduction :  (II), j=1
-            p=5
-            (potential) stable reduction :  (I)
-            reduction at p : [V] page 156, (3), f=4
-            p=2267
-            (potential) stable reduction :  (II), j=432
-            reduction at p : [I{1-0-0}] page 170, (1), f=1
-            <BLANKLINE>
-            the prime to 2 part of the conductor is 1416875
-            in factorized form : [5,4;2267,1]
-        """
-        from sage.misc.superseded import deprecation
-        deprecation(15808, 'the raw() method is provided for backwards compatibility only, use the result of the genus2reduction() call instead of parsing strings')
-
-        d = self(Q, P)
-
-        s = "a minimal equation over Z[1/2] is :\n"
-        s += "y^2 = %s\n\n" % str(d.minimal_equation).replace(" ", "")
-        s += "factorization of the minimal (away from 2) discriminant :\n"
-        s += "%s\n\n" % str(pari(d.minimal_disc).factor()).replace(" ", "")
-
-        for p in sorted(d.local_data.keys()):
-            s += "p=%s\n" % p
-            s += d.local_data[p].replace(":", " :") + "\n"
-
-        if d.prime_to_2_conductor_only:
-            s += "the prime to 2 part of the conductor is %s\n" % d.conductor
-        else:
-            s += "the conductor is %s\n" % d.conductor
-        s += "in factorized form : %s" % str(pari(d.conductor).factor()).replace(" ", "")
-
-        return s, d.Q, d.P
-
     def __call__(self, Q, P):
         """
         Compute and return the :class:`ReductionData` corresponding to
@@ -501,11 +431,11 @@ def __call__(self, Q, P):
         P = R(P)
         Q = R(Q)
         if P.degree() > 6:
-            raise ValueError("P (=%s) must have degree at most 6"%P)
-        if Q.degree() >=4:
-            raise ValueError("Q (=%s) must have degree at most 3"%Q)
+            raise ValueError("P (=%s) must have degree at most 6" % P)
+        if Q.degree() >= 4:
+            raise ValueError("Q (=%s) must have degree at most 3" % Q)
 
-        res = pari.genus2red([P,Q])
+        res = pari.genus2red([P, Q])
 
         conductor = ZZ(res[0])
         minimal_equation = R(res[2])

src/sage/rings/power_series_ring.py

@@ -134,7 +134,6 @@
 from sage.interfaces.magma import MagmaElement
 from sage.rings.fraction_field_element import FractionFieldElement
 from sage.misc.sage_eval import sage_eval
-from sage.misc.superseded import deprecation
 
 from sage.structure.unique_representation import UniqueRepresentation
 from sage.structure.category_object import normalize_names
@@ -458,8 +457,7 @@ class PowerSeriesRing_generic(UniqueRepresentation, ring.CommutativeRing, Nonexa
     """
 
     def __init__(self, base_ring, name=None, default_prec=None, sparse=False,
-                 use_lazy_mpoly_ring=None, implementation=None,
-                 category=None):
+                 implementation=None, category=None):
         """
         Initializes a power series ring.
 
@@ -479,9 +477,6 @@ def __init__(self, base_ring, name=None, default_prec=None, sparse=False,
           ``'pari'``.  The default is ``'pari'`` if the base field is
           a PARI finite field, and ``'poly'`` otherwise.
 
-        - ``use_lazy_mpoly_ring`` -- This option is deprecated; use
-          ``implementation='mpoly'`` instead.
-
         If the base ring is a polynomial ring, then the option
         ``implementation='mpoly'`` causes computations to be done with
         multivariate polynomials instead of a univariate polynomial
@@ -522,17 +517,11 @@ def __init__(self, base_ring, name=None, default_prec=None, sparse=False,
             ValueError: default_prec (= -5) must be non-negative
 
         """
-        if use_lazy_mpoly_ring is not None:
-            deprecation(15601, 'The option use_lazy_mpoly_ring is deprecated; use implementation="mpoly" instead')
-
         from sage.rings.finite_rings.finite_field_pari_ffelt import FiniteField_pari_ffelt
 
         if implementation is None:
             if isinstance(base_ring, FiniteField_pari_ffelt):
                 implementation = 'pari'
-            elif use_lazy_mpoly_ring and (is_MPolynomialRing(base_ring) or
-                                          is_PolynomialRing(base_ring)):
-                implementation = 'mpoly'
             else:
                 implementation = 'poly'
 
@@ -939,13 +928,6 @@ def _poly_ring(self):
         """
         return self.__poly_ring
 
-    def _mpoly_ring(self):
-        """
-        Return the polynomial ring that we use if ``use_lazy_mpoly_ring``
-        was set.
-        """
-        return self.__mpoly_ring
-
     def base_extend(self, R):
         """
         Return the power series ring over R in the same variable as self,
@@ -1275,4 +1257,3 @@ def unpickle_power_series_ring_v0(base_ring, name, default_prec, sparse):
         True
     """
     return PowerSeriesRing(base_ring, name=name, default_prec = default_prec, sparse=sparse)
-