passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/algebras/splitting_algebra.py

@@ -0,0 +1,779 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.libs.pari sage.modules
+r"""
+Splitting Algebras
+
+*Splitting algebras* have been considered by Dan Laksov, Anders Thorup,
+Torsten Ekedahl and others (see references below) in order to study
+intersection theory of Grassmann and other flag schemes. Similarly as
+*splitting fields* they can be considered as extensions of rings containing
+all the roots of a given monic polynomial over that ring under the
+assumption that its Galois group is the symmetric group of order equal
+to the polynomial's degree.
+
+Thus they can be used as a tool to express elements of a ring generated by
+`n` indeterminates in terms of symmetric functions in these indeterminates.
+
+This realization of splitting algebras follows the approach of a recursive
+quotient ring construction splitting off some linear factor of the
+polynomial in each recursive step. Accordingly it is inherited from
+:class:`PolynomialQuotientRing_domain`.
+
+AUTHORS:
+
+- Sebastian Oehms (April 2020): initial version
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2020 Sebastian Oehms <seb.oehms@gmail.com>
+#
+# 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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+
+from warnings import warn
+
+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`.
+
+    EXAMPLES::
+
+        sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+        sage: cp6 = cyclotomic_polynomial(6)
+        sage: CR6.<e6> = SplittingAlgebra(cp6)
+        sage: type(e6)
+        <class 'sage.algebras.splitting_algebra.SplittingAlgebra_with_category.element_class'>
+
+        sage: type(CR6(5))
+        <class 'sage.algebras.splitting_algebra.SplittingAlgebra_with_category.element_class'>
+    """
+    def __invert__(self):
+        r"""
+        Return the inverse of ``self``.
+
+        Support inversion of special elements attached to the construction
+        of the parent and which are recorded in the list
+        ``self.parent()._invertible_elements``.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            sage: CR3.<e3> = SplittingAlgebra(cyclotomic_polynomial(3))
+            sage: ~e3
+            -e3 - 1
+            sage: ~(e3 + 5)
+            Traceback (most recent call last):
+            ...
+            ArithmeticError: element is non-invertible
+        """
+        inv_elements = self.parent()._invertible_elements
+        if self in inv_elements:
+            return inv_elements[self]
+
+        return super().__invert__()
+
+    def is_unit(self):
+        r"""
+        Return ``True`` if ``self`` is invertible.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            sage: CR3.<e3> = SplittingAlgebra(cyclotomic_polynomial(3))
+            sage: e3.is_unit()
+            True
+        """
+        inv_elements = self.parent()._invertible_elements
+        if self in inv_elements:
+            return True
+
+        return super().is_unit()
+
+    def monomial_coefficients(self, copy=True):
+        r"""
+        Return the dictionary of ``self`` according to its lift to the cover.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            sage: CR3.<e3> = SplittingAlgebra(cyclotomic_polynomial(3))
+            sage: f = e3 + 42
+            sage: f.monomial_coefficients()
+            {0: 42, 1: 1}
+
+        ``dict`` is an alias::
+
+            sage: f.dict()
+            {0: 42, 1: 1}
+        """
+        return self.lift().monomial_coefficients(copy=copy)
+
+    dict = monomial_coefficients
+
+# ------------------------------------------------------------------------------------------------------------------
+# Parent class of the splitting algebra
+# --------------------------------------------------------------------------------------------------------
+
+
+class SplittingAlgebra(PolynomialQuotientRing_domain):
+    r"""
+    For a given monic polynomial `p(t)` of degree `n` over a commutative
+    ring `R`, the splitting algebra is the universal `R`-algebra in which
+    `p(t)` has `n` roots, or, more precisely, over which `p(t)` factors,
+
+    .. MATH::
+
+        p(t) = (t - \xi_1) \cdots (t - \xi_n).
+
+    This class creates an algebra as extension over the base ring of a
+    given polynomial `p` such that `p` splits into linear factors over
+    that extension. It is assumed (and not checked in general) that the
+    Galois group of `p` is the symmetric Group `S(n)`. The construction
+    is recursive (following [LT2012]_, 1.3).
+
+    INPUT:
+
+    - ``monic_polynomial`` -- the monic polynomial which should be split
+    - ``names`` -- names for the indeterminates to be adjoined to the
+      base ring of ``monic_polynomial``
+    - ``warning`` -- boolean (default: ``True``); can be used (by setting to
+      ``False``) to suppress a warning which will be thrown whenever it cannot
+      be checked that the Galois group of ``monic_polynomial`` is maximal
+
+    EXAMPLES::
+
+        sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+        sage: Lc.<w> = LaurentPolynomialRing(ZZ)
+        sage: PabLc.<u,v> = Lc[]; t = polygen(PabLc)
+        sage: S.<x, y> = SplittingAlgebra(t^3 - u*t^2 + v*t - w)
+        doctest:...: UserWarning: Assuming x^3 - u*x^2 + v*x - w to have maximal
+                                  Galois group!
+
+        sage: roots = S.splitting_roots(); roots
+        [x, y, -y - x + u]
+        sage: all(t^3 -u*t^2 +v*t -w == 0 for t in roots)
+        True
+        sage: xi = ~x; xi
+        (w^-1)*x^2 + ((-w^-1)*u)*x + (w^-1)*v
+        sage: ~xi == x
+        True
+        sage: ~y
+        ((-w^-1)*x)*y + (-w^-1)*x^2 + ((w^-1)*u)*x
+        sage: zi = ((w^-1)*x)*y; ~zi
+        -y - x + u
+
+        sage: cp3 = cyclotomic_polynomial(3).change_ring(GF(5))
+        sage: CR3.<e3> = SplittingAlgebra(cp3)
+        sage: CR3.is_field()
+        True
+        sage: CR3.cardinality()
+        25
+        sage: F.<a> = cp3.splitting_field()
+        sage: F.cardinality()
+        25
+        sage: E3 = cp3.change_ring(F).roots()[0][0]; E3
+        3*a + 3
+        sage: f = CR3.hom([E3]); f
+        Ring morphism:
+          From: Splitting Algebra of x^2 + x + 1
+                with roots [e3, 4*e3 + 4]
+                over Finite Field of size 5
+          To:   Finite Field in a of size 5^2
+          Defn: e3 |--> 3*a + 3
+
+    REFERENCES:
+
+    - [EL2002]_
+    - [Lak2010]_
+    - [Tho2011]_
+    - [LT2012]_
+    """
+    Element = SplittingAlgebraElement
+
+    def __init__(self, monic_polynomial, names='X', iterate=True, warning=True):
+        r"""
+        Python constructor.
+
+        EXAMPLES::
+
+            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: 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)
+        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))
+
+        self._defining_polynomial = monic_polynomial
+        self._iterate = iterate
+
+        try:
+            if not base_ring.is_integral_domain():
+                raise TypeError("base_ring must be an integral domain")
+        except NotImplementedError:
+            from sage.categories.rings import Rings
+            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)
+
+        if deg < 1:
+            raise ValueError("the degree of the polynomial must positive")
+
+        self._splitting_roots = []
+        self._coefficients_list = []
+        self._invertible_elements = {}
+
+        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()
+
+        self._set_modulus_irreducible_ = False
+        try:
+            if not p.is_irreducible():
+                raise ValueError("monic_polynomial must be irreducible")
+        except (NotImplementedError, AttributeError):
+            # 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
+
+        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)
+            first_root = base_ring_step.gen()
+
+            verbose("base_ring_step %s defined:" % (base_ring_step))
+
+            # -------------------------------------------------------------
+            # splitting first root off
+            # -------------------------------------------------------------
+            from copy import copy
+            root_names_reduces = copy(root_names)
+            root_names_reduces.remove(root_name)
+
+            P = base_ring_step[root_names_reduces[0]]
+            p = P(monic_polynomial.monomial_coefficients())
+            q, _ = p.quo_rem(P.gen() - first_root)
+
+            verbose("Invoking recursion with: %s" % (q,))
+
+            SplittingAlgebra.__init__(self, q, root_names_reduces, warning=False)
+
+            splitting_roots = base_ring_step._splitting_roots + self._splitting_roots
+            coefficients_list = base_ring_step._coefficients_list + self._coefficients_list
+
+            verbose("Adding roots: %s" % (splitting_roots))
+
+            self._splitting_roots = splitting_roots
+            self._coefficients_list = coefficients_list
+        else:
+            PolynomialQuotientRing_domain.__init__(self, P, p, root_name)
+
+            first_root = self.gen()
+            self._splitting_roots.append(first_root)
+            self._coefficients_list = [monic_polynomial.coefficients(sparse=False)]
+
+            if not iterate:
+                verbose("pre ring defined splitting_roots: %s" % (self._splitting_roots))
+                return
+
+            verbose("final ring defined splitting_roots: %s" % (self._splitting_roots))
+
+        if deg == 2:
+            coefficients = monic_polynomial.coefficients(sparse=False)
+            lin_coeff = coefficients[1]
+            self._splitting_roots.append(-lin_coeff - first_root)
+
+        self._root_names = names
+        self._splitting_roots = [self(root) for root in self._splitting_roots]
+        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
+        # -----------------------------------------------------------------
+        # first find the polynomial with invertible constant coefficient
+        # -----------------------------------------------------------------
+        cf0_inv = None
+        for cf in self._coefficients_list:
+            cf0 = cf[0]
+            try:
+                cf0_inv = ~(cf[0])
+                cf0_inv = self(cf0_inv)
+                verbose("invertible coefficient: %s found" % (cf0_inv))
+                break
+            except NotImplementedError:
+                verbose("constant coefficient: %s not invertibe" % (cf0))
+
+        # ------------------------------------------------------------------
+        # assuming that cf splits into linear factors over self
+        # and the _splitting_roots are its roots we can calculate inverses
+        # ------------------------------------------------------------------
+        if cf0_inv is not None:
+            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
+                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})
+                verbose("adding inverse %s of root %s" % (root_inv, root))
+            invert_items = list(self._invertible_elements.items())
+            for k, v in invert_items:
+                self._invertible_elements.update({v: k})
+        return
+
+    ########################################################################
+    # ----------------------------------------------------------------------
+    # overloaded inherited methods
+    # ----------------------------------------------------------------------
+    ########################################################################
+    def __reduce__(self):
+        r"""
+        Used in pickling.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            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'>,
+            (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'>,
+            (Y^3 + (X - t)*Y^2 + (X^2 - t*X - u)*Y + X^3 - t*X^2 - u*X - v,
+            ('Y', 'Z'),
+            False,
+            False))
+
+            sage: TestSuite(S).run()
+        """
+        defining_polynomial = self.defining_polynomial()
+        definig_coefficients = self._coefficients_list[0]
+        if defining_polynomial.coefficients(sparse=False) != definig_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 _repr_(self):
+        r"""
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            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._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
+        """
+        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()))
+
+    def _first_ngens(self, n):
+        r"""
+        Used by the preparser for ``R.<x> = ...``.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            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
+            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]
+             over Multivariate Polynomial Ring in u, v over Integer Ring
+            sage: S._first_ngens(4)
+            (X, Y, u, v)
+        """
+        srts = self.splitting_roots()
+        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.
+
+        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(u + v)
+            u + v
+            sage: S(X*Y + X)
+            X*Y + X
+            sage: TestSuite(S).run()                   # indirect doctest
+        """
+        if isinstance(x, SplittingAlgebraElement):
+            # coercion from covering fixes pickling problems
+            return self(x.lift())
+        return super()._element_constructor_(x)
+
+    def hom(self, im_gens, codomain=None, check=True, base_map=None):
+        r"""
+        This version keeps track with the special recursive structure
+        of :class:`SplittingAlgebra`
+
+        Type ``Ring.hom?`` to see the general documentation of this method.
+        Here you see just special examples for the current class.
+
+        EXAMPLES::
+
+            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'))
+            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]]
+            sage: f = S.hom(im_gens)
+            sage: f(u), f(v), f(w)
+            (x + y + z, x*y + x*z + y*z, x*y*z)
+            sage: roots = S.splitting_roots(); roots
+            [X, Y, -Y - X + u]
+            sage: [f(r) for r in roots]
+            [x, y, z]
+        """
+        base_ring = self.base_ring()
+
+        if not isinstance(im_gens, (list, tuple)):
+            im_gens = [im_gens]
+
+        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)
+
+        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)
+
+        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)
+        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)
+        lift = self.lifting_map()
+        return hom_from_cover*lift
+
+    ###################################################################
+    # -----------------------------------------------------------------
+    # local methods
+    # -----------------------------------------------------------------
+    ###################################################################
+
+    ###################################################################
+    # -----------------------------------------------------------------
+    # global methods
+    # -----------------------------------------------------------------
+    ###################################################################
+
+    def is_completely_split(self):
+        r"""
+        Return ``True`` if the defining polynomial of ``self`` splits into
+        linear factors over ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            sage: L.<u, v, w > = LaurentPolynomialRing(ZZ); x = polygen(L)
+            sage: S.<a,b> = SplittingAlgebra(x^3 - u*x^2 + v*x - w)
+            sage: S.is_completely_split()
+            True
+            sage: S.base_ring().is_completely_split()
+            False
+        """
+        return len(self.splitting_roots()) >= self.defining_polynomial().degree()
+
+    @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`.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            sage: x = polygen(ZZ)
+            sage: S = SplittingAlgebra(x^2+1, ('I',))
+            sage: lift = S.lifting_map()
+            sage: lift(5)
+            5
+            sage: r1, r2 =S.splitting_roots()
+            sage: lift(r1)
+            I
+        """
+        from sage.rings.morphism import RingMap_lift
+        return RingMap_lift(self, self.cover_ring())
+
+    def splitting_roots(self):
+        r"""
+        Return the roots of the split equation.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            sage: x = polygen(ZZ)
+            sage: S = SplittingAlgebra(x^2+1, ('I',))
+            sage: S.splitting_roots()
+            [I, -I]
+        """
+        return self._splitting_roots
+
+    @cached_method
+    def scalar_base_ring(self):
+        r"""
+        Return the ring of scalars of ``self`` (considered as an algebra).
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            sage: L.<u, v, w > = LaurentPolynomialRing(ZZ)
+            sage: x = polygen(L)
+            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
+            sage: S.scalar_base_ring()
+            Multivariate Laurent Polynomial Ring in u, v, w over Integer Ring
+        """
+        base_ring = self.base_ring()
+        if isinstance(base_ring, SplittingAlgebra):
+            if base_ring.is_completely_split():
+                # another splitting algebra independent of self
+                return base_ring
+            else:
+                return base_ring.scalar_base_ring()
+        return base_ring
+
+    @cached_method
+    def defining_polynomial(self):
+        r"""
+        Return the defining polynomial of ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.algebras.splitting_algebra import SplittingAlgebra
+            sage: L.<u, v, w > = LaurentPolynomialRing(ZZ)
+            sage: x = polygen(L)
+            sage: S = SplittingAlgebra(x^3 - u*x^2 + v*x - w, ('X', 'Y'))
+            sage: S.defining_polynomial()
+            x^3 - u*x^2 + v*x - w
+        """
+        base_ring = self.base_ring()
+        if isinstance(base_ring, SplittingAlgebra):
+            if base_ring.is_completely_split():
+                # another splitting algebra independent of self
+                return self._defining_polynomial
+            else:
+                return base_ring.defining_polynomial()
+        return self._defining_polynomial
+
+
+# --------------------------------------------------------------------------------------------
+# ============================================================================================
+# 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):
+    r"""
+    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
+    - ``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
+      splitting field of the ``monic_polynomial`` (if necessary and possible)
+    - ``flatten`` -- boolean (default: ``True``); if ``True`` the roots will
+      not be given as a list of pairs ``(root, multiplicity)`` but as a list of
+      roots repeated according to their multiplicity
+    - ``warning`` -- boolean (default: ``True``); can be used (by setting to
+      ``False``) to suppress a warning which will be thrown whenever it cannot
+      be checked that the Galois group of ``monic_polynomial`` is maximal
+
+    OUTPUT:
+
+    List of tuples ``(root, multiplicity)`` respectively list of roots repeated
+    according to their multiplicity if option ``flatten`` is ``True``.
+
+    EXAMPLES::
+
+        sage: from sage.algebras.splitting_algebra import solve_with_extension
+        sage: t = polygen(ZZ)
+        sage: p = t^2 -2*t +1
+        sage: solve_with_extension(p, flatten=True )
+        [1, 1]
+        sage: solve_with_extension(p)
+        [(1, 2)]
+
+        sage: cp5 = cyclotomic_polynomial(5, var='T').change_ring(UniversalCyclotomicField())
+        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):
+        r"""
+        This internal function creates all roots of a polynomial in an
+        appropriate extension ring assuming that none of the roots is
+        contained its base ring.
+
+        It first tries to create the splitting field of the given polynomial.
+        If this is not faithful the splitting algebra will be created.
+
+        INPUT:
+
+        - ``monic_polynomial`` -- the monic polynomial whose roots should
+          be created
+        - ``warning`` -- boolean (default: ``True``); can be used (by setting
+          to ``False``) to suppress a warning which will be thrown whenever it
+          cannot be checked that the Galois group of ``monic_polynomial`` is
+          maximal
+        """
+        parent = monic_polynomial.parent()
+        base_ring = parent.base_ring()
+
+        try:
+            ext_field, embed = monic_polynomial.splitting_field(var, map=True)
+
+            if embed.domain() != base_ring:
+                # 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
+            # -------------------------------------------------------------------------------------
+            reset_coercion = False
+            from sage.rings.number_field.number_field import NumberField_generic
+            if isinstance(base_ring, NumberField_generic):
+                reset_coercion = True
+            elif base_ring.is_finite() and not base_ring.is_prime_field():
+                reset_coercion = True
+            if reset_coercion:
+                ext_field._unset_coercions_used()
+                ext_field.register_coercion(embed)
+                ext_field.register_conversion(embed)
+
+            verbose("splitting field %s defined" % (ext_field))
+            pol_emb = monic_polynomial.change_ring(ext_field)
+            roots = pol_emb.roots()
+        except NotImplementedError:
+            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
+
+    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')
+    name_list = list(root_names)
+    root_list = []
+    try:
+        root_list = monic_polynomial.roots()
+    except (TypeError, ValueError, NotImplementedError):
+        pass
+
+    if not root_list:
+        # --------------------------------------------------------------
+        # no roots found: find roots in an appropriate extension ring
+        # --------------------------------------------------------------
+        verbose("no roots in base_ring")
+        if len(name_list) > deg_pol - 1:
+            name_list = [name_list[i] for i in range(deg_pol - 1)]
+        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)
+        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)
+            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))
+            missing_roots = create_roots(q, warning=True)
+            roots = root_list + missing_roots
+        else:
+            roots = root_list
+            verbose("all roots in base ring")
+
+    if flatten:
+        from sage.misc.flatten import flatten
+        return flatten([[rt]*m for rt, m in roots])
+    return roots