passagemath-combinat 10.6.1__cp312-cp312-musllinux_1_2_aarch64.whl → 10.8.1a1__cp312-cp312-musllinux_1_2_aarch64.whl

sage/algebras/splitting_algebra.py

@@ -34,18 +34,18 @@ AUTHORS:
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-
 from warnings import warn
 
+from sage.misc.flatten import flatten as flatten_list
 from sage.misc.verbose import verbose
 from sage.misc.cachefunc import cached_method
 from sage.rings.polynomial.polynomial_quotient_ring import PolynomialQuotientRing_domain
 from sage.rings.polynomial.polynomial_quotient_ring_element import PolynomialQuotientRingElement
 
 
-# ------------------------------------------------------------------------------------------------------------------
+# -------------------------------------------------------------------------
 # Element class for the splitting algebra
-# --------------------------------------------------------------------------------------------------------
+# -------------------------------------------------------------------------
 class SplittingAlgebraElement(PolynomialQuotientRingElement):
     r"""
     Element class for :class:`SplittingAlgebra`.
@@ -86,7 +86,7 @@ class SplittingAlgebraElement(PolynomialQuotientRingElement):
 
         return super().__invert__()
 
-    def is_unit(self):
+    def is_unit(self) -> bool:
         r"""
         Return ``True`` if ``self`` is invertible.
 
@@ -103,7 +103,7 @@ class SplittingAlgebraElement(PolynomialQuotientRingElement):
 
         return super().is_unit()
 
-    def monomial_coefficients(self, copy=True):
+    def monomial_coefficients(self, copy=True) -> dict:
         r"""
         Return the dictionary of ``self`` according to its lift to the cover.
 
@@ -124,9 +124,9 @@ class SplittingAlgebraElement(PolynomialQuotientRingElement):
 
     dict = monomial_coefficients
 
-# ------------------------------------------------------------------------------------------------------------------
+# ---------------------------------------------------------------------------
 # Parent class of the splitting algebra
-# --------------------------------------------------------------------------------------------------------
+# ---------------------------------------------------------------------------
 
 
 class SplittingAlgebra(PolynomialQuotientRing_domain):
@@ -204,7 +204,8 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
     """
     Element = SplittingAlgebraElement
 
-    def __init__(self, monic_polynomial, names='X', iterate=True, warning=True):
+    def __init__(self, monic_polynomial, names='X',
+                 iterate=True, warning=True) -> None:
         r"""
         Python constructor.
 
@@ -213,21 +214,20 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
             sage: from sage.algebras.splitting_algebra import SplittingAlgebra
             sage: Lw.<w> = LaurentPolynomialRing(ZZ)
             sage: PuvLw.<u,v> = Lw[]; t = polygen(PuvLw)
-            sage: S.<x, y> = SplittingAlgebra(t^3 - u*t^2 + v*t - w, warning=False)
+            sage: poly = t^3 - u*t^2 + v*t - w
+            sage: S.<x, y> = SplittingAlgebra(poly, warning=False)
             sage: TestSuite(S).run()
         """
-
-        # ---------------------------------------------------------------------------------
+        # ---------------------------------------------------------------
         # checking input parameters
-        # ---------------------------------------------------------------------------------
-
+        # ---------------------------------------------------------------
         base_ring = monic_polynomial.base_ring()
         if not monic_polynomial.is_monic():
             raise ValueError("given polynomial must be monic")
         deg = monic_polynomial.degree()
 
         from sage.structure.category_object import normalize_names
-        self._root_names = normalize_names(deg-1, names)
+        self._root_names = normalize_names(deg - 1, names)
         root_names = list(self._root_names)
         verbose("Create splitting algebra to base ring %s and polynomial %s (%s %s)"
                 % (base_ring, monic_polynomial, iterate, warning))
@@ -243,7 +243,7 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
             if base_ring not in Rings():
                 raise TypeError("base_ring must be a ring")
             if warning:
-                warn('Assuming %s to be an integral domain!' % base_ring)
+                warn(f'Assuming {base_ring} to be an integral domain!')
 
         if deg < 1:
             raise ValueError("the degree of the polynomial must positive")
@@ -255,9 +255,9 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
         if isinstance(base_ring, SplittingAlgebra):
             self._invertible_elements = base_ring._invertible_elements
 
