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)