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 PolynomialQuotientRing_domain.

AUTHORS:

• Sebastian Oehms (April 2020): initial version

class sage.algebras.splitting_algebra.SplittingAlgebra(monic_polynomial, names='X', iterate=True, warning=True)

Bases: PolynomialQuotientRing_domain

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,

\[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 – (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

alias of SplittingAlgebraElement

defining_polynomial()

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

hom(im_gens, codomain=None, check=True, base_map=None)

This version keeps track with the special recursive structure of 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]

is_completely_split()

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

lifting_map()

Return a section map from self to the cover ring. It is implemented according to the same named method of 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

scalar_base_ring()

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

splitting_roots()

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]

class sage.algebras.splitting_algebra.SplittingAlgebraElement(parent, polynomial, check=True)

Bases: PolynomialQuotientRingElement

Element class for 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'>

dict()

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: (e3 + 42).dict()
{0: 42, 1: 1}

is_unit()

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

sage.algebras.splitting_algebra.solve_with_extension(monic_polynomial, root_names=None, var='x', flatten=False, warning=True)

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 – (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 – (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