-        # ------------------------------------------------------------------------------------
+        # -----------------------------------------------------------
         # taking next root_name
-        # ------------------------------------------------------------------------------------
+        # -----------------------------------------------------------
         root_name = root_names[0]
         p = monic_polynomial.change_variable_name(root_name)
         P = p.parent()
@@ -270,16 +270,34 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
             # assuming this has been checked mathematically before
             self._set_modulus_irreducible_ = True
             if warning:
-                warn('Assuming %s to have maximal Galois group!' % (monic_polynomial))
-                warning = False # one warning must be enough
+                def_pol = monic_polynomial
+                if isinstance(base_ring, SplittingAlgebra):
+                    # Here we are inside a recursion. Using the splitting field
+                    # over the fractional field of the scalar base ring we may
+                    # find a reason to avoid the warning.
+                    def_pol = base_ring.defining_polynomial()
+                    F = base_ring.scalar_base_ring().fraction_field()
+                    def_pol_f = def_pol.change_ring(F)
+                    try:
+                        E = def_pol_f.splitting_field('Ex')
+                        if E.degree() == def_pol_f.degree().factorial():
+                            # Galois group is maximal
+                            warning = False
+                    except NotImplementedError:
+                        pass
+                if warning:
+                    warn(f'Assuming {def_pol} to have maximal Galois group!')
+                    warning = False  # one warning must be enough
 
         verbose("P %s defined:" % (P))
 
         if deg > 2 and iterate:
-            # ------------------------------------------------------------------------------------
+            # -----------------------------------------------------------
             # successive solution via recursion (on base_ring_step)
-            # ------------------------------------------------------------------------------------
-            base_ring_step = SplittingAlgebra(monic_polynomial, tuple(root_names), iterate=False, warning=False)
+            # -----------------------------------------------------------
+            base_ring_step = SplittingAlgebra(monic_polynomial,
+                                              tuple(root_names),
+                                              iterate=False, warning=warning)
             first_root = base_ring_step.gen()
 
             verbose("base_ring_step %s defined:" % (base_ring_step))
@@ -297,7 +315,8 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
 
             verbose("Invoking recursion with: %s" % (q,))
 
-            SplittingAlgebra.__init__(self, q, root_names_reduces, warning=False)
+            SplittingAlgebra.__init__(self, q, root_names_reduces,
+                                      warning=warning)
 
             splitting_roots = base_ring_step._splitting_roots + self._splitting_roots
             coefficients_list = base_ring_step._coefficients_list + self._coefficients_list
@@ -329,10 +348,13 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
         verbose("splitting_roots: %s embedded" % (self._splitting_roots))
 
         # --------------------------------------------------------------------
-        # try to calculate inverses of the roots. This is possible if the original polynomial
-        # has an invertible constant term. For example let cf = [-w, v,-u, 1] that is
-        # p = h^3 -u*h^2 + v*h -w, than u = x + y + z, v = x*y + x*z + y*z, w = x*y*z. If
-        # w is invertible then 1/x = (v -(u-x)*x)/w, 1/y = (v -(u-y)*y)/w, 1/z = (v -(u-z)*z)/w
+        # try to calculate inverses of the roots. This is possible if
+        # the original polynomial has an invertible constant term. For
+        # example let cf = [-w, v,-u, 1] that is
+        # p = h^3 -u*h^2 + v*h -w, then
+        # u = x + y + z, v = x*y + x*z + y*z, w = x*y*z. If w is
+        # invertible then 1/x = (v -(u-x)*x)/w, 1/y = (v -(u-y)*y)/w,
+        # 1/z = (v -(u-z)*z)/w
         # -----------------------------------------------------------------
         # first find the polynomial with invertible constant coefficient
         # -----------------------------------------------------------------
@@ -352,18 +374,18 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
         # and the _splitting_roots are its roots we can calculate inverses
         # ------------------------------------------------------------------
         if cf0_inv is not None:
-            deg_cf = len(cf)-1
+            deg_cf = len(cf) - 1
             pf = P(cf)
             for root in self._splitting_roots:
                 check = self(pf)
                 if not check.is_zero():
                     continue
                 root_inv = self.one()
