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, polynomial, names, element_class=FunctionFieldElement_polymod, category=CAT): """ Create a function field defined as an extension of another function field by adjoining a root of a univariate polynomial. INPUT: - ``polynomial`` -- a univariate polynomial over a function field - ``names`` -- variable names (as a tuple of length 1 or string) - ``category`` -- a category (defaults to category of function fields) EXAMPLES:: We create an extension of a function field:: sage: K.<x> = FunctionField(QQ); R.<y> = K[] sage: L = K.extension(y^5 - x^3 - 3*x + x*y); L Function field in y defined by y^5 + x*y - x^3 - 3*x Note the type:: sage: type(L) <class 'sage.rings.function_field.function_field.FunctionField_polymod_with_category'> We can set the variable name, which doesn't have to be y:: sage: L.<w> = K.extension(y^5 - x^3 - 3*x + x*y); L Function field in w defined by y^5 + x*y - x^3 - 3*x """ from sage.rings.polynomial.all import is_Polynomial if polynomial.parent().ngens() > 1 or not is_Polynomial(polynomial): raise TypeError("polynomial must be univariate a polynomial") if names is None: names = (polynomial.variable_name(), ) if polynomial.degree() <= 0: raise ValueError("polynomial must have positive degree") base_field = polynomial.base_ring() if not isinstance(base_field, FunctionField): raise TypeError("polynomial must be over a FunctionField") self._element_class = element_class self._element_init_pass_parent = False self._base_field = base_field self._polynomial = polynomial Field.__init__(self, base_field, names=names, category=category) self._hash = hash(polynomial) self._ring = self._polynomial.parent() self._populate_coercion_lists_(coerce_list=[base_field, self._ring]) self._gen = self(self._ring.gen())
def __init__(self, polynomial, names, element_class = FunctionFieldElement_polymod, category=CAT): """ Create a function field defined as an extension of another function field by adjoining a root of a univariate polynomial. INPUT: - ``polynomial`` -- a univariate polynomial over a function field - ``names`` -- variable names (as a tuple of length 1 or string) - ``category`` -- a category (defaults to category of function fields) EXAMPLES:: We create an extension of a function field:: sage: K.<x> = FunctionField(QQ); R.<y> = K[] sage: L = K.extension(y^5 - x^3 - 3*x + x*y); L Function field in y defined by y^5 + x*y - x^3 - 3*x Note the type:: sage: type(L) <class 'sage.rings.function_field.function_field.FunctionField_polymod_with_category'> We can set the variable name, which doesn't have to be y:: sage: L.<w> = K.extension(y^5 - x^3 - 3*x + x*y); L Function field in w defined by y^5 + x*y - x^3 - 3*x """ from sage.rings.polynomial.all import is_Polynomial if polynomial.parent().ngens()>1 or not is_Polynomial(polynomial): raise TypeError, "polynomial must be univariate a polynomial" if names is None: names = (polynomial.variable_name(), ) if polynomial.degree() <= 0: raise ValueError, "polynomial must have positive degree" base_field = polynomial.base_ring() if not isinstance(base_field, FunctionField): raise TypeError, "polynomial must be over a FunctionField" self._element_class = element_class self._element_init_pass_parent = False self._base_field = base_field self._polynomial = polynomial Field.__init__(self, base_field, names=names, category = category) self._hash = hash(polynomial) self._ring = self._polynomial.parent() self._populate_coercion_lists_(coerce_list=[base_field, self._ring]) self._gen = self(self._ring.gen())
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="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)