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, 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 = {}