def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Initialize ``self``.
EXAMPLES::
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(GF(2^3, 'a')).run()
"""
self._kwargs = {}
if repr not in ['int', 'log', 'poly']:
raise ValueError, "Unknown representation %s" % repr
q = Integer(q)
if q < 2:
raise ValueError, "q must be a prime power"
F = q.factor()
if len(F) > 1:
raise ValueError, "q must be a prime power"
p = F[0][0]
k = F[0][1]
if q >= 1 << 16:
raise ValueError, "q must be < 2^16"
import constructor
FiniteField.__init__(self,
constructor.FiniteField(p),
name,
normalize=False)
self._kwargs['repr'] = repr
self._kwargs['cache'] = cache
self._is_conway = False
if modulus is None or modulus == 'conway':
if k == 1:
modulus = 'random' # this will use the gfq_factory_pk function.
elif ConwayPolynomials().has_polynomial(p, k):
from sage.rings.finite_rings.constructor import conway_polynomial
modulus = conway_polynomial(p, k)
self._is_conway = True
elif modulus is None:
modulus = 'random'
else:
raise ValueError, "Conway polynomial not found"
from sage.rings.polynomial.all import is_Polynomial
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Initialize ``self``.
EXAMPLES::
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(GF(2^3, 'a')).run()
"""
self._kwargs = {}
if repr not in ["int", "log", "poly"]:
raise ValueError, "Unknown representation %s" % repr
q = Integer(q)
if q < 2:
raise ValueError, "q must be a prime power"
F = q.factor()
if len(F) > 1:
raise ValueError, "q must be a prime power"
p = F[0][0]
k = F[0][1]
if q >= 1 << 16:
raise ValueError, "q must be < 2^16"
import constructor
FiniteField.__init__(self, constructor.FiniteField(p), name, normalize=False)
self._kwargs["repr"] = repr
self._kwargs["cache"] = cache
self._is_conway = False
if modulus is None or modulus == "conway":
if k == 1:
modulus = "random" # this will use the gfq_factory_pk function.
elif ConwayPolynomials().has_polynomial(p, k):
from sage.rings.finite_rings.constructor import conway_polynomial
modulus = conway_polynomial(p, k)
self._is_conway = True
elif modulus is None:
modulus = "random"
else:
raise ValueError, "Conway polynomial not found"
from sage.rings.polynomial.all import is_Polynomial
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
def __init__(self, q, names="a", modulus=None, repr="poly"):
"""
Initialize ``self``.
TESTS::
sage: k.<a> = GF(2^100, modulus='strangeinput')
Traceback (most recent call last):
...
ValueError: no such algorithm for finding an irreducible polynomial: strangeinput
sage: k.<a> = GF(2^20) ; type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: loads(dumps(k)) is k
True
sage: k1.<a> = GF(2^16)
sage: k2.<a> = GF(2^17)
sage: k1 == k2
False
sage: k3.<a> = GF(2^16, impl="pari_ffelt")
sage: k1 == k3
False
sage: TestSuite(k).run()
sage: k.<a> = GF(2^64)
sage: k._repr_option('element_is_atomic')
False
sage: P.<x> = PolynomialRing(k)
sage: (a+1)*x # indirect doctest
(a + 1)*x
"""
late_import()
q = Integer(q)
if q < 2:
raise ValueError("q must be a 2-power")
k = q.exact_log(2)
if q != 1 << k:
raise ValueError("q must be a 2-power")
FiniteField.__init__(self, GF2, names, normalize=True)
self._kwargs = {'repr': repr}
from sage.rings.polynomial.polynomial_element import is_Polynomial
if not is_Polynomial(modulus):
from sage.misc.superseded import deprecation
deprecation(
16983,
"constructing a FiniteField_ntl_gf2e without giving a polynomial as modulus is deprecated, use the more general FiniteField constructor instead"
)
R = GF2['x']
if modulus is None or isinstance(modulus, str):
modulus = R.irreducible_element(k, algorithm=modulus)
else:
modulus = R(modulus)
self._cache = Cache_ntl_gf2e(self, k, modulus)
self._modulus = modulus
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Initialize ``self``.
EXAMPLES::
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(GF(2^3, 'a')).run()
"""
self._kwargs = {}
if repr not in ["int", "log", "poly"]:
raise ValueError("Unknown representation %s" % repr)
q = Integer(q)
if q < 2:
raise ValueError("q must be a prime power")
F = q.factor()
if len(F) > 1:
raise ValueError("q must be a prime power")
p = F[0][0]
k = F[0][1]
if q >= 1 << 16:
raise ValueError("q must be < 2^16")
from .finite_field_constructor import GF
FiniteField.__init__(self, GF(p), name, normalize=False)
self._kwargs["repr"] = repr
self._kwargs["cache"] = cache
from sage.rings.polynomial.polynomial_element import is_Polynomial
if not is_Polynomial(modulus):
from sage.misc.superseded import deprecation
deprecation(
16930,
"constructing a FiniteField_givaro without giving a polynomial as modulus is deprecated, use the more general FiniteField constructor instead",
)
R = GF(p)["x"]
if modulus is None or isinstance(modulus, str):
modulus = R.irreducible_element(k, algorithm=modulus)
else:
modulus = R(modulus)
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
self._modulus = modulus
def __init__(self, q, names="a", modulus=None, repr="poly"):
"""
Initialize ``self``.
TESTS::
sage: k.<a> = GF(2^100, modulus='strangeinput')
Traceback (most recent call last):
...
ValueError: Modulus parameter not understood
sage: k.<a> = GF(2^20) ; type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: loads(dumps(k)) is k
True
sage: k1.<a> = GF(2^16)
sage: k2.<a> = GF(2^17)
sage: k1 == k2
False
sage: k3 = k1._finite_field_ext_pari_()
sage: k1 == k3
False
sage: TestSuite(k).run()
sage: k.<a> = GF(2^64)
sage: k._repr_option('element_is_atomic')
False
sage: P.<x> = PolynomialRing(k)
sage: (a+1)*x # indirect doctest
(a + 1)*x
"""
late_import()
q = Integer(q)
if q < 2:
raise ValueError("q must be a 2-power")
k = q.exact_log(2)
if q != 1 << k:
raise ValueError("q must be a 2-power")
p = Integer(2)
FiniteField.__init__(self, GF(p), names, normalize=True)
self._kwargs = {'repr': repr}
self._is_conway = False
if modulus is None or modulus == 'default':
if exists_conway_polynomial(p, k):
modulus = "conway"
else:
modulus = "minimal_weight"
if modulus == "conway":
modulus = conway_polynomial(p, k)
self._is_conway = True
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_ntl_gf2e(self, k, modulus)
self._polynomial = {}
def __init__(self, q, names="a", modulus=None, repr="poly"):
"""
Initialize ``self``.
TESTS::
sage: k.<a> = GF(2^100, modulus='strangeinput')
Traceback (most recent call last):
...
ValueError: Modulus parameter not understood
sage: k.<a> = GF(2^20) ; type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: loads(dumps(k)) is k
True
sage: k1.<a> = GF(2^16)
sage: k2.<a> = GF(2^17)
sage: k1 == k2
False
sage: k3 = k1._finite_field_ext_pari_()
sage: k1 == k3
False
sage: TestSuite(k).run()
sage: k.<a> = GF(2^64)
sage: k._repr_option('element_is_atomic')
False
sage: P.<x> = PolynomialRing(k)
sage: (a+1)*x # indirect doctest
(a + 1)*x
"""
late_import()
q = Integer(q)
if q < 2:
raise ValueError("q must be a 2-power")
k = q.exact_log(2)
if q != 1 << k:
raise ValueError("q must be a 2-power")
p = Integer(2)
FiniteField.__init__(self, GF(p), names, normalize=True)
self._kwargs = {'repr':repr}
self._is_conway = False
if modulus is None or modulus == 'default':
if exists_conway_polynomial(p, k):
modulus = "conway"
else:
modulus = "minimal_weight"
if modulus == "conway":
modulus = conway_polynomial(p, k)
self._is_conway = True
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_ntl_gf2e(self, k, modulus)
self._polynomial = {}
def __init__(self, q, names="a", modulus=None, repr="poly"):
"""
Initialize ``self``.
TESTS::
sage: k.<a> = GF(2^100, modulus='strangeinput')
Traceback (most recent call last):
...
ValueError: no such algorithm for finding an irreducible polynomial: strangeinput
sage: k.<a> = GF(2^20) ; type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: loads(dumps(k)) is k
True
sage: k1.<a> = GF(2^16)
sage: k2.<a> = GF(2^17)
sage: k1 == k2
False
sage: k3.<a> = GF(2^16, impl="pari_ffelt")
sage: k1 == k3
False
sage: TestSuite(k).run()
sage: k.<a> = GF(2^64)
sage: k._repr_option('element_is_atomic')
False
sage: P.<x> = PolynomialRing(k)
sage: (a+1)*x # indirect doctest
(a + 1)*x
"""
late_import()
q = Integer(q)
if q < 2:
raise ValueError("q must be a 2-power")
k = q.exact_log(2)
if q != 1 << k:
raise ValueError("q must be a 2-power")
FiniteField.__init__(self, GF2, names, normalize=True)
self._kwargs = {'repr':repr}
from sage.rings.polynomial.polynomial_element import is_Polynomial
if not is_Polynomial(modulus):
from sage.misc.superseded import deprecation
deprecation(16983, "constructing a FiniteField_ntl_gf2e without giving a polynomial as modulus is deprecated, use the more general FiniteField constructor instead")
R = GF2['x']
if modulus is None or isinstance(modulus, str):
modulus = R.irreducible_element(k, algorithm=modulus)
else:
modulus = R(modulus)
self._cache = Cache_ntl_gf2e(self, k, modulus)
self._modulus = modulus
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Initialize ``self``.
EXAMPLES::
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(GF(2^3, 'a')).run()
"""
self._kwargs = {}
if repr not in ['int', 'log', 'poly']:
raise ValueError("Unknown representation %s"%repr)
q = Integer(q)
if q < 2:
raise ValueError("q must be a prime power")
F = q.factor()
if len(F) > 1:
raise ValueError("q must be a prime power")
p = F[0][0]
k = F[0][1]
if q >= 1<<16:
raise ValueError("q must be < 2^16")
import constructor
FiniteField.__init__(self, constructor.FiniteField(p), name, normalize=False)
self._kwargs['repr'] = repr
self._kwargs['cache'] = cache
if modulus is None or modulus == 'conway':
if k == 1:
modulus = 'random' # this will use the gfq_factory_pk function.
elif ConwayPolynomials().has_polynomial(p, k):
from sage.rings.finite_rings.conway_polynomials import conway_polynomial
modulus = conway_polynomial(p, k)
elif modulus is None:
modulus = 'random'
else:
raise ValueError("Conway polynomial not found")
from sage.rings.polynomial.polynomial_element import is_Polynomial
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Initialize ``self``.
EXAMPLES::
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(GF(2^3, 'a')).run()
"""
self._kwargs = {}
if repr not in ['int', 'log', 'poly']:
raise ValueError("Unknown representation %s" % repr)
q = Integer(q)
if q < 2:
raise ValueError("q must be a prime power")
F = q.factor()
if len(F) > 1:
raise ValueError("q must be a prime power")
p = F[0][0]
k = F[0][1]
if q >= 1 << 16:
raise ValueError("q must be < 2^16")
from .finite_field_constructor import GF
FiniteField.__init__(self, GF(p), name, normalize=False)
self._kwargs['repr'] = repr
self._kwargs['cache'] = cache
from sage.rings.polynomial.polynomial_element import is_Polynomial
if not is_Polynomial(modulus):
from sage.misc.superseded import deprecation
deprecation(
16930,
"constructing a FiniteField_givaro without giving a polynomial as modulus is deprecated, use the more general FiniteField constructor instead"
)
R = GF(p)['x']
if modulus is None or isinstance(modulus, str):
modulus = R.irreducible_element(k, algorithm=modulus)
else:
modulus = R(modulus)
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
self._modulus = modulus
def __init__(self, q, names="a", modulus=None, repr="poly"):
"""
Initialize ``self``.
TESTS::
sage: k.<a> = GF(2^100, modulus='strangeinput')
Traceback (most recent call last):
...
ValueError: no such algorithm for finding an irreducible polynomial: strangeinput
sage: k.<a> = GF(2^20) ; type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: loads(dumps(k)) is k
True
sage: k1.<a> = GF(2^16)
sage: k2.<a> = GF(2^17)
sage: k1 == k2
False
sage: k3.<a> = GF(2^16, impl="pari_ffelt")
sage: k1 == k3
False
sage: TestSuite(k).run()
sage: k.<a> = GF(2^64)
sage: k._repr_option('element_is_atomic')
False
sage: P.<x> = PolynomialRing(k)
sage: (a+1)*x # indirect doctest
(a + 1)*x
"""
late_import()
q = Integer(q)
if q < 2:
raise ValueError("q must be a 2-power")
k = q.exact_log(2)
if q != 1 << k:
raise ValueError("q must be a 2-power")
FiniteField.__init__(self, GF2, names, normalize=True)
from sage.rings.polynomial.polynomial_element import is_Polynomial
if not is_Polynomial(modulus):
raise TypeError("modulus must be a polynomial")
self._cache = Cache_ntl_gf2e(self, k, modulus)
self._modulus = modulus
def __init__(self, q, names="a", modulus=None, repr="poly"):
"""
Initialize ``self``.
TESTS::
sage: k.<a> = GF(2^100, modulus='strangeinput')
Traceback (most recent call last):
...
ValueError: no such algorithm for finding an irreducible polynomial: strangeinput
sage: k.<a> = GF(2^20) ; type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: loads(dumps(k)) is k
True
sage: k1.<a> = GF(2^16)
sage: k2.<a> = GF(2^17)
sage: k1 == k2
False
sage: k3.<a> = GF(2^16, impl="pari_ffelt")
sage: k1 == k3
False
sage: TestSuite(k).run()
sage: k.<a> = GF(2^64)
sage: k._repr_option('element_is_atomic')
False
sage: P.<x> = PolynomialRing(k)
sage: (a+1)*x # indirect doctest
(a + 1)*x
"""
late_import()
q = Integer(q)
if q < 2:
raise ValueError("q must be a 2-power")
k = q.exact_log(2)
if q != 1 << k:
raise ValueError("q must be a 2-power")
FiniteField.__init__(self, GF2, names, normalize=True)
from sage.rings.polynomial.polynomial_element import is_Polynomial
if not is_Polynomial(modulus):
raise TypeError("modulus must be a polynomial")
self._cache = Cache_ntl_gf2e(self, k, modulus)
self._modulus = modulus
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Initialize ``self``.
EXAMPLES::
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(GF(2^3, 'a')).run()
"""
if repr not in ['int', 'log', 'poly']:
raise ValueError("Unknown representation %s"%repr)
q = Integer(q)
if q < 2:
raise ValueError("q must be a prime power")
F = q.factor()
if len(F) > 1:
raise ValueError("q must be a prime power")
p = F[0][0]
k = F[0][1]
if q >= 1<<16:
raise ValueError("q must be < 2^16")
from .finite_field_constructor import GF
FiniteField.__init__(self, GF(p), name, normalize=False)
from sage.rings.polynomial.polynomial_element import is_Polynomial
if not is_Polynomial(modulus):
raise TypeError("modulus must be a polynomial")
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
self._modulus = modulus
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Initialize ``self``.
EXAMPLES::
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(GF(2^3, 'a')).run()
"""
if repr not in ['int', 'log', 'poly']:
raise ValueError("Unknown representation %s"%repr)
q = Integer(q)
if q < 2:
raise ValueError("q must be a prime power")
F = q.factor()
if len(F) > 1:
raise ValueError("q must be a prime power")
p = F[0][0]
k = F[0][1]
if q >= 1<<16:
raise ValueError("q must be < 2^16")
from .finite_field_constructor import GF
FiniteField.__init__(self, GF(p), name, normalize=False)
from sage.rings.polynomial.polynomial_element import is_Polynomial
if not is_Polynomial(modulus):
raise TypeError("modulus must be a polynomial")
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
self._modulus = modulus
def __init__(self, q, name, modulus=None):
"""
Create finite field of order `q` with variable printed as name.
EXAMPLES::
sage: k = FiniteField(9, 'a', impl='pari_mod'); k
Finite Field in a of size 3^2
"""
from sage.misc.superseded import deprecation
deprecation(17297, 'The "pari_mod" finite field implementation is deprecated')
if element_ext_pari.dynamic_FiniteField_ext_pariElement is None: element_ext_pari._late_import()
from .finite_field_constructor import FiniteField as GF
q = integer.Integer(q)
if q < 2:
raise ArithmeticError("q must be a prime power")
# note: the following call takes care of the fact that
# proof.arithmetic() is True or False.
p, n = q.is_prime_power(get_data=True)
if n > 1:
base_ring = GF(p)
elif n == 0:
raise ArithmeticError("q must be a prime power")
else:
raise ValueError("The size of the finite field must not be prime.")
FiniteField_generic.__init__(self, base_ring, name, normalize=True)
self._kwargs = {}
self.__char = p
self.__pari_one = pari.pari(1).Mod(self.__char)
self.__degree = n
self.__order = q
self.__is_field = True
if not sage.rings.polynomial.polynomial_element.is_Polynomial(modulus):
from sage.misc.superseded import deprecation
deprecation(16930, "constructing a FiniteField_ext_pari without giving a polynomial as modulus is deprecated, use the more general FiniteField constructor instead")
if modulus is None or modulus == "default":
from .conway_polynomials import exists_conway_polynomial
if exists_conway_polynomial(self.__char, self.__degree):
modulus = "conway"
else:
modulus = "random"
if isinstance(modulus,str):
if modulus == "conway":
from .conway_polynomials import conway_polynomial
modulus = conway_polynomial(self.__char, self.__degree)
elif modulus == "random":
# The following is fast/deterministic, but has serious problems since
# it crashes on 64-bit machines, and I can't figure out why:
# self.__pari_modulus = pari.pari.finitefield_init(self.__char, self.__degree, self.variable_name())
# So instead we iterate through random polys until we find an irreducible one.
R = GF(self.__char)['x']
while True:
modulus = R.random_element(self.__degree)
modulus = modulus.monic()
if modulus.degree() == self.__degree and modulus.is_irreducible():
break
else:
raise ValueError("Modulus parameter not understood")
elif isinstance(modulus, (list, tuple)):
modulus = GF(self.__char)['x'](modulus)
elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus):
if modulus.base_ring() is not base_ring:
modulus = modulus.change_ring(base_ring)
else:
raise ValueError("Modulus parameter not understood")
self._modulus = modulus
f = pari.pari(str(modulus))
self.__pari_modulus = f.subst(modulus.parent().variable_name(), 'a') * self.__pari_one
self.__gen = element_ext_pari.FiniteField_ext_pariElement(self, pari.pari('a'))
self._zero_element = self._element_constructor_(0)
self._one_element = self._element_constructor_(1)
def __init__(self, q, name, modulus=None):
"""
Create finite field of order q with variable printed as name.
INPUT:
- ``q`` -- integer, size of the finite field, not prime
- ``name`` -- variable used for printing element of the finite
field. Also, two finite fields are considered
equal if they have the same variable name, and not
otherwise.
- ``modulus`` -- you may provide a polynomial to use for reduction or
a string:
'conway': force the use of a Conway polynomial, will
raise a RuntimeError if none is found in the database;
'random': use a random irreducible polynomial.
'default': a Conway polynomial is used if found. Otherwise
a random polynomial is used.
OUTPUT:
- FiniteField_ext_pari -- a finite field of order q with given variable name.
EXAMPLES::
sage: FiniteField(65537)
Finite Field of size 65537
sage: FiniteField(2^20, 'c')
Finite Field in c of size 2^20
sage: FiniteField(3^11, "b")
Finite Field in b of size 3^11
sage: FiniteField(3^11, "b").gen()
b
You can also create a finite field using GF, which is a synonym
for FiniteField. ::
sage: GF(19^5, 'a')
Finite Field in a of size 19^5
"""
if element_ext_pari.dynamic_FiniteField_ext_pariElement is None: element_ext_pari._late_import()
from constructor import FiniteField as GF
q = integer.Integer(q)
if q < 2:
raise ArithmeticError, "q must be a prime power"
from sage.structure.proof.all import arithmetic
proof = arithmetic()
if proof:
F = q.factor()
else:
from sage.rings.arith import is_pseudoprime_small_power
F = is_pseudoprime_small_power(q, get_data=True)
if len(F) != 1:
raise ArithmeticError, "q must be a prime power"
if F[0][1] > 1:
base_ring = GF(F[0][0])
else:
raise ValueError, "The size of the finite field must not be prime."
#base_ring = self
FiniteField_generic.__init__(self, base_ring, name, normalize=True)
self._kwargs = {}
self.__char = F[0][0]
self.__pari_one = pari.pari(1).Mod(self.__char)
self.__degree = integer.Integer(F[0][1])
self.__order = q
self.__is_field = True
if modulus is None or modulus == "default":
from constructor import exists_conway_polynomial
if exists_conway_polynomial(self.__char, self.__degree):
modulus = "conway"
else:
modulus = "random"
if isinstance(modulus,str):
if modulus == "conway":
from constructor import conway_polynomial
modulus = conway_polynomial(self.__char, self.__degree)
elif modulus == "random":
# The following is fast/deterministic, but has serious problems since
# it crashes on 64-bit machines, and I can't figure out why:
# self.__pari_modulus = pari.pari.finitefield_init(self.__char, self.__degree, self.variable_name())
# So instead we iterate through random polys until we find an irreducible one.
R = GF(self.__char)['x']
while True:
modulus = R.random_element(self.__degree)
modulus = modulus.monic()
if modulus.degree() == self.__degree and modulus.is_irreducible():
break
else:
raise ValueError("Modulus parameter not understood")
elif isinstance(modulus, (list, tuple)):
modulus = GF(self.__char)['x'](modulus)
elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus):
if modulus.parent() is not base_ring:
modulus = modulus.change_ring(base_ring)
else:
raise ValueError("Modulus parameter not understood")
self.__modulus = modulus
f = pari.pari(str(modulus))
self.__pari_modulus = f.subst(modulus.parent().variable_name(), 'a') * self.__pari_one
self.__gen = element_ext_pari.FiniteField_ext_pariElement(self, pari.pari('a'))
self._zero_element = self._element_constructor_(0)
self._one_element = self._element_constructor_(1)
def __init__(self, q, name, modulus=None):
"""
Create finite field of order q with variable printed as name.
INPUT:
- ``q`` -- integer, size of the finite field, not prime
- ``name`` -- variable used for printing element of the finite
field. Also, two finite fields are considered
equal if they have the same variable name, and not
otherwise.
- ``modulus`` -- you may provide a polynomial to use for reduction or
a string:
'conway': force the use of a Conway polynomial, will
raise a RuntimeError if none is found in the database;
'random': use a random irreducible polynomial.
'default': a Conway polynomial is used if found. Otherwise
a random polynomial is used.
OUTPUT:
- FiniteField_ext_pari -- a finite field of order q with given variable name.
EXAMPLES::
sage: FiniteField(65537)
Finite Field of size 65537
sage: FiniteField(2^20, 'c')
Finite Field in c of size 2^20
sage: FiniteField(3^11, "b")
Finite Field in b of size 3^11
sage: FiniteField(3^11, "b").gen()
b
You can also create a finite field using GF, which is a synonym
for FiniteField. ::
sage: GF(19^5, 'a')
Finite Field in a of size 19^5
"""
if element_ext_pari.dynamic_FiniteField_ext_pariElement is None:
element_ext_pari._late_import()
from constructor import FiniteField as GF
q = integer.Integer(q)
if q < 2:
raise ArithmeticError, "q must be a prime power"
from sage.structure.proof.all import arithmetic
proof = arithmetic()
if proof:
F = q.factor()
else:
from sage.rings.arith import is_pseudoprime_small_power
F = is_pseudoprime_small_power(q, get_data=True)
if len(F) != 1:
raise ArithmeticError, "q must be a prime power"
if F[0][1] > 1:
base_ring = GF(F[0][0])
else:
raise ValueError, "The size of the finite field must not be prime."
#base_ring = self
FiniteField_generic.__init__(self, base_ring, name, normalize=True)
self._kwargs = {}
self.__char = F[0][0]
self.__pari_one = pari.pari(1).Mod(self.__char)
self.__degree = integer.Integer(F[0][1])
self.__order = q
self.__is_field = True
if modulus is None or modulus == "default":
from constructor import exists_conway_polynomial
if exists_conway_polynomial(self.__char, self.__degree):
modulus = "conway"
else:
modulus = "random"
if isinstance(modulus, str):
if modulus == "conway":
from constructor import conway_polynomial
modulus = conway_polynomial(self.__char, self.__degree)
elif modulus == "random":
# The following is fast/deterministic, but has serious problems since
# it crashes on 64-bit machines, and I can't figure out why:
# self.__pari_modulus = pari.pari.finitefield_init(self.__char, self.__degree, self.variable_name())
# So instead we iterate through random polys until we find an irreducible one.
R = GF(self.__char)['x']
while True:
modulus = R.random_element(self.__degree)
modulus = modulus.monic()
if modulus.degree(
) == self.__degree and modulus.is_irreducible():
break
else:
raise ValueError("Modulus parameter not understood")
elif isinstance(modulus, (list, tuple)):
modulus = GF(self.__char)['x'](modulus)
elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus):
if modulus.parent() is not base_ring:
modulus = modulus.change_ring(base_ring)
else:
raise ValueError("Modulus parameter not understood")
self.__modulus = modulus
f = pari.pari(str(modulus))
self.__pari_modulus = f.subst(modulus.parent().variable_name(),
'a') * self.__pari_one
self.__gen = element_ext_pari.FiniteField_ext_pariElement(
self, pari.pari('a'))
self._zero_element = self._element_constructor_(0)
self._one_element = self._element_constructor_(1)
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Finite Field. These are implemented using Zech logs and the
cardinality must be < 2^16. By default conway polynomials are
used as minimal polynomial.
INPUT:
q -- p^n (must be prime power)
name -- variable used for poly_repr (default: 'a')
modulus -- you may provide a minimal polynomial to use for
reduction or 'random' to force a random
irreducible polynomial. (default: None, a conway
polynomial is used if found. Otherwise a random
polynomial is used)
repr -- controls the way elements are printed to the user:
(default: 'poly')
'log': repr is element.log_repr()
'int': repr is element.int_repr()
'poly': repr is element.poly_repr()
cache -- if True a cache of all elements of this field is
created. Thus, arithmetic does not create new
elements which speeds calculations up. Also, if
many elements are needed during a calculation
this cache reduces the memory requirement as at
most self.order() elements are created. (default: False)
OUTPUT:
Givaro finite field with characteristic p and cardinality p^n.
EXAMPLES:
By default conway polynomials are used:
sage: k.<a> = GF(2**8)
sage: -a ^ k.degree()
a^4 + a^3 + a^2 + 1
sage: f = k.modulus(); f
x^8 + x^4 + x^3 + x^2 + 1
You may enforce a modulus:
sage: P.<x> = PolynomialRing(GF(2))
sage: f = x^8 + x^4 + x^3 + x + 1 # Rijndael Polynomial
sage: k.<a> = GF(2^8, modulus=f)
sage: k.modulus()
x^8 + x^4 + x^3 + x + 1
sage: a^(2^8)
a
You may enforce a random modulus:
sage: k = GF(3**5, 'a', modulus='random')
sage: k.modulus() # random polynomial
x^5 + 2*x^4 + 2*x^3 + x^2 + 2
Three different representations are possible:
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='poly').gen()
a
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='int').gen()
3
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='log').gen()
5
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(j).run()
"""
self._kwargs = {}
if repr not in ['int', 'log', 'poly']:
raise ValueError, "Unknown representation %s" % repr
q = Integer(q)
if q < 2:
raise ValueError, "q must be a prime power"
F = q.factor()
if len(F) > 1:
raise ValueError, "q must be a prime power"
p = F[0][0]
k = F[0][1]
if q >= 1 << 16:
raise ValueError, "q must be < 2^16"
import constructor
FiniteField.__init__(self,
constructor.FiniteField(p),
name,
normalize=False)
self._kwargs['repr'] = repr
self._kwargs['cache'] = cache
self._is_conway = False
if modulus is None or modulus == 'conway':
if k == 1:
modulus = 'random' # this will use the gfq_factory_pk function.
elif ConwayPolynomials().has_polynomial(p, k):
from sage.rings.finite_rings.constructor import conway_polynomial
modulus = conway_polynomial(p, k)
self._is_conway = True
elif modulus is None:
modulus = 'random'
else:
raise ValueError, "Conway polynomial not found"
from sage.rings.polynomial.all import is_Polynomial
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
def __init__(self, q, names="a", modulus=None, repr="poly"):
"""
Finite Field for characteristic 2 and order >= 2.
INPUT:
q -- 2^n (must be 2 power)
names -- variable used for poly_repr (default: 'a')
modulus -- you may provide a polynomial to use for reduction or
a string:
'conway': force the use of a Conway polynomial, will
raise a RuntimeError if none is found in the database;
'minimal_weight': use a minimal weight polynomial, should
result in faster arithmetic;
'random': use a random irreducible polynomial.
'default':a Conway polynomial is used if found. Otherwise
a sparse polynomial is used.
repr -- controls the way elements are printed to the user:
(default: 'poly')
'poly': polynomial representation
OUTPUT:
Finite field with characteristic 2 and cardinality 2^n.
EXAMPLES::
sage: k.<a> = GF(2^16)
sage: type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: k.<a> = GF(2^1024)
sage: k.modulus()
x^1024 + x^19 + x^6 + x + 1
sage: set_random_seed(0)
sage: k.<a> = GF(2^17, modulus='random')
sage: k.modulus()
x^17 + x^16 + x^15 + x^10 + x^8 + x^6 + x^4 + x^3 + x^2 + x + 1
sage: k.modulus().is_irreducible()
True
sage: k.<a> = GF(2^211, modulus='minimal_weight')
sage: k.modulus()
x^211 + x^11 + x^10 + x^8 + 1
sage: k.<a> = GF(2^211, modulus='conway')
sage: k.modulus()
x^211 + x^9 + x^6 + x^5 + x^3 + x + 1
sage: k.<a> = GF(2^411, modulus='conway')
Traceback (most recent call last):
...
RuntimeError: requested conway polynomial not in database.
TESTS::
sage: k.<a> = GF(2^100, modulus='strangeinput')
Traceback (most recent call last):
...
ValueError: Modulus parameter not understood
sage: k.<a> = GF(2^20) ; type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: loads(dumps(k)) is k
True
sage: k1.<a> = GF(2^16)
sage: k2.<a> = GF(2^17)
sage: k1 == k2
False
sage: k3 = k1._finite_field_ext_pari_()
sage: k1 == k3
False
"""
late_import()
q = Integer(q)
if q < 2:
raise ValueError("q must be a 2-power")
k = q.exact_log(2)
if q != 1 << k:
raise ValueError("q must be a 2-power")
p = Integer(2)
FiniteField.__init__(self, GF(p), names, normalize=True)
self._kwargs = {'repr':repr}
self._is_conway = False
if modulus is None or modulus == 'default':
if exists_conway_polynomial(p, k):
modulus = "conway"
else:
modulus = "minimal_weight"
if modulus == "conway":
modulus = conway_polynomial(p, k)
self._is_conway = True
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_ntl_gf2e(self, k, modulus)
self._polynomial = {}
def __init__(self, q, name="a", modulus=None, repr="poly", cache=False):
"""
Finite Field. These are implemented using Zech logs and the
cardinality must be < 2^16. By default conway polynomials are
used as minimal polynomial.
INPUT:
q -- p^n (must be prime power)
name -- variable used for poly_repr (default: 'a')
modulus -- you may provide a minimal polynomial to use for
reduction or 'random' to force a random
irreducible polynomial. (default: None, a conway
polynomial is used if found. Otherwise a random
polynomial is used)
repr -- controls the way elements are printed to the user:
(default: 'poly')
'log': repr is element.log_repr()
'int': repr is element.int_repr()
'poly': repr is element.poly_repr()
cache -- if True a cache of all elements of this field is
created. Thus, arithmetic does not create new
elements which speeds calculations up. Also, if
many elements are needed during a calculation
this cache reduces the memory requirement as at
most self.order() elements are created. (default: False)
OUTPUT:
Givaro finite field with characteristic p and cardinality p^n.
EXAMPLES:
By default conway polynomials are used:
sage: k.<a> = GF(2**8)
sage: -a ^ k.degree()
a^4 + a^3 + a^2 + 1
sage: f = k.modulus(); f
x^8 + x^4 + x^3 + x^2 + 1
You may enforce a modulus:
sage: P.<x> = PolynomialRing(GF(2))
sage: f = x^8 + x^4 + x^3 + x + 1 # Rijndael Polynomial
sage: k.<a> = GF(2^8, modulus=f)
sage: k.modulus()
x^8 + x^4 + x^3 + x + 1
sage: a^(2^8)
a
You may enforce a random modulus:
sage: k = GF(3**5, 'a', modulus='random')
sage: k.modulus() # random polynomial
x^5 + 2*x^4 + 2*x^3 + x^2 + 2
Three different representations are possible:
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='poly').gen()
a
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='int').gen()
3
sage: sage.rings.finite_rings.finite_field_givaro.FiniteField_givaro(9,repr='log').gen()
5
sage: k.<a> = GF(2^3)
sage: j.<b> = GF(3^4)
sage: k == j
False
sage: GF(2^3,'a') == copy(GF(2^3,'a'))
True
sage: TestSuite(j).run()
"""
self._kwargs = {}
if repr not in ['int', 'log', 'poly']:
raise ValueError, "Unknown representation %s"%repr
q = Integer(q)
if q < 2:
raise ValueError, "q must be a prime power"
F = q.factor()
if len(F) > 1:
raise ValueError, "q must be a prime power"
p = F[0][0]
k = F[0][1]
if q >= 1<<16:
raise ValueError, "q must be < 2^16"
import constructor
FiniteField.__init__(self, constructor.FiniteField(p), name, normalize=False)
self._kwargs['repr'] = repr
self._kwargs['cache'] = cache
self._is_conway = False
if modulus is None or modulus == 'conway':
if k == 1:
modulus = 'random' # this will use the gfq_factory_pk function.
elif ConwayPolynomials().has_polynomial(p, k):
from sage.rings.finite_rings.constructor import conway_polynomial
modulus = conway_polynomial(p, k)
self._is_conway = True
elif modulus is None:
modulus = 'random'
else:
raise ValueError, "Conway polynomial not found"
from sage.rings.polynomial.all import is_Polynomial
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_givaro(self, p, k, modulus, repr, cache)
def __init__(self, q, name, modulus=None):
"""
Create finite field of order `q` with variable printed as name.
EXAMPLES::
sage: from sage.rings.finite_rings.finite_field_ext_pari import FiniteField_ext_pari
sage: k = FiniteField_ext_pari(9, 'a'); k
Finite Field in a of size 3^2
"""
if element_ext_pari.dynamic_FiniteField_ext_pariElement is None: element_ext_pari._late_import()
from constructor import FiniteField as GF
q = integer.Integer(q)
if q < 2:
raise ArithmeticError, "q must be a prime power"
from sage.structure.proof.all import arithmetic
proof = arithmetic()
if proof:
F = q.factor()
else:
from sage.rings.arith import is_pseudoprime_small_power
F = is_pseudoprime_small_power(q, get_data=True)
if len(F) != 1:
raise ArithmeticError, "q must be a prime power"
if F[0][1] > 1:
base_ring = GF(F[0][0])
else:
raise ValueError, "The size of the finite field must not be prime."
#base_ring = self
FiniteField_generic.__init__(self, base_ring, name, normalize=True)
self._kwargs = {}
self.__char = F[0][0]
self.__pari_one = pari.pari(1).Mod(self.__char)
self.__degree = integer.Integer(F[0][1])
self.__order = q
self.__is_field = True
if modulus is None or modulus == "default":
from conway_polynomials import exists_conway_polynomial
if exists_conway_polynomial(self.__char, self.__degree):
modulus = "conway"
else:
modulus = "random"
if isinstance(modulus,str):
if modulus == "conway":
from conway_polynomials import conway_polynomial
modulus = conway_polynomial(self.__char, self.__degree)
elif modulus == "random":
# The following is fast/deterministic, but has serious problems since
# it crashes on 64-bit machines, and I can't figure out why:
# self.__pari_modulus = pari.pari.finitefield_init(self.__char, self.__degree, self.variable_name())
# So instead we iterate through random polys until we find an irreducible one.
R = GF(self.__char)['x']
while True:
modulus = R.random_element(self.__degree)
modulus = modulus.monic()
if modulus.degree() == self.__degree and modulus.is_irreducible():
break
else:
raise ValueError("Modulus parameter not understood")
elif isinstance(modulus, (list, tuple)):
modulus = GF(self.__char)['x'](modulus)
elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus):
if modulus.parent() is not base_ring:
modulus = modulus.change_ring(base_ring)
else:
raise ValueError("Modulus parameter not understood")
self.__modulus = modulus
f = pari.pari(str(modulus))
self.__pari_modulus = f.subst(modulus.parent().variable_name(), 'a') * self.__pari_one
self.__gen = element_ext_pari.FiniteField_ext_pariElement(self, pari.pari('a'))
self._zero_element = self._element_constructor_(0)
self._one_element = self._element_constructor_(1)
def __init__(self, q, name, modulus=None):
"""
Create finite field of order `q` with variable printed as name.
EXAMPLES::
sage: from sage.rings.finite_rings.finite_field_ext_pari import FiniteField_ext_pari
sage: k = FiniteField_ext_pari(9, 'a'); k
Finite Field in a of size 3^2
"""
if element_ext_pari.dynamic_FiniteField_ext_pariElement is None: element_ext_pari._late_import()
from constructor import FiniteField as GF
q = integer.Integer(q)
if q < 2:
raise ArithmeticError, "q must be a prime power"
from sage.structure.proof.all import arithmetic
proof = arithmetic()
if proof:
F = q.factor()
else:
from sage.rings.arith import is_pseudoprime_small_power
F = is_pseudoprime_small_power(q, get_data=True)
if len(F) != 1:
raise ArithmeticError, "q must be a prime power"
if F[0][1] > 1:
base_ring = GF(F[0][0])
else:
raise ValueError, "The size of the finite field must not be prime."
#base_ring = self
FiniteField_generic.__init__(self, base_ring, name, normalize=True)
self._kwargs = {}
self.__char = F[0][0]
self.__pari_one = pari.pari(1).Mod(self.__char)
self.__degree = integer.Integer(F[0][1])
self.__order = q
self.__is_field = True
if modulus is None or modulus == "default":
from constructor import exists_conway_polynomial
if exists_conway_polynomial(self.__char, self.__degree):
modulus = "conway"
else:
modulus = "random"
if isinstance(modulus,str):
if modulus == "conway":
from constructor import conway_polynomial
modulus = conway_polynomial(self.__char, self.__degree)
elif modulus == "random":
# The following is fast/deterministic, but has serious problems since
# it crashes on 64-bit machines, and I can't figure out why:
# self.__pari_modulus = pari.pari.finitefield_init(self.__char, self.__degree, self.variable_name())
# So instead we iterate through random polys until we find an irreducible one.
R = GF(self.__char)['x']
while True:
modulus = R.random_element(self.__degree)
modulus = modulus.monic()
if modulus.degree() == self.__degree and modulus.is_irreducible():
break
else:
raise ValueError("Modulus parameter not understood")
elif isinstance(modulus, (list, tuple)):
modulus = GF(self.__char)['x'](modulus)
elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus):
if modulus.parent() is not base_ring:
modulus = modulus.change_ring(base_ring)
else:
raise ValueError("Modulus parameter not understood")
self.__modulus = modulus
f = pari.pari(str(modulus))
self.__pari_modulus = f.subst(modulus.parent().variable_name(), 'a') * self.__pari_one
self.__gen = element_ext_pari.FiniteField_ext_pariElement(self, pari.pari('a'))
self._zero_element = self._element_constructor_(0)
self._one_element = self._element_constructor_(1)
def __init__(self, q, names="a", modulus=None, repr="poly"):
"""
Finite Field for characteristic 2 and order >= 2.
INPUT:
q -- 2^n (must be 2 power)
names -- variable used for poly_repr (default: 'a')
modulus -- you may provide a polynomial to use for reduction or
a string:
'conway': force the use of a Conway polynomial, will
raise a RuntimeError if none is found in the database;
'minimal_weight': use a minimal weight polynomial, should
result in faster arithmetic;
'random': use a random irreducible polynomial.
'default':a Conway polynomial is used if found. Otherwise
a sparse polynomial is used.
repr -- controls the way elements are printed to the user:
(default: 'poly')
'poly': polynomial representation
OUTPUT:
Finite field with characteristic 2 and cardinality 2^n.
EXAMPLES::
sage: k.<a> = GF(2^16)
sage: type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: k.<a> = GF(2^1024)
sage: k.modulus()
x^1024 + x^19 + x^6 + x + 1
sage: set_random_seed(0)
sage: k.<a> = GF(2^17, modulus='random')
sage: k.modulus()
x^17 + x^16 + x^15 + x^10 + x^8 + x^6 + x^4 + x^3 + x^2 + x + 1
sage: k.modulus().is_irreducible()
True
sage: k.<a> = GF(2^211, modulus='minimal_weight')
sage: k.modulus()
x^211 + x^11 + x^10 + x^8 + 1
sage: k.<a> = GF(2^211, modulus='conway')
sage: k.modulus()
x^211 + x^9 + x^6 + x^5 + x^3 + x + 1
sage: k.<a> = GF(2^411, modulus='conway')
Traceback (most recent call last):
...
RuntimeError: requested conway polynomial not in database.
TESTS::
sage: k.<a> = GF(2^100, modulus='strangeinput')
Traceback (most recent call last):
...
ValueError: Modulus parameter not understood
sage: k.<a> = GF(2^20) ; type(k)
<class 'sage.rings.finite_rings.finite_field_ntl_gf2e.FiniteField_ntl_gf2e_with_category'>
sage: loads(dumps(k)) is k
True
sage: k1.<a> = GF(2^16)
sage: k2.<a> = GF(2^17)
sage: k1 == k2
False
sage: k3 = k1._finite_field_ext_pari_()
sage: k1 == k3
False
"""
late_import()
q = Integer(q)
if q < 2:
raise ValueError("q must be a 2-power")
k = q.exact_log(2)
if q != 1 << k:
raise ValueError("q must be a 2-power")
p = Integer(2)
FiniteField.__init__(self, GF(p), names, normalize=True)
self._kwargs = {'repr': repr}
self._is_conway = False
if modulus is None or modulus == 'default':
if exists_conway_polynomial(p, k):
modulus = "conway"
else:
modulus = "minimal_weight"
if modulus == "conway":
modulus = conway_polynomial(p, k)
self._is_conway = True
if is_Polynomial(modulus):
modulus = modulus.list()
self._cache = Cache_ntl_gf2e(self, k, modulus)
self._polynomial = {}