def create_key_and_extra_args(self,
order,
name=None,
modulus=None,
names=None,
impl=None,
proof=None,
**kwds):
"""
EXAMPLES::
sage: GF.create_key_and_extra_args(9, 'a')
((9, ('a',), 'conway', None, '{}', 3, 2, True), {})
sage: GF.create_key_and_extra_args(9, 'a', foo='value')
((9, ('a',), 'conway', None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'})
"""
from sage.structure.proof.all import WithProof, arithmetic
if proof is None: proof = arithmetic()
with WithProof('arithmetic', proof):
order = int(order)
if order <= 1:
raise ValueError("the order of a finite field must be > 1.")
if arith.is_prime(order):
name = None
modulus = None
p = integer.Integer(order)
n = integer.Integer(1)
elif arith.is_prime_power(order):
if not names is None: name = names
name = normalize_names(1, name)
p, n = arith.factor(order)[0]
if modulus is None or modulus == "default":
if exists_conway_polynomial(p, n):
modulus = "conway"
else:
if p == 2:
modulus = "minimal_weight"
else:
modulus = "random"
elif modulus == "random":
modulus += str(random.randint(0, 1 << 128))
if isinstance(modulus, (list, tuple)):
modulus = FiniteField(p)['x'](modulus)
# some classes use 'random' as the modulus to
# generate a random modulus, but we don't want
# to cache it
elif sage.rings.polynomial.polynomial_element.is_Polynomial(
modulus):
modulus = modulus.change_variable_name('x')
elif not isinstance(modulus, str):
raise ValueError("Modulus parameter not understood.")
else: # Neither a prime, nor a prime power
raise ValueError(
"the order of a finite field must be a prime power.")
return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def create_key_and_extra_args(self,
order,
name=None,
modulus=None,
names=None,
impl=None,
proof=None,
**kwds):
"""
EXAMPLES::
sage: GF.create_key_and_extra_args(9, 'a')
((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {})
sage: GF.create_key_and_extra_args(9, 'a', foo='value')
((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'})
"""
from sage.structure.proof.all import WithProof, arithmetic
if proof is None: proof = arithmetic()
with WithProof('arithmetic', proof):
order = int(order)
if order <= 1:
raise ValueError("the order of a finite field must be > 1.")
if arith.is_prime(order):
name = None
modulus = None
p = integer.Integer(order)
n = integer.Integer(1)
elif arith.is_prime_power(order):
if not names is None: name = names
name = normalize_names(1, name)
p, n = arith.factor(order)[0]
if modulus is None or isinstance(modulus, str):
# A string specifies an algorithm to find a suitable modulus.
if modulus == "default": # for backward compatibility
modulus = None
modulus = GF(p)['x'].irreducible_element(n,
algorithm=modulus)
elif isinstance(modulus, (list, tuple)):
modulus = GF(p)['x'](modulus)
elif sage.rings.polynomial.polynomial_element.is_Polynomial(
modulus):
modulus = modulus.change_variable_name('x')
else:
raise TypeError("wrong type for modulus parameter")
else:
raise ValueError(
"the order of a finite field must be a prime power.")
return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def other_keys(self, key, K):
"""
EXAMPLES::
sage: key, extra = GF.create_key_and_extra_args(9, 'a'); key
(9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True)
sage: K = GF.create_object(0, key); K
Finite Field in a of size 3^2
sage: GF.other_keys(key, K)
[(9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True),
(9, ('a',), x^2 + 2*x + 2, 'givaro', '{}', 3, 2, True)]
"""
if len(key) == 5: # backward compat
order, name, modulus, impl, _ = key
p, n = arith.factor(order)[0]
proof = True
else:
order, name, modulus, impl, _, p, n, proof = key
from sage.structure.proof.all import WithProof
with WithProof('arithmetic', proof):
if K.degree() > 1:
modulus = K.modulus().change_variable_name('x')
new_keys = [(order, name, modulus, impl, _, p, n, proof)]
from finite_field_prime_modn import FiniteField_prime_modn
if isinstance(K, FiniteField_prime_modn):
impl = 'modn'
elif isinstance(K, FiniteField_givaro):
impl = 'givaro'
else:
from finite_field_ntl_gf2e import FiniteField_ntl_gf2e
from finite_field_ext_pari import FiniteField_ext_pari
from finite_field_pari_ffelt import FiniteField_pari_ffelt
if isinstance(K, FiniteField_ntl_gf2e):
impl = 'ntl'
elif isinstance(K, FiniteField_ext_pari):
impl = 'pari_mod'
elif isinstance(K, FiniteField_pari_ffelt):
impl = 'pari_ffelt'
new_keys.append((order, name, modulus, impl, _, p, n, proof))
return new_keys
def create_object(self, version, key, **kwds):
"""
EXAMPLES::
sage: K = GF(19) # indirect doctest
sage: TestSuite(K).run()
We try to create finite fields with various implementations::
sage: k = GF(2, impl='modn')
sage: k = GF(2, impl='givaro')
sage: k = GF(2, impl='ntl')
sage: k = GF(2, impl='pari')
Traceback (most recent call last):
...
ValueError: the degree must be at least 2
sage: k = GF(2, impl='supercalifragilisticexpialidocious')
Traceback (most recent call last):
...
ValueError: no such finite field implementation: 'supercalifragilisticexpialidocious'
sage: k.<a> = GF(2^15, impl='modn')
Traceback (most recent call last):
...
ValueError: the 'modn' implementation requires a prime order
sage: k.<a> = GF(2^15, impl='givaro')
sage: k.<a> = GF(2^15, impl='ntl')
sage: k.<a> = GF(2^15, impl='pari')
sage: k.<a> = GF(3^60, impl='modn')
Traceback (most recent call last):
...
ValueError: the 'modn' implementation requires a prime order
sage: k.<a> = GF(3^60, impl='givaro')
Traceback (most recent call last):
...
ValueError: q must be < 2^16
sage: k.<a> = GF(3^60, impl='ntl')
Traceback (most recent call last):
...
ValueError: q must be a 2-power
sage: k.<a> = GF(3^60, impl='pari')
"""
# IMPORTANT! If you add a new class to the list of classes
# that get cached by this factor object, then you *must* add
# the following method to that class in order to fully support
# pickling:
#
# def __reduce__(self): # and include good doctests, please!
# return self._factory_data[0].reduce_data(self)
#
# This is not in the base class for finite fields, since some finite
# fields need not be created using this factory object, e.g., residue
# class fields.
if len(key) == 5:
# for backward compatibility of pickles (see trac 10975).
order, name, modulus, impl, _ = key
p, n = Integer(order).factor()[0]
proof = True
prefix = kwds.get('prefix', None)
# We can set the defaults here to be those for givaro
# as they are otherwise ignored
repr = 'poly'
elem_cache = (order < 500)
elif len(key) == 8:
# For backward compatibility of pickles (see trac #21433)
order, name, modulus, impl, _, p, n, proof = key
prefix = kwds.get('prefix', None)
# We can set the defaults here to be those for givaro
# as they are otherwise ignored
repr = kwds.get('repr', 'poly')
elem_cache = kwds.get('elem_cache', (order < 500))
else:
order, name, modulus, impl, p, n, proof, prefix, repr, elem_cache = key
if impl == 'modn':
if n != 1:
raise ValueError(
"the 'modn' implementation requires a prime order")
from .finite_field_prime_modn import FiniteField_prime_modn
# Using a check option here is probably a worthwhile
# compromise since this constructor is simple and used a
# huge amount.
K = FiniteField_prime_modn(order, check=False, modulus=modulus)
else:
# We have to do this with block so that the finite field
# constructors below will use the proof flag that was
# passed in when checking for primality, factoring, etc.
# Otherwise, we would have to complicate all of their
# constructors with check options.
from sage.structure.proof.all import WithProof
with WithProof('arithmetic', proof):
if impl == 'givaro':
K = FiniteField_givaro(order, name, modulus, repr,
elem_cache)
elif impl == 'ntl':
from .finite_field_ntl_gf2e import FiniteField_ntl_gf2e
K = FiniteField_ntl_gf2e(order, name, modulus)
elif impl == 'pari_ffelt' or impl == 'pari':
from .finite_field_pari_ffelt import FiniteField_pari_ffelt
K = FiniteField_pari_ffelt(p, modulus, name)
else:
raise ValueError(
"no such finite field implementation: %r" % impl)
# Temporary; see create_key_and_extra_args() above.
if prefix is not None:
K._prefix = prefix
return K
def create_key_and_extra_args(self,
order,
name=None,
modulus=None,
names=None,
impl=None,
proof=None,
check_irreducible=True,
prefix=None,
repr=None,
elem_cache=None,
**kwds):
"""
EXAMPLES::
sage: GF.create_key_and_extra_args(9, 'a')
((9, ('a',), x^2 + 2*x + 2, 'givaro', 3, 2, True, None, 'poly', True), {})
We do not take invalid keyword arguments and raise a value error
to better ensure uniqueness::
sage: GF.create_key_and_extra_args(9, 'a', foo='value')
Traceback (most recent call last):
...
TypeError: create_key_and_extra_args() got an unexpected keyword argument 'foo'
Moreover, ``repr`` and ``elem_cache`` are ignored when not
using givaro::
sage: GF.create_key_and_extra_args(16, 'a', impl='ntl', repr='poly')
((16, ('a',), x^4 + x + 1, 'ntl', 2, 4, True, None, None, None), {})
sage: GF.create_key_and_extra_args(16, 'a', impl='ntl', elem_cache=False)
((16, ('a',), x^4 + x + 1, 'ntl', 2, 4, True, None, None, None), {})
sage: GF(16, impl='ntl') is GF(16, impl='ntl', repr='foo')
True
We handle extra arguments for the givaro finite field and
create unique objects for their defaults::
sage: GF(25, impl='givaro') is GF(25, impl='givaro', repr='poly')
True
sage: GF(25, impl='givaro') is GF(25, impl='givaro', elem_cache=True)
True
sage: GF(625, impl='givaro') is GF(625, impl='givaro', elem_cache=False)
True
We explicitly take ``structure``, ``implementation`` and ``prec`` attributes
for compatibility with :class:`~sage.categories.pushout.AlgebraicExtensionFunctor`
but we ignore them as they are not used, see :trac:`21433`::
sage: GF.create_key_and_extra_args(9, 'a', structure=None)
((9, ('a',), x^2 + 2*x + 2, 'givaro', 3, 2, True, None, 'poly', True), {})
"""
import sage.arith.all
from sage.structure.proof.all import WithProof, arithmetic
if proof is None:
proof = arithmetic()
for key, val in kwds.items():
if key not in ['structure', 'implementation', 'prec', 'embedding']:
raise TypeError(
"create_key_and_extra_args() got an unexpected keyword argument '%s'"
% key)
if not (val is None
or isinstance(val, list) and all(c is None for c in val)):
raise NotImplementedError(
"ring extension with prescribed %s is not implemented" %
key)
with WithProof('arithmetic', proof):
order = Integer(order)
if order <= 1:
raise ValueError(
"the order of a finite field must be at least 2")
if order.is_prime():
p = order
n = Integer(1)
if impl is None:
impl = 'modn'
name = ('x', ) # Ignore name
# Every polynomial of degree 1 is irreducible
check_irreducible = False
elif order.is_prime_power():
if names is not None:
name = names
if name is not None:
name = normalize_names(1, name)
p, n = order.factor()[0]
if name is None:
if prefix is None:
prefix = 'z'
name = prefix + str(n)
if modulus is not None:
raise ValueError(
"no modulus may be specified if variable name not given"
)
# Fpbar will have a strong reference, since algebraic_closure caches its results,
# and the coefficients of modulus lie in GF(p)
Fpbar = GF(p).algebraic_closure(prefix)
# This will give a Conway polynomial if p,n is small enough to be in the database
# and a pseudo-Conway polynomial if it's not.
modulus = Fpbar._get_polynomial(n)
check_irreducible = False
if impl is None:
if order < zech_log_bound:
impl = 'givaro'
elif p == 2:
impl = 'ntl'
else:
impl = 'pari_ffelt'
else:
raise ValueError(
"the order of a finite field must be a prime power")
# Determine modulus.
# For the 'modn' implementation, we use the following
# optimization which we also need to avoid an infinite loop:
# a modulus of None is a shorthand for x-1.
if modulus is not None or impl != 'modn':
R = PolynomialRing(FiniteField(p), 'x')
if modulus is None:
modulus = R.irreducible_element(n)
if isinstance(modulus, str):
# A string specifies an algorithm to find a suitable modulus.
modulus = R.irreducible_element(n, algorithm=modulus)
else:
if sage.rings.polynomial.polynomial_element.is_Polynomial(
modulus):
modulus = modulus.change_variable_name('x')
modulus = R(modulus).monic()
if modulus.degree() != n:
raise ValueError(
"the degree of the modulus does not equal the degree of the field"
)
if check_irreducible and not modulus.is_irreducible():
raise ValueError(
"finite field modulus must be irreducible but it is not"
)
# If modulus is x - 1 for impl="modn", set it to None
if impl == 'modn' and modulus[0] == -1:
modulus = None
# Check extra arguments for givaro and setup their defaults
# TODO: ntl takes a repr, but ignores it
if impl == 'givaro':
if repr is None:
repr = 'poly'
if elem_cache is None:
elem_cache = (order < 500)
else:
# This has the effect of ignoring these keywords
repr = None
elem_cache = None
return (order, name, modulus, impl, p, n, proof, prefix, repr,
elem_cache), {}
def create_object(self,
version,
key,
check_irreducible=True,
elem_cache=None,
names=None,
**kwds):
"""
EXAMPLES::
sage: K = GF(19)
sage: TestSuite(K).run()
"""
# IMPORTANT! If you add a new class to the list of classes
# that get cached by this factor object, then you *must* add
# the following method to that class in order to fully support
# pickling:
#
# def __reduce__(self): # and include good doctests, please!
# return self._factory_data[0].reduce_data(self)
#
# This is not in the base class for finite fields, since some finite
# fields need not be created using this factory object, e.g., residue
# class fields.
if len(key) == 5:
# for backward compatibility of pickles (see trac 10975).
order, name, modulus, impl, _ = key
p, n = arith.factor(order)[0]
proof = True
else:
order, name, modulus, impl, _, p, n, proof = key
if isinstance(modulus, str) and modulus.startswith("random"):
modulus = "random"
if elem_cache is None:
elem_cache = order < 500
if n == 1 and (impl is None or impl == 'modn'):
from finite_field_prime_modn import FiniteField_prime_modn
# Using a check option here is probably a worthwhile
# compromise since this constructor is simple and used a
# huge amount.
K = FiniteField_prime_modn(order, check=False, **kwds)
else:
# We have to do this with block so that the finite field
# constructors below will use the proof flag that was
# passed in when checking for primality, factoring, etc.
# Otherwise, we would have to complicate all of their
# constructors with check options (like above).
from sage.structure.proof.all import WithProof
with WithProof('arithmetic', proof):
if check_irreducible and polynomial_element.is_Polynomial(
modulus):
if modulus.parent().base_ring().characteristic() == 0:
modulus = modulus.change_ring(FiniteField(p))
if not modulus.is_irreducible():
raise ValueError(
"finite field modulus must be irreducible but it is not."
)
if modulus.degree() != n:
raise ValueError(
"The degree of the modulus does not correspond to the cardinality of the field."
)
if name is None:
raise TypeError("you must specify the generator name.")
if order < zech_log_bound:
# DO *NOT* use for prime subfield, since that would lead to
# a circular reference in the call to ParentWithGens in the
# __init__ method.
K = FiniteField_givaro(order,
name,
modulus,
cache=elem_cache,
**kwds)
else:
if order % 2 == 0 and (impl is None or impl == 'ntl'):
from element_ntl_gf2e import FiniteField_ntl_gf2e
K = FiniteField_ntl_gf2e(order, name, modulus, **kwds)
else:
from finite_field_ext_pari import FiniteField_ext_pari
K = FiniteField_ext_pari(order, name, modulus, **kwds)
return K
def create_key_and_extra_args(self,
order,
name=None,
modulus=None,
names=None,
impl=None,
proof=None,
**kwds):
"""
EXAMPLES::
sage: GF.create_key_and_extra_args(9, 'a')
((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {})
sage: GF.create_key_and_extra_args(9, 'a', foo='value')
((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'})
"""
from sage.structure.proof.all import WithProof, arithmetic
if proof is None: proof = arithmetic()
with WithProof('arithmetic', proof):
order = int(order)
if order <= 1:
raise ValueError("the order of a finite field must be > 1.")
if arith.is_prime(order):
name = None
modulus = None
p = integer.Integer(order)
n = integer.Integer(1)
elif arith.is_prime_power(order):
if not names is None: name = names
name = normalize_names(1, name)
p, n = arith.factor(order)[0]
# The following is a temporary solution that allows us
# to construct compatible systems of finite fields
# until algebraic closures of finite fields are
# implemented in Sage. It requires the user to
# specify two parameters:
#
# - `conway` -- boolean; if True, this field is
# constructed to fit in a compatible system using
# a Conway polynomial.
# - `prefix` -- a string used to generate names for
# automatically constructed finite fields
#
# See the docstring of FiniteFieldFactory for examples.
#
# Once algebraic closures of finite fields are
# implemented, this syntax should be superseded by
# something like the following:
#
# sage: Fpbar = GF(5).algebraic_closure('z')
# sage: F, e = Fpbar.subfield(3) # e is the embedding into Fpbar
# sage: F
# Finite field in z3 of size 5^3
#
# This temporary solution only uses actual Conway
# polynomials (no pseudo-Conway polynomials), since
# pseudo-Conway polynomials are not unique, and until
# we have algebraic closures of finite fields, there
# is no good place to store a specific choice of
# pseudo-Conway polynomials.
if name is None:
if not (kwds.has_key('conway') and kwds['conway']):
raise ValueError(
"parameter 'conway' is required if no name given")
if not kwds.has_key('prefix'):
raise ValueError(
"parameter 'prefix' is required if no name given")
name = kwds['prefix'] + str(n)
if kwds.has_key('conway') and kwds['conway']:
from conway_polynomials import conway_polynomial
if not kwds.has_key('prefix'):
raise ValueError(
"a prefix must be specified if conway=True")
if modulus is not None:
raise ValueError(
"no modulus may be specified if conway=True")
# The following raises a RuntimeError if no polynomial is found.
modulus = conway_polynomial(p, n)
if modulus is None or isinstance(modulus, str):
# A string specifies an algorithm to find a suitable modulus.
if modulus == "default": # for backward compatibility
modulus = None
modulus = GF(p)['x'].irreducible_element(n,
algorithm=modulus)
elif isinstance(modulus, (list, tuple)):
modulus = GF(p)['x'](modulus)
elif sage.rings.polynomial.polynomial_element.is_Polynomial(
modulus):
modulus = modulus.change_variable_name('x')
else:
raise TypeError("wrong type for modulus parameter")
else:
raise ValueError(
"the order of a finite field must be a prime power.")
return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def create_key_and_extra_args(self,
order,
name=None,
modulus=None,
names=None,
impl=None,
proof=None,
check_irreducible=True,
**kwds):
"""
EXAMPLES::
sage: GF.create_key_and_extra_args(9, 'a')
((9, ('a',), x^2 + 2*x + 2, 'givaro', '{}', 3, 2, True), {})
sage: GF.create_key_and_extra_args(9, 'a', foo='value')
((9, ('a',), x^2 + 2*x + 2, 'givaro', "{'foo': 'value'}", 3, 2, True), {'foo': 'value'})
"""
import sage.arith.all
from sage.structure.proof.all import WithProof, arithmetic
if proof is None:
proof = arithmetic()
with WithProof('arithmetic', proof):
order = Integer(order)
if order <= 1:
raise ValueError(
"the order of a finite field must be at least 2")
if order.is_prime():
p = order
n = Integer(1)
if impl is None:
impl = 'modn'
name = ('x', ) # Ignore name
# Every polynomial of degree 1 is irreducible
check_irreducible = False
elif order.is_prime_power():
if names is not None:
name = names
if name is not None:
name = normalize_names(1, name)
p, n = order.factor()[0]
# The following is a temporary solution that allows us
# to construct compatible systems of finite fields
# until algebraic closures of finite fields are
# implemented in Sage. It requires the user to
# specify two parameters:
#
# - `conway` -- boolean; if True, this field is
# constructed to fit in a compatible system using
# a Conway polynomial.
# - `prefix` -- a string used to generate names for
# automatically constructed finite fields
#
# See the docstring of FiniteFieldFactory for examples.
#
# Once algebraic closures of finite fields are
# implemented, this syntax should be superseded by
# something like the following:
#
# sage: Fpbar = GF(5).algebraic_closure('z')
# sage: F, e = Fpbar.subfield(3) # e is the embedding into Fpbar
# sage: F
# Finite field in z3 of size 5^3
#
# This temporary solution only uses actual Conway
# polynomials (no pseudo-Conway polynomials), since
# pseudo-Conway polynomials are not unique, and until
# we have algebraic closures of finite fields, there
# is no good place to store a specific choice of
# pseudo-Conway polynomials.
if name is None:
if not ('conway' in kwds and kwds['conway']):
raise ValueError(
"parameter 'conway' is required if no name given")
if 'prefix' not in kwds:
raise ValueError(
"parameter 'prefix' is required if no name given")
name = kwds['prefix'] + str(n)
if 'conway' in kwds and kwds['conway']:
from conway_polynomials import conway_polynomial
if 'prefix' not in kwds:
raise ValueError(
"a prefix must be specified if conway=True")
if modulus is not None:
raise ValueError(
"no modulus may be specified if conway=True")
# The following raises a RuntimeError if no polynomial is found.
modulus = conway_polynomial(p, n)
if impl is None:
if order < zech_log_bound:
impl = 'givaro'
elif p == 2:
impl = 'ntl'
else:
impl = 'pari_ffelt'
else:
raise ValueError(
"the order of a finite field must be a prime power")
# Determine modulus.
# For the 'modn' implementation, we use the following
# optimization which we also need to avoid an infinite loop:
# a modulus of None is a shorthand for x-1.
if modulus is not None or impl != 'modn':
R = PolynomialRing(FiniteField(p), 'x')
if modulus is None:
modulus = R.irreducible_element(n)
if isinstance(modulus, str):
# A string specifies an algorithm to find a suitable modulus.
if modulus == "default":
from sage.misc.superseded import deprecation
deprecation(
16983,
"the modulus 'default' is deprecated, use modulus=None instead (which is the default)"
)
modulus = None
modulus = R.irreducible_element(n, algorithm=modulus)
else:
if sage.rings.polynomial.polynomial_element.is_Polynomial(
modulus):
modulus = modulus.change_variable_name('x')
modulus = R(modulus).monic()
if modulus.degree() != n:
raise ValueError(
"the degree of the modulus does not equal the degree of the field"
)
if check_irreducible and not modulus.is_irreducible():
raise ValueError(
"finite field modulus must be irreducible but it is not"
)
# If modulus is x - 1 for impl="modn", set it to None
if impl == 'modn' and modulus[0] == -1:
modulus = None
return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def create_key_and_extra_args(self,
order,
name=None,
modulus=None,
names=None,
impl=None,
proof=None,
check_irreducible=True,
**kwds):
"""
EXAMPLES::
sage: GF.create_key_and_extra_args(9, 'a')
((9, ('a',), x^2 + 2*x + 2, 'givaro', '{}', 3, 2, True), {})
sage: GF.create_key_and_extra_args(9, 'a', foo='value')
((9, ('a',), x^2 + 2*x + 2, 'givaro', "{'foo': 'value'}", 3, 2, True), {'foo': 'value'})
"""
import sage.arith.all
from sage.structure.proof.all import WithProof, arithmetic
if proof is None:
proof = arithmetic()
with WithProof('arithmetic', proof):
order = Integer(order)
if order <= 1:
raise ValueError(
"the order of a finite field must be at least 2")
if order.is_prime():
p = order
n = Integer(1)
if impl is None:
impl = 'modn'
name = ('x', ) # Ignore name
# Every polynomial of degree 1 is irreducible
check_irreducible = False
elif order.is_prime_power():
if names is not None:
name = names
if name is not None:
name = normalize_names(1, name)
p, n = order.factor()[0]
if name is None:
if 'prefix' not in kwds:
kwds['prefix'] = 'z'
name = kwds['prefix'] + str(n)
if modulus is not None:
raise ValueError(
"no modulus may be specified if variable name not given"
)
if 'conway' in kwds:
del kwds['conway']
from sage.misc.superseded import deprecation
deprecation(
17569,
"the 'conway' argument is deprecated, pseudo-conway polynomials are now used by default if no variable name is given"
)
# Fpbar will have a strong reference, since algebraic_closure caches its results,
# and the coefficients of modulus lie in GF(p)
Fpbar = GF(p).algebraic_closure(kwds.get('prefix', 'z'))
# This will give a Conway polynomial if p,n is small enough to be in the database
# and a pseudo-Conway polynomial if it's not.
modulus = Fpbar._get_polynomial(n)
check_irreducible = False
if impl is None:
if order < zech_log_bound:
impl = 'givaro'
elif p == 2:
impl = 'ntl'
else:
impl = 'pari_ffelt'
else:
raise ValueError(
"the order of a finite field must be a prime power")
# Determine modulus.
# For the 'modn' implementation, we use the following
# optimization which we also need to avoid an infinite loop:
# a modulus of None is a shorthand for x-1.
if modulus is not None or impl != 'modn':
R = PolynomialRing(FiniteField(p), 'x')
if modulus is None:
modulus = R.irreducible_element(n)
if isinstance(modulus, str):
# A string specifies an algorithm to find a suitable modulus.
if modulus == "default":
from sage.misc.superseded import deprecation
deprecation(
16983,
"the modulus 'default' is deprecated, use modulus=None instead (which is the default)"
)
modulus = None
modulus = R.irreducible_element(n, algorithm=modulus)
else:
if sage.rings.polynomial.polynomial_element.is_Polynomial(
modulus):
modulus = modulus.change_variable_name('x')
modulus = R(modulus).monic()
if modulus.degree() != n:
raise ValueError(
"the degree of the modulus does not equal the degree of the field"
)
if check_irreducible and not modulus.is_irreducible():
raise ValueError(
"finite field modulus must be irreducible but it is not"
)
# If modulus is x - 1 for impl="modn", set it to None
if impl == 'modn' and modulus[0] == -1:
modulus = None
return (order, name, modulus, impl, str(kwds), p, n, proof), kwds