-                for pos in range(deg_cf-1):
-                    root_inv = (-1)**(pos+1) * cf[deg_cf-pos-1] - root_inv * root
+                for pos in range(deg_cf - 1):
+                    root_inv = (-1)**(pos + 1) * cf[deg_cf - pos - 1] - root_inv * root
                 verbose("inverse %s of root %s" % (root_inv, root))
                 root_inv = (-1)**(deg_cf) * cf0_inv * root_inv
-                self._invertible_elements.update({root:root_inv})
+                self._invertible_elements.update({root: root_inv})
                 verbose("adding inverse %s of root %s" % (root_inv, root))
             invert_items = list(self._invertible_elements.items())
             for k, v in invert_items:
@@ -375,7 +397,7 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
     # overloaded inherited methods
     # ----------------------------------------------------------------------
     ########################################################################
-    def __reduce__(self):
+    def __reduce__(self) -> tuple:
         r"""
         Used in pickling.
 
@@ -385,10 +407,10 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
             sage: L.<t, u, v, w > = LaurentPolynomialRing(ZZ); x = polygen(L)
             sage: S = SplittingAlgebra(x^4 -t*x^3 - u*x^2 - v*x + w, ('X', 'Y', 'Z'), warning=False)
             sage: S.__reduce__()
-            (<class 'sage.algebras.splitting_algebra.SplittingAlgebra_with_category'>,
+            (<...SplittingAlgebra_with_category'>,
             (x^4 - t*x^3 - u*x^2 - v*x + w, ('X', 'Y', 'Z'), True, False))
             sage: S.base_ring().__reduce__()
-            (<class 'sage.algebras.splitting_algebra.SplittingAlgebra_with_category'>,
+            (<...SplittingAlgebra_with_category'>,
             (Y^3 + (X - t)*Y^2 + (X^2 - t*X - u)*Y + X^3 - t*X^2 - u*X - v,
             ('Y', 'Z'),
             False,
@@ -396,15 +418,16 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
 
             sage: TestSuite(S).run()
         """
-        defining_polynomial = self.defining_polynomial()
-        definig_coefficients = self._coefficients_list[0]
-        if defining_polynomial.coefficients(sparse=False) != definig_coefficients:
+        def_polynomial = self.defining_polynomial()
+        def_coefficients = self._coefficients_list[0]
+        if def_polynomial.coefficients(sparse=False) != def_coefficients:
             # case of factorization algebra (intermediate construction step)
             par_pol = self.cover_ring()
-            defining_polynomial = par_pol(definig_coefficients)
-        return self.__class__, (defining_polynomial, self._root_names, self._iterate, False)
+            def_polynomial = par_pol(def_coefficients)
+        return self.__class__, (def_polynomial, self._root_names,
+                                self._iterate, False)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -413,23 +436,26 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
             sage: from sage.algebras.splitting_algebra import SplittingAlgebra
             sage: L.<u, v> = PolynomialRing(ZZ)
             sage: t = polygen(L)
-            sage: Spl.<S, T> = SplittingAlgebra(t^3 - (u^2-v)*t^2 + (v+u)*t - 1)
+            sage: Spl.<S, T> = SplittingAlgebra(t^3 - (u^2-v)*t^2 + (v+u)*t - 1, warning=False)
             sage: Spl._repr_()
             'Splitting Algebra of x^3 + (-u^2 + v)*x^2 + (u + v)*x - 1
              with roots [S, T, -T - S + u^2 - v]
              over Multivariate Polynomial Ring in u, v over Integer Ring'
             sage: Spl.base_ring()    # indirect doctest
             Factorization Algebra of x^3 + (-u^2 + v)*x^2 + (u + v)*x - 1
-             with roots [S] over Multivariate Polynomial Ring in u, v over Integer Ring
+             with roots [S] over Multivariate Polynomial Ring in u, v
+             over Integer Ring
         """
         if self.is_completely_split():
             return ('Splitting Algebra of %s with roots %s over %s'
-                    % (self.defining_polynomial(), self.splitting_roots(), self.scalar_base_ring()))
-        else:
-            return ('Factorization Algebra of %s with roots %s over %s'
-                    % (self.defining_polynomial(), self.splitting_roots(), self.scalar_base_ring()))
+                    % (self.defining_polynomial(), self.splitting_roots(),
+                       self.scalar_base_ring()))
+
+        return ('Factorization Algebra of %s with roots %s over %s'
+                % (self.defining_polynomial(), self.splitting_roots(),
+                   self.scalar_base_ring()))
 
-    def _first_ngens(self, n):
+    def _first_ngens(self, n) -> tuple:
         r"""
         Used by the preparser for ``R.<x> = ...``.
 
