Fix failing tests by fallback to factor()

Author: user202729

src/sage/categories/fields.py

@@ -692,6 +692,13 @@ def _squarefree_decomposition_univariate_polynomial(self, f):
                 sage: f = QQbar['x'](1)                                                 # needs sage.rings.number_field
                 sage: f.squarefree_decomposition()                                      # needs sage.rings.number_field
                 1
+
+            .. NOTE::
+
+                Currently factorization over non-finite fields with positive characteristic
+                is not implemented, it would be useful to port the algorithm in
+                :meth:`sage.rings.finite_rings.finite_field_base.FiniteField._squarefree_decomposition_univariate_polynomial`
+                here.
             """
             from sage.structure.factorization import Factorization
             if f.degree() == 0:

src/sage/rings/polynomial/polynomial_element.pyx

@@ -10514,27 +10514,44 @@ cdef class Polynomial(CommutativePolynomial):
             sage: (x^3 + x^2).radical()                                                 # needs sage.rings.finite_rings
             x^2 + x
 
-        TESTS::
+        TESTS:
+
+        Check that the method is sufficiently fast::
 
             sage: R.<x> = GF(2^13)[]
             sage: f = R.random_element(degree=1000)
-            sage: g = f.radical()
+            sage: g = f.radical()  # < 1s
+
+        Check that the method works as long as either :meth:`squarefree_decomposition`
+        or :meth:`factor` is implemented::
+
+            sage: F.<x> = FunctionField(GF(2^10))
+            sage: R.<y> = F[]
+            sage: f = (y+1/(x-1))^2 * (y+x)
+            sage: f.factor()
+            (y + x) * (y + 1/(x + 1))^2
+            sage: f.squarefree_decomposition()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError: square-free decomposition not implemented for this polynomial
         """
         P = self._parent
         R = P.base_ring()
         p = R.characteristic()
-        if p == 0 or p > self.degree():
-            if R.is_field():
-                return self // self.gcd(self.derivative())
-            else:
-                # Be careful with the content: return the
-                # radical of the content times the radical of
-                # (self/content)
-                content = self.content_ideal().gen()
-                self_1 = (self//content)
-                return (self_1 // self_1.gcd(self_1.derivative())) * content.radical()
-        else:  # The above method is not always correct (see Issue 8736)
-            return self.squarefree_decomposition().radical_value()
+        if 0 < p <= self.degree():
+            # The method below is not always correct (see Issue 8736)
+            try:
+                return self.squarefree_decomposition().radical_value()
+            except NotImplementedError:
+                return self.factor().radical_value()
+        if R.is_field():
+            return self // self.gcd(self.derivative())
+        # Be careful with the content: return the
+        # radical of the content times the radical of
+        # (self/content)
+        content = self.content_ideal().gen()
+        self_1 = (self//content)
+        return (self_1 // self_1.gcd(self_1.derivative())) * content.radical()
 
     def content_ideal(self):
         """