def __init__(self, prepoly, poly, prec, halt, print_mode, shift_seed,
names, implementation):
"""
A capped absolute representation of an eisenstein extension of Zp.
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 = ZpCA(3, 10000, print_pos=False); S.<x> = ZZ[]; f = x^3 + 9*x - 3
sage: W.<w> = R.ext(f); W
Eisenstein Extension of 3-adic Ring with capped absolute precision 10000 in w defined by (1 + O(3^10000))*x^3 + (O(3^10000))*x^2 + (3^2 + O(3^10000))*x + (-3 + O(3^10000))
sage: W.precision_cap()
30000
sage: R.<p> = ZpCA(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()
6
"""
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, False, ntl_poly,
"small", "e", shift_poly)
else:
self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(),
30, unram_prec, prec, False,
ntl_poly, "big", "e",
shift_poly)
self._shift_seed = shift_seed
self._pre_poly = prepoly
self._implementation = implementation
EisensteinExtensionGeneric.__init__(self, poly, prec, print_mode,
names, pAdicZZpXCAElement)
def __init__(self,
exact_modulus,
poly,
prec,
print_mode,
shift_seed,
names,
implementation='NTL'):
"""
A fixed modulus representation of an eisenstein extension of Zp.
INPUT:
- ``exact_modulus`` -- the original polynomial defining the extension.
This could be a polynomial with integer coefficients, for example,
while ``poly`` has coefficients in a `p`-adic ring.
- ``poly`` -- the polynomial with coefficients in :meth:`base_ring`
defining this extension
- ``prec`` -- the precision cap of this ring
- ``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
3-adic Eisenstein Extension Ring in w defined by x^3 + 9*x - 3
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._exact_modulus = exact_modulus
self._implementation = implementation
EisensteinExtensionGeneric.__init__(self, poly, prec, print_mode,
names, pAdicZZpXFMElement)
def __init__(self, exact_modulus, poly, prec, print_mode, shift_seed,
names, implementation):
"""
A capped absolute representation of an eisenstein extension of Zp.
INPUT:
- ``exact_modulus`` -- the original polynomial defining the extension.
This could be a polynomial with integer coefficients, for example,
while ``poly`` has coefficients in a `p`-adic ring.
- ``poly`` -- the polynomial with coefficients in :meth:`base_ring`
defining this extension
- ``prec`` -- the precision cap of this ring
- ``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 = ZpCA(3, 10000, print_pos=False); S.<x> = ZZ[]; f = x^3 + 9*x - 3
sage: W.<w> = R.ext(f); W
Eisenstein Extension in w defined by x^3 + 9*x - 3 with capped absolute precision 30000 over 3-adic Ring
sage: W.precision_cap()
30000
sage: R.<p> = ZpCA(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)
if unram_prec <= 30:
self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(),
unram_prec, unram_prec,
prec, False, ntl_poly,
"small", "e", shift_poly)
else:
self.prime_pow = PowComputer_ext_maker(poly.base_ring().prime(),
30, unram_prec, prec, False,
ntl_poly, "big", "e",
shift_poly)
self._shift_seed = shift_seed
self._exact_modulus = exact_modulus
self._implementation = implementation
EisensteinExtensionGeneric.__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, implementation='NTL'):
"""
A capped relative representation of an eisenstein extension of Qp.
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 = 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
self._implementation = implementation
EisensteinExtensionGeneric.__init__(self, poly, prec, print_mode, names, pAdicZZpXCRElement)
def __init__(self, prepoly, poly, prec, halt, print_mode, shift_seed, names, implementation='NTL'):
"""
A fixed modulus representation of an eisenstein extension of Zp.
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 = 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 + (O(3^10000))*x^2 + (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
self._implementation = implementation
EisensteinExtensionGeneric.__init__(self, poly, prec, print_mode, names, pAdicZZpXFMElement)
def __init__(self, exact_modulus, poly, prec, print_mode, shift_seed, names, implementation='NTL'):
"""
A capped relative representation of an eisenstein extension of Qp.
INPUT:
- ``exact_modulus`` -- the original polynomial defining the extension.
This could be a polynomial with rational coefficients, for example,
while ``poly`` has coefficients in a `p`-adic field.
- ``poly`` -- the polynomial with coefficients in :meth:`base_ring`
defining this extension
- ``prec`` -- the precision cap of this ring
- ``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 in w defined by x^3 + 9*x - 3 with capped relative precision 30000 over 3-adic Field
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._exact_modulus = exact_modulus
self._implementation = implementation
EisensteinExtensionGeneric.__init__(self, poly, prec, print_mode, names, pAdicZZpXCRElement)
def __init__(self, exact_modulus, poly, prec, print_mode, shift_seed, names, implementation='NTL'):
"""
A fixed modulus representation of an eisenstein extension of Zp.
INPUT:
- ``exact_modulus`` -- the original polynomial defining the extension.
This could be a polynomial with integer coefficients, for example,
while ``poly`` has coefficients in a `p`-adic ring.
- ``poly`` -- the polynomial with coefficients in :meth:`base_ring`
defining this extension
- ``prec`` -- the precision cap of this ring
- ``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 in w defined by x^3 + 9*x - 3 of fixed modulus w^30000 over 3-adic Ring
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._exact_modulus = exact_modulus
self._implementation = implementation
EisensteinExtensionGeneric.__init__(self, poly, prec, print_mode, names, pAdicZZpXFMElement)
def __init__(self, prepoly, poly, prec, halt, print_mode, shift_seed, names, implementation='FLINT'):
"""
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))
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))
def __init__(self, exact_modulus, poly, prec, print_mode, shift_seed, names, implementation='FLINT'):
r"""
A representation of Qq.
INPUT:
- ``exact_modulus`` -- the original polynomial defining the extension.
This could be a polynomial with rational coefficients, for example,
while ``poly`` has coefficients in a `p`-adic field.
- ``poly`` -- the polynomial with coefficients in :meth:`base_ring`
defining this extension
- ``prec`` -- the precision cap of this ring
- ``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> = Qq(27,10000); R #indirect doctest
Unramified Extension in a defined by x^3 + 2*x + 1 with capped relative precision 10000 over 3-adic Field
sage: R.<a> = Qq(next_prime(10^30)^3, 3); R.prime()
1000000000000000000000000000057
"""
# Currently doesn't support polynomials with non-integral coefficients
self._shift_seed = None
self._exact_modulus = exact_modulus
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 = pAdicZZpXCRElement
else:
Zpoly = _make_integral_poly(exact_modulus, poly.base_ring().prime(), prec)
cache_limit = min(prec, 30)
self.prime_pow = PowComputer_flint_maker(poly.base_ring().prime(), cache_limit, prec, prec, True, Zpoly, prec_type='capped-rel')
element_class = qAdicCappedRelativeElement
UnramifiedExtensionGeneric.__init__(self, poly, prec, print_mode, names, element_class)
if implementation != 'NTL':
from .qadic_flint_CR import pAdicCoercion_ZZ_CR, pAdicCoercion_QQ_CR
self.register_coercion(pAdicCoercion_ZZ_CR(self))
self.register_coercion(pAdicCoercion_QQ_CR(self))
def __init__(self, exact_modulus, poly, prec, print_mode, shift_seed, names, implementation='FLINT'):
"""
A capped absolute representation of Zq.
INPUT:
- ``exact_modulus`` -- the original polynomial defining the extension.
This could be a polynomial with integer coefficients, for example,
while poly has coefficients in a `p`-adic ring.
- ``poly`` -- the polynomial with coefficients in :meth:`base_ring`
defining this extension
- ``prec`` -- the precision cap of this ring
- ``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
3-adic Unramified Extension Ring in a defined by x^3 + 2*x + 1
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._exact_modulus = exact_modulus
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(exact_modulus, 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))
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='FLINT'):
"""
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):
"""
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, exact_modulus, poly, prec, print_mode, shift_seed, names, implementation='FLINT'):
"""
A fixed modulus representation of Zq.
INPUT:
- ``exact_modulus`` -- the original polynomial defining the extension.
This could be a polynomial with integer coefficients, for example,
while ``poly`` has coefficients in a `p`-adic field.
- ``poly`` -- the polynomial with coefficients in :meth:`base_ring`
defining this extension
- ``prec`` -- the precision cap of this ring
- ``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 in a defined by x^3 + 2*x + 1 of fixed modulus 3^10000 over 3-adic Ring
sage: R.<a> = ZqFM(next_prime(10^30)^3, 3); R.prime()
1000000000000000000000000000057
"""
self._shift_seed = None
self._exact_modulus = exact_modulus
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(exact_modulus, 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, exact_modulus, poly, prec, print_mode, shift_seed, names, implementation='FLINT'):
"""
A fixed modulus representation of Zq.
INPUT:
- ``exact_modulus`` -- the original polynomial defining the extension.
This could be a polynomial with integer coefficients, for example,
while ``poly`` has coefficients in a `p`-adic field.
- ``poly`` -- the polynomial with coefficients in :meth:`base_ring`
defining this extension
- ``prec`` -- the precision cap of this ring
- ``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
3-adic Unramified Extension Ring in a defined by x^3 + 2*x + 1
sage: R.<a> = ZqFM(next_prime(10^30)^3, 3); R.prime()
1000000000000000000000000000057
"""
self._shift_seed = None
self._exact_modulus = exact_modulus
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(exact_modulus, 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):
"""
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):
"""
A representation of Qq.
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> = Qq(27,10000); R #indirect doctest
Unramified Extension of 3-adic Field with capped relative 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> = Qq(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, pAdicZZpXCRElement)
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)