@@ -439,6 +465,9 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
             sage: L.<u, v> = PolynomialRing(ZZ)
             sage: t = polygen(L)
             sage: S.<X, Y> = SplittingAlgebra(t^3 - (u^2-v)*t^2 + (v+u)*t - 1)  # indirect doctest
+            doctest:warning
+            ...
+            UserWarning: Assuming x^3 + (-u^2 + v)*x^2 + (u + v)*x - 1 to have maximal Galois group!
             sage: X.parent()
             Splitting Algebra of x^3 + (-u^2 + v)*x^2 + (u + v)*x - 1
              with roots [X, Y, -Y - X + u^2 - v]
@@ -447,19 +476,20 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
             (X, Y, u, v)
         """
         srts = self.splitting_roots()
-        k = len(srts)-1
+        k = len(srts) - 1
         gens = srts[:k] + list(self.scalar_base_ring().gens())
         return tuple(gens[:n])
 
     def _element_constructor_(self, x):
         r"""
-        Make sure ``x`` is a valid member of ``self``, and return the constructed element.
+        Make sure ``x`` is a valid member of ``self``, and return the
+        constructed element.
 
         TESTS::
 
             sage: from sage.algebras.splitting_algebra import SplittingAlgebra
             sage: L.<u, v, w> = LaurentPolynomialRing(ZZ); x = polygen(L)
-            sage: S.<X, Y> = SplittingAlgebra(x^3 - u*x^2 + v*x - w)
+            sage: S.<X, Y> = SplittingAlgebra(x^3 - u*x^2 + v*x - w, warning=False)
             sage: S(u + v)
             u + v
             sage: S(X*Y + X)
@@ -484,6 +514,9 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
             sage: from sage.algebras.splitting_algebra import SplittingAlgebra
             sage: L.<u, v, w> = LaurentPolynomialRing(ZZ); x = polygen(L)
             sage: S = SplittingAlgebra(x^3 - u*x^2 + v*x - w, ('X', 'Y'))
+            doctest:warning
+            ...
+            UserWarning: Assuming x^3 - u*x^2 + v*x - w to have maximal Galois group!
             sage: P.<x, y, z> = PolynomialRing(ZZ)
             sage: F = FractionField(P)
             sage: im_gens = [F(g) for g in [y, x, x + y + z, x*y+x*z+y*z, x*y*z]]
@@ -502,23 +535,27 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
 
         all_gens = self.gens_dict_recursive()
         if len(im_gens) != len(all_gens):
-            return super().hom(im_gens, codomain=codomain, check=check, base_map=base_map)
+            return super().hom(im_gens, codomain=codomain,
+                               check=check, base_map=base_map)
 
         num_gens = len(self.gens())
         im_gens_start = [img for img in im_gens if im_gens.index(img) < num_gens]
         im_gens_end = [img for img in im_gens if im_gens.index(img) >= num_gens]
 
         if not im_gens_end:
-            return super().hom(im_gens, codomain=codomain, check=check, base_map=base_map)
+            return super().hom(im_gens, codomain=codomain,
+                               check=check, base_map=base_map)
 
         verbose('base %s im_gens_end %s codomain %s check %s base_map %s' % (base_ring, im_gens_end, codomain, check, base_map))
-        hom_on_base_recurs = base_ring.hom(im_gens_end, codomain=codomain, check=check, base_map=base_map)
+        hom_on_base_recurs = base_ring.hom(im_gens_end, codomain=codomain,
+                                           check=check, base_map=base_map)
         verbose('hom_on_base_recurs %s' % (hom_on_base_recurs))
 
         cover_ring = self.cover_ring()
-        hom_from_cover = cover_ring.hom(im_gens_start, codomain=codomain, check=check, base_map=hom_on_base_recurs)
+        hom_from_cover = cover_ring.hom(im_gens_start, codomain=codomain,
+                                        check=check, base_map=hom_on_base_recurs)
         lift = self.lifting_map()
