ai-content-maker/.venv/Lib/site-packages/sympy/polys/numberfields/galoisgroups.py

624 lines
20 KiB
Python

"""
Compute Galois groups of polynomials.
We use algorithms from [1], with some modifications to use lookup tables for
resolvents.
References
==========
.. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*.
"""
from collections import defaultdict
import random
from sympy.core.symbol import Dummy, symbols
from sympy.ntheory.primetest import is_square
from sympy.polys.domains import ZZ
from sympy.polys.densebasic import dup_random
from sympy.polys.densetools import dup_eval
from sympy.polys.euclidtools import dup_discriminant
from sympy.polys.factortools import dup_factor_list, dup_irreducible_p
from sympy.polys.numberfields.galois_resolvents import (
GaloisGroupException, get_resolvent_by_lookup, define_resolvents,
Resolvent,
)
from sympy.polys.numberfields.utilities import coeff_search
from sympy.polys.polytools import (Poly, poly_from_expr,
PolificationFailed, ComputationFailed)
from sympy.polys.sqfreetools import dup_sqf_p
from sympy.utilities import public
class MaxTriesException(GaloisGroupException):
...
def tschirnhausen_transformation(T, max_coeff=10, max_tries=30, history=None,
fixed_order=True):
r"""
Given a univariate, monic, irreducible polynomial over the integers, find
another such polynomial defining the same number field.
Explanation
===========
See Alg 6.3.4 of [1].
Parameters
==========
T : Poly
The given polynomial
max_coeff : int
When choosing a transformation as part of the process,
keep the coeffs between plus and minus this.
max_tries : int
Consider at most this many transformations.
history : set, None, optional (default=None)
Pass a set of ``Poly.rep``'s in order to prevent any of these
polynomials from being returned as the polynomial ``U`` i.e. the
transformation of the given polynomial *T*. The given poly *T* will
automatically be added to this set, before we try to find a new one.
fixed_order : bool, default True
If ``True``, work through candidate transformations A(x) in a fixed
order, from small coeffs to large, resulting in deterministic behavior.
If ``False``, the A(x) are chosen randomly, while still working our way
up from small coefficients to larger ones.
Returns
=======
Pair ``(A, U)``
``A`` and ``U`` are ``Poly``, ``A`` is the
transformation, and ``U`` is the transformed polynomial that defines
the same number field as *T*. The polynomial ``A`` maps the roots of
*T* to the roots of ``U``.
Raises
======
MaxTriesException
if could not find a polynomial before exceeding *max_tries*.
"""
X = Dummy('X')
n = T.degree()
if history is None:
history = set()
history.add(T.rep)
if fixed_order:
coeff_generators = {}
deg_coeff_sum = 3
current_degree = 2
def get_coeff_generator(degree):
gen = coeff_generators.get(degree, coeff_search(degree, 1))
coeff_generators[degree] = gen
return gen
for i in range(max_tries):
# We never use linear A(x), since applying a fixed linear transformation
# to all roots will only multiply the discriminant of T by a square
# integer. This will change nothing important. In particular, if disc(T)
# was zero before, it will still be zero now, and typically we apply
# the transformation in hopes of replacing T by a squarefree poly.
if fixed_order:
# If d is degree and c max coeff, we move through the dc-space
# along lines of constant sum. First d + c = 3 with (d, c) = (2, 1).
# Then d + c = 4 with (d, c) = (3, 1), (2, 2). Then d + c = 5 with
# (d, c) = (4, 1), (3, 2), (2, 3), and so forth. For a given (d, c)
# we go though all sets of coeffs where max = c, before moving on.
gen = get_coeff_generator(current_degree)
coeffs = next(gen)
m = max(abs(c) for c in coeffs)
if current_degree + m > deg_coeff_sum:
if current_degree == 2:
deg_coeff_sum += 1
current_degree = deg_coeff_sum - 1
else:
current_degree -= 1
gen = get_coeff_generator(current_degree)
coeffs = next(gen)
a = [ZZ(1)] + [ZZ(c) for c in coeffs]
else:
# We use a progressive coeff bound, up to the max specified, since it
# is preferable to succeed with smaller coeffs.
# Give each coeff bound five tries, before incrementing.
C = min(i//5 + 1, max_coeff)
d = random.randint(2, n - 1)
a = dup_random(d, -C, C, ZZ)
A = Poly(a, T.gen)
U = Poly(T.resultant(X - A), X)
if U.rep not in history and dup_sqf_p(U.rep.rep, ZZ):
return A, U
raise MaxTriesException
def has_square_disc(T):
"""Convenience to check if a Poly or dup has square discriminant. """
d = T.discriminant() if isinstance(T, Poly) else dup_discriminant(T, ZZ)
return is_square(d)
def _galois_group_degree_3(T, max_tries=30, randomize=False):
r"""
Compute the Galois group of a polynomial of degree 3.
Explanation
===========
Uses Prop 6.3.5 of [1].
"""
from sympy.combinatorics.galois import S3TransitiveSubgroups
return ((S3TransitiveSubgroups.A3, True) if has_square_disc(T)
else (S3TransitiveSubgroups.S3, False))
def _galois_group_degree_4_root_approx(T, max_tries=30, randomize=False):
r"""
Compute the Galois group of a polynomial of degree 4.
Explanation
===========
Follows Alg 6.3.7 of [1], using a pure root approximation approach.
"""
from sympy.combinatorics.permutations import Permutation
from sympy.combinatorics.galois import S4TransitiveSubgroups
X = symbols('X0 X1 X2 X3')
# We start by considering the resolvent for the form
# F = X0*X2 + X1*X3
# and the group G = S4. In this case, the stabilizer H is D4 = < (0123), (02) >,
# and a set of representatives of G/H is {I, (01), (03)}
F1 = X[0]*X[2] + X[1]*X[3]
s1 = [
Permutation(3),
Permutation(3)(0, 1),
Permutation(3)(0, 3)
]
R1 = Resolvent(F1, X, s1)
# In the second half of the algorithm (if we reach it), we use another
# form and set of coset representatives. However, we may need to permute
# them first, so cannot form their resolvent now.
F2_pre = X[0]*X[1]**2 + X[1]*X[2]**2 + X[2]*X[3]**2 + X[3]*X[0]**2
s2_pre = [
Permutation(3),
Permutation(3)(0, 2)
]
history = set()
for i in range(max_tries):
if i > 0:
# If we're retrying, need a new polynomial T.
_, T = tschirnhausen_transformation(T, max_tries=max_tries,
history=history,
fixed_order=not randomize)
R_dup, _, i0 = R1.eval_for_poly(T, find_integer_root=True)
# If R is not squarefree, must retry.
if not dup_sqf_p(R_dup, ZZ):
continue
# By Prop 6.3.1 of [1], Gal(T) is contained in A4 iff disc(T) is square.
sq_disc = has_square_disc(T)
if i0 is None:
# By Thm 6.3.3 of [1], Gal(T) is not conjugate to any subgroup of the
# stabilizer H = D4 that we chose. This means Gal(T) is either A4 or S4.
return ((S4TransitiveSubgroups.A4, True) if sq_disc
else (S4TransitiveSubgroups.S4, False))
# Gal(T) is conjugate to a subgroup of H = D4, so it is either V, C4
# or D4 itself.
if sq_disc:
# Neither C4 nor D4 is contained in A4, so Gal(T) must be V.
return (S4TransitiveSubgroups.V, True)
# Gal(T) can only be D4 or C4.
# We will now use our second resolvent, with G being that conjugate of D4 that
# Gal(T) is contained in. To determine the right conjugate, we will need
# the permutation corresponding to the integer root we found.
sigma = s1[i0]
# Applying sigma means permuting the args of F, and
# conjugating the set of coset representatives.
F2 = F2_pre.subs(zip(X, sigma(X)), simultaneous=True)
s2 = [sigma*tau*sigma for tau in s2_pre]
R2 = Resolvent(F2, X, s2)
R_dup, _, _ = R2.eval_for_poly(T)
d = dup_discriminant(R_dup, ZZ)
# If d is zero (R has a repeated root), must retry.
if d == 0:
continue
if is_square(d):
return (S4TransitiveSubgroups.C4, False)
else:
return (S4TransitiveSubgroups.D4, False)
raise MaxTriesException
def _galois_group_degree_4_lookup(T, max_tries=30, randomize=False):
r"""
Compute the Galois group of a polynomial of degree 4.
Explanation
===========
Based on Alg 6.3.6 of [1], but uses resolvent coeff lookup.
"""
from sympy.combinatorics.galois import S4TransitiveSubgroups
history = set()
for i in range(max_tries):
R_dup = get_resolvent_by_lookup(T, 0)
if dup_sqf_p(R_dup, ZZ):
break
_, T = tschirnhausen_transformation(T, max_tries=max_tries,
history=history,
fixed_order=not randomize)
else:
raise MaxTriesException
# Compute list L of degrees of irreducible factors of R, in increasing order:
fl = dup_factor_list(R_dup, ZZ)
L = sorted(sum([
[len(r) - 1] * e for r, e in fl[1]
], []))
if L == [6]:
return ((S4TransitiveSubgroups.A4, True) if has_square_disc(T)
else (S4TransitiveSubgroups.S4, False))
if L == [1, 1, 4]:
return (S4TransitiveSubgroups.C4, False)
if L == [2, 2, 2]:
return (S4TransitiveSubgroups.V, True)
assert L == [2, 4]
return (S4TransitiveSubgroups.D4, False)
def _galois_group_degree_5_hybrid(T, max_tries=30, randomize=False):
r"""
Compute the Galois group of a polynomial of degree 5.
Explanation
===========
Based on Alg 6.3.9 of [1], but uses a hybrid approach, combining resolvent
coeff lookup, with root approximation.
"""
from sympy.combinatorics.galois import S5TransitiveSubgroups
from sympy.combinatorics.permutations import Permutation
X5 = symbols("X0,X1,X2,X3,X4")
res = define_resolvents()
F51, _, s51 = res[(5, 1)]
F51 = F51.as_expr(*X5)
R51 = Resolvent(F51, X5, s51)
history = set()
reached_second_stage = False
for i in range(max_tries):
if i > 0:
_, T = tschirnhausen_transformation(T, max_tries=max_tries,
history=history,
fixed_order=not randomize)
R51_dup = get_resolvent_by_lookup(T, 1)
if not dup_sqf_p(R51_dup, ZZ):
continue
# First stage
# If we have not yet reached the second stage, then the group still
# might be S5, A5, or M20, so must test for that.
if not reached_second_stage:
sq_disc = has_square_disc(T)
if dup_irreducible_p(R51_dup, ZZ):
return ((S5TransitiveSubgroups.A5, True) if sq_disc
else (S5TransitiveSubgroups.S5, False))
if not sq_disc:
return (S5TransitiveSubgroups.M20, False)
# Second stage
reached_second_stage = True
# R51 must have an integer root for T.
# To choose our second resolvent, we need to know which conjugate of
# F51 is a root.
rounded_roots = R51.round_roots_to_integers_for_poly(T)
# These are integers, and candidates to be roots of R51.
# We find the first one that actually is a root.
for permutation_index, candidate_root in rounded_roots.items():
if not dup_eval(R51_dup, candidate_root, ZZ):
break
X = X5
F2_pre = X[0]*X[1]**2 + X[1]*X[2]**2 + X[2]*X[3]**2 + X[3]*X[4]**2 + X[4]*X[0]**2
s2_pre = [
Permutation(4),
Permutation(4)(0, 1)(2, 4)
]
i0 = permutation_index
sigma = s51[i0]
F2 = F2_pre.subs(zip(X, sigma(X)), simultaneous=True)
s2 = [sigma*tau*sigma for tau in s2_pre]
R2 = Resolvent(F2, X, s2)
R_dup, _, _ = R2.eval_for_poly(T)
d = dup_discriminant(R_dup, ZZ)
if d == 0:
continue
if is_square(d):
return (S5TransitiveSubgroups.C5, True)
else:
return (S5TransitiveSubgroups.D5, True)
raise MaxTriesException
def _galois_group_degree_5_lookup_ext_factor(T, max_tries=30, randomize=False):
r"""
Compute the Galois group of a polynomial of degree 5.
Explanation
===========
Based on Alg 6.3.9 of [1], but uses resolvent coeff lookup, plus
factorization over an algebraic extension.
"""
from sympy.combinatorics.galois import S5TransitiveSubgroups
_T = T
history = set()
for i in range(max_tries):
R_dup = get_resolvent_by_lookup(T, 1)
if dup_sqf_p(R_dup, ZZ):
break
_, T = tschirnhausen_transformation(T, max_tries=max_tries,
history=history,
fixed_order=not randomize)
else:
raise MaxTriesException
sq_disc = has_square_disc(T)
if dup_irreducible_p(R_dup, ZZ):
return ((S5TransitiveSubgroups.A5, True) if sq_disc
else (S5TransitiveSubgroups.S5, False))
if not sq_disc:
return (S5TransitiveSubgroups.M20, False)
# If we get this far, Gal(T) can only be D5 or C5.
# But for Gal(T) to have order 5, T must already split completely in
# the extension field obtained by adjoining a single one of its roots.
fl = Poly(_T, domain=ZZ.alg_field_from_poly(_T)).factor_list()[1]
if len(fl) == 5:
return (S5TransitiveSubgroups.C5, True)
else:
return (S5TransitiveSubgroups.D5, True)
def _galois_group_degree_6_lookup(T, max_tries=30, randomize=False):
r"""
Compute the Galois group of a polynomial of degree 6.
Explanation
===========
Based on Alg 6.3.10 of [1], but uses resolvent coeff lookup.
"""
from sympy.combinatorics.galois import S6TransitiveSubgroups
# First resolvent:
history = set()
for i in range(max_tries):
R_dup = get_resolvent_by_lookup(T, 1)
if dup_sqf_p(R_dup, ZZ):
break
_, T = tschirnhausen_transformation(T, max_tries=max_tries,
history=history,
fixed_order=not randomize)
else:
raise MaxTriesException
fl = dup_factor_list(R_dup, ZZ)
# Group the factors by degree.
factors_by_deg = defaultdict(list)
for r, _ in fl[1]:
factors_by_deg[len(r) - 1].append(r)
L = sorted(sum([
[d] * len(ff) for d, ff in factors_by_deg.items()
], []))
T_has_sq_disc = has_square_disc(T)
if L == [1, 2, 3]:
f1 = factors_by_deg[3][0]
return ((S6TransitiveSubgroups.C6, False) if has_square_disc(f1)
else (S6TransitiveSubgroups.D6, False))
elif L == [3, 3]:
f1, f2 = factors_by_deg[3]
any_square = has_square_disc(f1) or has_square_disc(f2)
return ((S6TransitiveSubgroups.G18, False) if any_square
else (S6TransitiveSubgroups.G36m, False))
elif L == [2, 4]:
if T_has_sq_disc:
return (S6TransitiveSubgroups.S4p, True)
else:
f1 = factors_by_deg[4][0]
return ((S6TransitiveSubgroups.A4xC2, False) if has_square_disc(f1)
else (S6TransitiveSubgroups.S4xC2, False))
elif L == [1, 1, 4]:
return ((S6TransitiveSubgroups.A4, True) if T_has_sq_disc
else (S6TransitiveSubgroups.S4m, False))
elif L == [1, 5]:
return ((S6TransitiveSubgroups.PSL2F5, True) if T_has_sq_disc
else (S6TransitiveSubgroups.PGL2F5, False))
elif L == [1, 1, 1, 3]:
return (S6TransitiveSubgroups.S3, False)
assert L == [6]
# Second resolvent:
history = set()
for i in range(max_tries):
R_dup = get_resolvent_by_lookup(T, 2)
if dup_sqf_p(R_dup, ZZ):
break
_, T = tschirnhausen_transformation(T, max_tries=max_tries,
history=history,
fixed_order=not randomize)
else:
raise MaxTriesException
T_has_sq_disc = has_square_disc(T)
if dup_irreducible_p(R_dup, ZZ):
return ((S6TransitiveSubgroups.A6, True) if T_has_sq_disc
else (S6TransitiveSubgroups.S6, False))
else:
return ((S6TransitiveSubgroups.G36p, True) if T_has_sq_disc
else (S6TransitiveSubgroups.G72, False))
@public
def galois_group(f, *gens, by_name=False, max_tries=30, randomize=False, **args):
r"""
Compute the Galois group for polynomials *f* up to degree 6.
Examples
========
>>> from sympy import galois_group
>>> from sympy.abc import x
>>> f = x**4 + 1
>>> G, alt = galois_group(f)
>>> print(G)
PermutationGroup([
(0 1)(2 3),
(0 2)(1 3)])
The group is returned along with a boolean, indicating whether it is
contained in the alternating group $A_n$, where $n$ is the degree of *T*.
Along with other group properties, this can help determine which group it
is:
>>> alt
True
>>> G.order()
4
Alternatively, the group can be returned by name:
>>> G_name, _ = galois_group(f, by_name=True)
>>> print(G_name)
S4TransitiveSubgroups.V
The group itself can then be obtained by calling the name's
``get_perm_group()`` method:
>>> G_name.get_perm_group()
PermutationGroup([
(0 1)(2 3),
(0 2)(1 3)])
Group names are values of the enum classes
:py:class:`sympy.combinatorics.galois.S1TransitiveSubgroups`,
:py:class:`sympy.combinatorics.galois.S2TransitiveSubgroups`,
etc.
Parameters
==========
f : Expr
Irreducible polynomial over :ref:`ZZ` or :ref:`QQ`, whose Galois group
is to be determined.
gens : optional list of symbols
For converting *f* to Poly, and will be passed on to the
:py:func:`~.poly_from_expr` function.
by_name : bool, default False
If ``True``, the Galois group will be returned by name.
Otherwise it will be returned as a :py:class:`~.PermutationGroup`.
max_tries : int, default 30
Make at most this many attempts in those steps that involve
generating Tschirnhausen transformations.
randomize : bool, default False
If ``True``, then use random coefficients when generating Tschirnhausen
transformations. Otherwise try transformations in a fixed order. Both
approaches start with small coefficients and degrees and work upward.
args : optional
For converting *f* to Poly, and will be passed on to the
:py:func:`~.poly_from_expr` function.
Returns
=======
Pair ``(G, alt)``
The first element ``G`` indicates the Galois group. It is an instance
of one of the :py:class:`sympy.combinatorics.galois.S1TransitiveSubgroups`
:py:class:`sympy.combinatorics.galois.S2TransitiveSubgroups`, etc. enum
classes if *by_name* was ``True``, and a :py:class:`~.PermutationGroup`
if ``False``.
The second element is a boolean, saying whether the group is contained
in the alternating group $A_n$ ($n$ the degree of *T*).
Raises
======
ValueError
if *f* is of an unsupported degree.
MaxTriesException
if could not complete before exceeding *max_tries* in those steps
that involve generating Tschirnhausen transformations.
See Also
========
.Poly.galois_group
"""
gens = gens or []
args = args or {}
try:
F, opt = poly_from_expr(f, *gens, **args)
except PolificationFailed as exc:
raise ComputationFailed('galois_group', 1, exc)
return F.galois_group(by_name=by_name, max_tries=max_tries,
randomize=randomize)