def field(self):
"""
If this ring is a field, return the corresponding field as a finite
field, which may have extra functionality and structure. Otherwise,
raise a ValueError.
EXAMPLES::
sage: R = Integers(7); R
Ring of integers modulo 7
sage: R.field()
Finite Field of size 7
sage: R = Integers(9)
sage: R.field()
Traceback (most recent call last):
...
ValueError: self must be a field
"""
try:
return self.__field
except AttributeError:
if not self.is_field():
raise ValueError, "self must be a field"
import constructor
k = constructor.FiniteField(self.order())
self.__field = k
return k
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, p, modulus, name=None):
"""
Create a finite field of characteristic `p` defined by the
polynomial ``modulus``, with distinguished generator called
``name``.
EXAMPLE::
sage: from sage.rings.finite_rings.finite_field_pari_ffelt import FiniteField_pari_ffelt
sage: R.<x> = PolynomialRing(GF(3))
sage: k = FiniteField_pari_ffelt(3, x^2 + 2*x + 2, 'a'); k
Finite Field in a of size 3^2
"""
import constructor
from sage.libs.pari.all import pari
from sage.rings.integer import Integer
from sage.structure.proof.all import arithmetic
proof = arithmetic()
p = Integer(p)
if ((p < 2) or (proof and not p.is_prime())
or (not proof and not p.is_pseudoprime())):
raise ArithmeticError("p must be a prime number")
Fp = constructor.FiniteField(p)
if name is None:
name = modulus.variable_name()
FiniteField.__init__(self, base=Fp, names=name, normalize=True)
modulus = self.polynomial_ring()(modulus)
n = modulus.degree()
if n < 2:
raise ValueError("the degree must be at least 2")
self._modulus = modulus
self._degree = n
self._card = p**n
self._kwargs = {}
self._gen_pari = pari(modulus).ffgen()
self._zero_element = self.element_class(self, 0)
self._one_element = self.element_class(self, 1)
self._gen = self.element_class(self, self._gen_pari)
def prime_subfield(self):
r"""
Return the prime subfield `\GF{p}` of self if ``self`` is `\GF{p^n}`.
EXAMPLES::
sage: GF(3^4, 'b').prime_subfield()
Finite Field of size 3
sage: S.<b> = GF(5^2); S
Finite Field in b of size 5^2
sage: S.prime_subfield()
Finite Field of size 5
sage: type(S.prime_subfield())
<class 'sage.rings.finite_rings.finite_field_prime_modn.FiniteField_prime_modn_with_category'>
"""
try:
return self._prime_subfield
except AttributeError:
import constructor
self._prime_subfield = constructor.FiniteField(self.characteristic())
return self._prime_subfield
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)