-        return hom_from_cover*lift
+        return hom_from_cover * lift
 
     ###################################################################
     # -----------------------------------------------------------------
@@ -532,7 +569,7 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
     # -----------------------------------------------------------------
     ###################################################################
 
-    def is_completely_split(self):
+    def is_completely_split(self) -> bool:
         r"""
         Return ``True`` if the defining polynomial of ``self`` splits into
         linear factors over ``self``.
@@ -552,8 +589,10 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
     @cached_method
     def lifting_map(self):
         r"""
-        Return a section map from ``self`` to the cover ring. It is implemented according
-        to the same named method of :class:`~sage.rings.quotient_ring.QuotientRing_nc`.
+        Return a section map from ``self`` to the cover ring.
+
+        It is implemented according to the same named method of
+        :class:`~sage.rings.quotient_ring.QuotientRing_nc`.
 
         EXAMPLES::
 
@@ -570,7 +609,7 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
         from sage.rings.morphism import RingMap_lift
         return RingMap_lift(self, self.cover_ring())
 
-    def splitting_roots(self):
+    def splitting_roots(self) -> list:
         r"""
         Return the roots of the split equation.
 
@@ -597,7 +636,8 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
             sage: S = SplittingAlgebra(x^3 - u*x^2 + v*x - w, ('X', 'Y'))
             sage: S.base_ring()
             Factorization Algebra of x^3 - u*x^2 + v*x - w with roots [X]
-             over Multivariate Laurent Polynomial Ring in u, v, w over Integer Ring
+             over Multivariate Laurent Polynomial Ring in u, v, w
+             over Integer Ring
             sage: S.scalar_base_ring()
             Multivariate Laurent Polynomial Ring in u, v, w over Integer Ring
         """
@@ -634,20 +674,23 @@ class SplittingAlgebra(PolynomialQuotientRing_domain):
         return self._defining_polynomial
 
 
-# --------------------------------------------------------------------------------------------
-# ============================================================================================
-# Utility function to create the roots of a polynomial in an appropriate extension ring
-# ============================================================================================
-# --------------------------------------------------------------------------------------------
+# ----------------------------------------------------------------------
+# ======================================================================
+# Utility function to create the roots of a polynomial in an
+# appropriate extension ring
+# ======================================================================
+# ----------------------------------------------------------------------
 
-def solve_with_extension(monic_polynomial, root_names=None, var='x', flatten=False, warning=True):
+def solve_with_extension(monic_polynomial, root_names=None, var='x',
+                         flatten=False, warning=True) -> list[tuple]:
     r"""
-    Return all roots of a monic polynomial in its base ring or in an appropriate
-    extension ring, as far as possible.
+    Return all roots of a monic polynomial in its base ring or in an
+    appropriate extension ring, as far as possible.
 
     INPUT:
 
-    - ``monic_polynomial`` -- the monic polynomial whose roots should be created
+    - ``monic_polynomial`` -- the monic polynomial whose roots
+      should be created
     - ``root_names`` -- names for the indeterminates needed to define the
       splitting algebra of the ``monic_polynomial`` (if necessary and possible)
     - ``var`` -- (default: ``'x'``) for the indeterminate needed to define the
@@ -674,13 +717,14 @@ def solve_with_extension(monic_polynomial, root_names=None, var='x', flatten=Fal
         sage: solve_with_extension(p)
         [(1, 2)]
 
-        sage: cp5 = cyclotomic_polynomial(5, var='T').change_ring(UniversalCyclotomicField())
+        sage: U = UniversalCyclotomicField()
+        sage: cp5 = cyclotomic_polynomial(5, var='T').change_ring(U)
         sage: solve_with_extension(cp5)
         [(E(5), 1), (E(5)^4, 1), (E(5)^2, 1), (E(5)^3, 1)]
         sage: _[0][0].parent()
         Universal Cyclotomic Field
     """
