def __init__(self, prepoly, poly, prec, halt, print_mode, shift_seed, names): """ A capped relative representation of an eisenstein extension of Qp. INPUTS:: - prepoly -- The original polynomial defining the extension. This could be a polynomial with integer coefficients, for example, while poly has coefficients in Qp. - poly -- The polynomial with coefficients in self.base_ring() defining this extension. - prec -- The precision cap of this ring. - halt -- unused - print_mode -- A dictionary of print options. - shift_seed -- unused - names -- a 4-tuple, (variable_name, residue_name, unramified_subextension_variable_name, uniformizer_name) EXAMPLES:: sage: R = Qp(3, 10000, print_pos=False); S.<x> = ZZ[]; f = x^3 + 9*x - 3 sage: W.<w> = R.ext(f); W #indirect doctest Eisenstein Extension of 3-adic Field with capped relative precision 10000 in w defined by (1 + O(3^10000))*x^3 + (O(3^10001))*x^2 + (3^2 + O(3^10001))*x + (-3 + O(3^10001)) sage: W.precision_cap() 30000 sage: R.<p> = Qp(next_prime(10^30), 3, print_pos=False); S.<x> = ZZ[]; f = x^3 + p^2*x - p sage: W.<w> = R.ext(f); W.prime() 1000000000000000000000000000057 sage: W.precision_cap() 9 """ # Currently doesn't support polynomials with non-integral coefficients unram_prec = (prec + poly.degree() - 1) // poly.degree() ntl_poly = ntl_ZZ_pX([a.lift() for a in poly.list()], poly.base_ring().prime()**unram_prec) shift_poly = ntl_ZZ_pX([a.lift() for a in shift_seed.list()], shift_seed.base_ring().prime()**unram_prec) if unram_prec <= 30: self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(), unram_prec, unram_prec, prec, True, ntl_poly, "small", "e", shift_poly) else: self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(), 30, unram_prec, prec, True, ntl_poly, "big", "e", shift_poly) self._shift_seed = shift_seed self._pre_poly = prepoly EisensteinExtensionGeneric.__init__(self, poly, prec, print_mode, names, pAdicZZpXCRElement)
def __init__(self, prepoly, poly, prec, halt, print_mode, shift_seed, names): """ A capped absolute representation of Zq. INPUTS:: - prepoly -- The original polynomial defining the extension. This could be a polynomial with integer coefficients, for example, while poly has coefficients in Zp. - poly -- The polynomial with coefficients in self.base_ring() defining this extension. - prec -- The precision cap of this ring. - halt -- unused - print_mode -- A dictionary of print options. - shift_seed -- unused - names -- a 4-tuple, (variable_name, residue_name, unramified_subextension_variable_name, uniformizer_name) EXAMPLES:: sage: R.<a> = ZqCA(27,10000); R #indirect doctest Unramified Extension of 3-adic Ring with capped absolute precision 10000 in a defined by (1 + O(3^10000))*x^3 + (2 + O(3^10000))*x + (1 + O(3^10000)) sage: R.<a> = ZqCA(next_prime(10^30)^3, 3); R.prime() 1000000000000000000000000000057 """ # Currently doesn't support polynomials with non-integral coefficients ntl_poly = ntl_ZZ_pX([a.lift() for a in poly.list()], poly.base_ring().prime()**prec) if prec <= 30: self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(), prec, prec, prec, True, ntl_poly, "small", "u") else: self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(), 30, prec, prec, True, ntl_poly, "big", "u") self._shift_seed = None self._pre_poly = prepoly UnramifiedExtensionGeneric.__init__(self, poly, prec, print_mode, names, pAdicZZpXCAElement)
def __init__(self, prepoly, poly, prec, halt, print_mode, shift_seed, names): """ A fixed modulus representation of an eisenstein extension of Zp. INPUTS:: - prepoly -- The original polynomial defining the extension. This could be a polynomial with integer coefficients, for example, while poly has coefficients in Zp. - poly -- The polynomial with coefficients in self.base_ring() defining this extension. - prec -- The precision cap of this ring. - halt -- unused - print_mode -- A dictionary of print options. - shift_seed -- unused - names -- a 4-tuple, (variable_name, residue_name, unramified_subextension_variable_name, uniformizer_name) EXAMPLES:: sage: R = ZpFM(3, 10000, print_pos=False); S.<x> = ZZ[]; f = x^3 + 9*x - 3 sage: W.<w> = R.ext(f); W #indirect doctest Eisenstein Extension of 3-adic Ring of fixed modulus 3^10000 in w defined by (1 + O(3^10000))*x^3 + (3^2 + O(3^10000))*x + (-3 + 3^10000 + O(3^10000)) sage: W.precision_cap() 30000 sage: R.<p> = ZpFM(next_prime(10^30), 3, print_pos=False); S.<x> = ZZ[]; f = x^3 + p^2*x - p sage: W.<w> = R.ext(f); W.prime() 1000000000000000000000000000057 sage: W.precision_cap() 9 """ unram_prec = (prec + poly.degree() - 1) // poly.degree() ntl_poly = ntl_ZZ_pX([a.lift() for a in poly.list()], poly.base_ring().prime()**unram_prec) shift_poly = ntl_ZZ_pX([a.lift() for a in shift_seed.list()], shift_seed.base_ring().prime()**unram_prec) #print poly.base_ring().prime(), prec, poly.degree(), ntl_poly # deal with prec not a multiple of e better. self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(), max(min(unram_prec - 1, 30), 1), unram_prec, prec, False, ntl_poly, "FM", "e", shift_poly) self._shift_seed = shift_seed self._pre_poly = prepoly EisensteinExtensionGeneric.__init__(self, poly, prec, print_mode, names, pAdicZZpXFMElement)
def __init__(self, prepoly, poly, prec, halt, print_mode, shift_seed, names): """ A fixed modulus representation of Zq. INPUTS:: - prepoly -- The original polynomial defining the extension. This could be a polynomial with integer coefficients, for example, while poly has coefficients in Qp. - poly -- The polynomial with coefficients in self.base_ring() defining this extension. - prec -- The precision cap of this ring. - halt -- unused - print_mode -- A dictionary of print options. - shift_seed -- unused - names -- a 4-tuple, (variable_name, residue_name, unramified_subextension_variable_name, uniformizer_name) EXAMPLES:: sage: R.<a> = ZqFM(27,10000); R #indirect doctest Unramified Extension of 3-adic Ring of fixed modulus 3^10000 in a defined by (1 + O(3^10000))*x^3 + (2 + O(3^10000))*x + (1 + O(3^10000)) sage: R.<a> = ZqFM(next_prime(10^30)^3, 3); R.prime() 1000000000000000000000000000057 """ ntl_poly = ntl_ZZ_pX([a.lift() for a in poly.list()], poly.base_ring().prime()**prec) self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(), max(min(prec - 1, 30), 1), prec, prec, False, ntl_poly, "FM", "u") self._shift_seed = None self._pre_poly = prepoly UnramifiedExtensionGeneric.__init__(self, poly, prec, print_mode, names, pAdicZZpXFMElement)
def __init__(self, prepoly, poly, prec, halt, print_mode, shift_seed, names, implementation='NTL'): """ A fixed modulus representation of Zq. INPUT: - prepoly -- The original polynomial defining the extension. This could be a polynomial with integer coefficients, for example, while poly has coefficients in Qp. - poly -- The polynomial with coefficients in self.base_ring() defining this extension. - prec -- The precision cap of this ring. - halt -- unused - print_mode -- A dictionary of print options. - shift_seed -- unused - names -- a 4-tuple, (variable_name, residue_name, unramified_subextension_variable_name, uniformizer_name) EXAMPLES:: sage: R.<a> = ZqFM(27,10000); R #indirect doctest Unramified Extension of 3-adic Ring of fixed modulus 3^10000 in a defined by (1 + O(3^10000))*x^3 + (O(3^10000))*x^2 + (2 + O(3^10000))*x + (1 + O(3^10000)) sage: R.<a> = ZqFM(next_prime(10^30)^3, 3); R.prime() 1000000000000000000000000000057 """ self._shift_seed = None self._pre_poly = prepoly self._implementation = implementation if implementation == 'NTL': ntl_poly = ntl_ZZ_pX([a.lift() for a in poly.list()], poly.base_ring().prime()**prec) self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(), max(min(prec - 1, 30), 1), prec, prec, False, ntl_poly, "FM", "u") element_class = pAdicZZpXFMElement else: Zpoly = _make_integral_poly(prepoly, poly.base_ring().prime(), prec) cache_limit = 0 # prevents caching self.prime_pow = PowComputer_flint_maker(poly.base_ring().prime(), cache_limit, prec, prec, False, Zpoly, prec_type='fixed-mod') element_class = qAdicFixedModElement UnramifiedExtensionGeneric.__init__(self, poly, prec, print_mode, names, element_class) if implementation != 'NTL': from qadic_flint_FM import pAdicCoercion_ZZ_FM, pAdicConvert_QQ_FM self.register_coercion(pAdicCoercion_ZZ_FM(self)) self.register_conversion(pAdicConvert_QQ_FM(self))
def __init__(self, prepoly, poly, prec, halt, print_mode, shift_seed, names, implementation='NTL'): """ A capped absolute representation of Zq. INPUT: - prepoly -- The original polynomial defining the extension. This could be a polynomial with integer coefficients, for example, while poly has coefficients in Zp. - poly -- The polynomial with coefficients in self.base_ring() defining this extension. - prec -- The precision cap of this ring. - halt -- unused - print_mode -- A dictionary of print options. - shift_seed -- unused - names -- a 4-tuple, (variable_name, residue_name, unramified_subextension_variable_name, uniformizer_name) EXAMPLES:: sage: R.<a> = ZqCA(27,10000); R #indirect doctest Unramified Extension of 3-adic Ring with capped absolute precision 10000 in a defined by (1 + O(3^10000))*x^3 + (O(3^10000))*x^2 + (2 + O(3^10000))*x + (1 + O(3^10000)) sage: R.<a> = ZqCA(next_prime(10^30)^3, 3); R.prime() 1000000000000000000000000000057 """ # Currently doesn't support polynomials with non-integral coefficients self._shift_seed = None self._pre_poly = prepoly self._implementation = implementation if implementation == 'NTL': ntl_poly = ntl_ZZ_pX([a.lift() for a in poly.list()], poly.base_ring().prime()**prec) if prec <= 30: self.prime_pow = PowComputer_ext_maker( poly.base_ring().prime(), prec, prec, prec, True, ntl_poly, "small", "u") else: self.prime_pow = PowComputer_ext_maker( poly.base_ring().prime(), 30, prec, prec, True, ntl_poly, "big", "u") element_class = pAdicZZpXCAElement else: Zpoly = _make_integral_poly(prepoly, poly.base_ring().prime(), prec) cache_limit = min(prec, 30) self.prime_pow = PowComputer_flint_maker(poly.base_ring().prime(), cache_limit, prec, prec, False, Zpoly, prec_type='capped-abs') element_class = qAdicCappedAbsoluteElement UnramifiedExtensionGeneric.__init__(self, poly, prec, print_mode, names, element_class) if implementation != 'NTL': from qadic_flint_CA import pAdicCoercion_ZZ_CA, pAdicConvert_QQ_CA self.register_coercion(pAdicCoercion_ZZ_CA(self)) self.register_conversion(pAdicConvert_QQ_CA(self))