-    def create_roots(monic_polynomial, warning=True):
+    def create_roots(monic_polynomial, warning=warning):
         r"""
         This internal function creates all roots of a polynomial in an
         appropriate extension ring assuming that none of the roots is
@@ -708,10 +752,10 @@ def solve_with_extension(monic_polynomial, root_names=None, var='x', flatten=Fal
                 # in this case the SplittingAlgebra is preferred
                 raise NotImplementedError
 
-            # -------------------------------------------------------------------------------------
-            # in some cases the embedding of the base_ring in ext_field can not be obtained
-            # as coercion
-            # -------------------------------------------------------------------------------------
+            # -------------------------------------------------------------
+            # in some cases the embedding of the base_ring in
+            # ext_field can not be obtained as coercion
+            # -------------------------------------------------------------
             reset_coercion = False
             from sage.rings.number_field.number_field import NumberField_generic
             if isinstance(base_ring, NumberField_generic):
@@ -727,7 +771,8 @@ def solve_with_extension(monic_polynomial, root_names=None, var='x', flatten=Fal
             pol_emb = monic_polynomial.change_ring(ext_field)
             roots = pol_emb.roots()
         except NotImplementedError:
-            ext_ring = SplittingAlgebra(monic_polynomial, name_list, warning=warning)
+            ext_ring = SplittingAlgebra(monic_polynomial, name_list,
+                                        warning=warning)
             verbose("splitting algebra %s defined" % (ext_ring))
             roots = [(r, 1) for r in ext_ring.splitting_roots()]
         return roots
@@ -735,7 +780,7 @@ def solve_with_extension(monic_polynomial, root_names=None, var='x', flatten=Fal
     deg_pol = monic_polynomial.degree()
     if not root_names:
         from sage.structure.category_object import normalize_names
-        root_names = normalize_names(deg_pol-1, 'r')
+        root_names = normalize_names(deg_pol - 1, 'r')
     name_list = list(root_names)
     root_list = []
     try:
@@ -753,20 +798,20 @@ def solve_with_extension(monic_polynomial, root_names=None, var='x', flatten=Fal
         roots = create_roots(monic_polynomial, warning=warning)
 
     else:
-        # ------------------------------------------------------------------
+        # ----------------------------------------------------------------
         # root calculation was possible but maybe some more roots in
         # an appropriate extension ring can be constructed.
-        # ------------------------------------------------------------------
-        num_roots = sum(m for r, m in root_list)
+        # ----------------------------------------------------------------
+        num_roots = sum(m for _, m in root_list)
         if num_roots < deg_pol:
             h = monic_polynomial.variables()[0]
             divisor = monic_polynomial.base_ring().one()
             for r, m in root_list:
                 divisor *= (h - r)**m
-            q, r = monic_polynomial.quo_rem(divisor)
+            q, _ = monic_polynomial.quo_rem(divisor)
             if len(name_list) > deg_pol - num_roots - 1:
-                name_list = [name_list[i] for i in range(deg_pol - num_roots - 1)]
-            verbose("%d root found in base ring, now solving %s" % (num_roots,q))
+                name_list = name_list[:deg_pol - num_roots - 1]
+            verbose(f"{num_roots} root found in base ring, now solving {q}")
             missing_roots = create_roots(q, warning=True)
             roots = root_list + missing_roots
         else:
@@ -774,6 +819,5 @@ def solve_with_extension(monic_polynomial, root_names=None, var='x', flatten=Fal
             verbose("all roots in base ring")
 
     if flatten:
-        from sage.misc.flatten import flatten
-        return flatten([[rt]*m for rt, m in roots])
+        return flatten_list([[rt] * m for rt, m in roots])
     return roots

sage/algebras/tensor_algebra.py

@@ -12,12 +12,12 @@ AUTHORS:
     - Coerce to/from free algebra.
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #  Copyright (C) 2014 Travis Scrimshaw <tscrim at 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.categories.algebras import Algebras
 from sage.categories.pushout import ConstructionFunctor
@@ -115,7 +115,7 @@ class TensorAlgebra(CombinatorialFreeModule):
         # the following is not the best option, but it's better than nothing.
         self._print_options['tensor_symbol'] = options.get('tensor_symbol', tensor.symbol)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -127,7 +127,7 @@ class TensorAlgebra(CombinatorialFreeModule):
         """
         return "Tensor Algebra of {}".format(self._base_module)
 
-    def _repr_term(self, m):
+    def _repr_term(self, m) -> str:
         """
         Return a string of representation of the term indexed by ``m``.
 
@@ -153,7 +153,7 @@ class TensorAlgebra(CombinatorialFreeModule):
             symb = tensor.symbol
         return symb.join(self._base_module._repr_term(k) for k,e in m._monomial for i in range(e))
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a latex representation of the term indexed by ``m``.
 
@@ -617,7 +617,7 @@ class TensorAlgebraFunctor(ConstructionFunctor):
         """
         ConstructionFunctor.__init__(self, Modules(base), Algebras(base))
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         Return a string representation of ``self``.
 

sage/algebras/yangian.py

@@ -251,7 +251,7 @@ class Yangian(CombinatorialFreeModule):
                                          sorting_key=Yangian._term_key,
                                          prefix=variable_name, category=category)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -264,7 +264,7 @@ class Yangian(CombinatorialFreeModule):
         """
         return "Yangian of gl({}) in the {} filtration over {}".format(self._n, self._filtration, self.base_ring())
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -290,7 +290,7 @@ class Yangian(CombinatorialFreeModule):
         """
         return (-len(x), x._sorted_items())
 
-    def _repr_term(self, m):
+    def _repr_term(self, m) -> str:
         """
         Return a string representation of the basis element indexed by ``m``.
 
@@ -306,11 +306,11 @@ class Yangian(CombinatorialFreeModule):
         if len(m) == 0:
             return '1'
         prefix = self.prefix()
-        return '*'.join(prefix + '({})[{},{}]'.format(r,i,j)
+        return '*'.join(prefix + '({})[{},{}]'.format(r, i, j)
                         + ('^{}'.format(exp) if exp > 1 else '')
-                        for (r,i,j), exp in m._sorted_items())
+                        for (r, i, j), exp in m._sorted_items())
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a `\LaTeX` representation of the basis element indexed
         by ``m``.
@@ -674,7 +674,7 @@ class YangianLevel(Yangian):
         CombinatorialFreeModule.__init__(self, base_ring, basis_keys,
                                          prefix=variable_name, category=category)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -686,7 +686,7 @@ class YangianLevel(Yangian):
         return "Yangian of level {} of gl({}) in the {} filtration over {}".format(
                         self._level, self._n, self._filtration, self.base_ring())
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -697,7 +697,7 @@ class YangianLevel(Yangian):
         """
         from sage.misc.latex import latex
         return "Y_{{{}}}(\\mathfrak{{gl}}_{{{}}}, {})".format(
-                        self._level, self._n, latex(self.base_ring()))
+            self._level, self._n, latex(self.base_ring()))
 
     def _coerce_map_from_(self, R):
         """
@@ -899,7 +899,7 @@ class GradedYangianBase(AssociatedGradedAlgebra):
     """
     Base class for graded algebras associated to a Yangian.
     """
-    def _repr_term(self, m):
+    def _repr_term(self, m) -> str:
         """
         Return a string representation of the monomial indexed by ``m``.
 
@@ -913,11 +913,11 @@ class GradedYangianBase(AssociatedGradedAlgebra):
         if len(m) == 0:
             return '1'
         prefix = self.prefix()
-        return '*'.join(prefix + '({})[{},{}]'.format(r,i,j)
+        return '*'.join(prefix + '({})[{},{}]'.format(r, i, j)
                         + ('^{}'.format(exp) if exp > 1 else '')
-                        for (r,i,j), exp in m._sorted_items())
+                        for (r, i, j), exp in m._sorted_items())
 
-    def _latex_term(self, m):
+    def _latex_term(self, m) -> str:
         r"""
         Return a latex representation of the monomial indexed by ``m``.
 
@@ -934,11 +934,12 @@ class GradedYangianBase(AssociatedGradedAlgebra):
         prefix = "\\overline{{{}}}".format(self._A.prefix())
 
         def term(r, i, j, exp):
-            s = prefix + '^{{({})}}_{{{},{}}}'.format(r,i,j)
+            s = prefix + '^{{({})}}_{{{},{}}}'.format(r, i, j)
             if exp == 1:
                 return s
             return '\\left({}\\right)^{{{}}}'.format(s, exp)
-        return ' '.join(term(r, i, j, exp) for (r,i,j), exp in m._sorted_items())
+        return ' '.join(term(r, i, j, exp)
+                        for (r, i, j), exp in m._sorted_items())
 
 
 class GradedYangianNatural(GradedYangianBase):