passagemath-pari 10.6.32__cp314-cp314-musllinux_1_2_x86_64.whl

sage/rings/padics/pow_computer_relative.pxd

@@ -0,0 +1,29 @@
+# sage_setup: distribution = sagemath-pari
+from sage.rings.padics.pow_computer cimport PowComputer_class
+from sage.rings.polynomial.polynomial_element cimport Polynomial_generic_dense
+
+cdef class PowComputer_relative(PowComputer_class):
+    # p-adic elements are represented by polynomials in this ring
+    cdef public object poly_ring
+    # the p-adic ring is an extension of this base ring
+    cdef public object base_ring
+    # the modulus of the extension
+    cdef public Polynomial_generic_dense modulus
+    # storage for temporary variables used in the linkage files
+    cdef Polynomial_generic_dense tmp_cconv_out
+    cdef Polynomial_generic_dense tmp_ccoeffs
+    cdef Polynomial_generic_dense tmp_ccoeffs_frac
+    cdef Polynomial_generic_dense tmp_ccmp_a
+    cdef Polynomial_generic_dense tmp_ccmp_b
+    cdef Polynomial_generic_dense shift_rem
+    cdef Polynomial_generic_dense aliasing
+    # allow cached methods
+    cdef public dict _cached_methods
+
+    cdef unsigned long capdiv(self, unsigned long n) noexcept
+
+cdef class PowComputer_relative_eis(PowComputer_relative):
+    # (x^e - modulus)/p
+    cdef public Polynomial_generic_dense _shift_seed
+    cdef public Polynomial_generic_dense _inv_shift_seed
+    cpdef Polynomial_generic_dense invert(self, Polynomial_generic_dense element, long prec)

sage/rings/padics/pow_computer_relative.pyx

@@ -0,0 +1,415 @@
+# sage_setup: distribution = sagemath-pari
+# distutils: libraries = NTL_LIBRARIES gmp M_LIBRARIES
+# distutils: extra_compile_args = NTL_CFLAGS
+# distutils: include_dirs = NTL_INCDIR
+# distutils: library_dirs = NTL_LIBDIR
+# distutils: extra_link_args = NTL_LIBEXTRA
+# distutils: language = c++
+r"""
+A ``PowComputer`` for relative extensions
+
+This module provides helper classes for the various kinds of relative `p`-adic
+extensions. You should never have to access these directly, unless you are
+working on linkages or other low-level `p`-adics code within the Sage library.
+
+AUTHORS:
+
+- David Roe, Julian Rüth (2017-06-11): initial version
+"""
+# ****************************************************************************
+#       Copyright (C) 2017 David Roe <roed.math@gmail.com>
+#                     2017 Julian Rüth <julian.rueth@fsfe.org>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.rings.integer cimport Integer
+from sage.misc.cachefunc import cached_method
+
+
+cdef class PowComputer_relative(PowComputer_class):
+    r"""
+    Base class for a ``PowComputer`` for use in `p`-adics implemented by Sage
+    Polynomials.
+
+    For a description of inputs see :func:`PowComputer_relative_maker`.
+
+    EXAMPLES::
+
+        sage: # needs sage.libs.flint
+        sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+        sage: R.<a> = ZqFM(25)
+        sage: S.<x> = R[]
+        sage: f = x^3 - 5*x - 5*a
+        sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+        sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+        sage: PC = PowComputer_relative_maker(3, 20, 20, 60, False, f, shift_seed, 'fixed-mod')
+
+    TESTS::
+
+        sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative
+        sage: isinstance(PC, PowComputer_relative)                                      # needs sage.libs.flint
+        True
+    """
+    def __cinit__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed):
+        r"""
+        TESTS::
+
+            sage: # needs sage.libs.flint
+            sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+            sage: R.<a> = ZqFM(25)
+            sage: S.<x> = R[]
+            sage: f = x^3 - 5*x - 5*a
+            sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+            sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+            sage: PC = PowComputer_relative_maker(3, 20, 20, 60, False, f, shift_seed, 'fixed-mod')
+        """
+        self._allocated = 4
+
+    def __init__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed):
+        r"""
+        TESTS::
+
+            sage: # needs sage.libs.flint
+            sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+            sage: R.<a> = ZqFM(25)
+            sage: S.<x> = R[]; f = x^3 - 5*x - 5*a
+            sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+            sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+            sage: PC = PowComputer_relative_maker(5, 20, 20, 60, False, f, shift_seed, 'fixed-mod')  # indirect doctest
+            sage: TestSuite(PC).run()
+        """
+        PowComputer_class.__init__(self, prime, cache_limit, prec_cap, ram_prec_cap, in_field, poly, shift_seed)
+        self.e = poly.degree() * poly.base_ring().absolute_e()
+        self.f = poly.base_ring().absolute_f()
+
+        self.modulus = poly
+
+        self.tmp_cconv_out = poly.parent()()
+        self.tmp_ccoeffs = poly.parent()()
+        self.tmp_ccmp_a = poly.parent()()
+        self.tmp_ccmp_b = poly.parent()()
+        self.shift_rem = poly.parent()()
+        self.aliasing = poly.parent()()
+
+        self.base_ring = poly.base_ring()
+        self.poly_ring = poly.parent()
+        self._shift_seed = shift_seed
+
+    def __dealloc__(self):
+        r"""
+        TESTS::
+
+            sage: # needs sage.libs.flint
+            sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+            sage: R.<a> = ZqFM(25)
+            sage: S.<x> = R[]
+            sage: f = x^3 - 5*x - 5*a
+            sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+            sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+            sage: PC = PowComputer_relative_maker(5, 20, 20, 60, False, f, shift_seed, 'fixed-mod')
+            sage: del PC
+        """
+
+    def __reduce__(self):
+        r"""
+        Return a picklable representation of this ``PowComputer``.
+
+        TESTS::
+
+            sage: # needs sage.libs.flint
+            sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+            sage: R.<a> = ZqFM(25)
+            sage: S.<x> = R[]
+            sage: f = x^3 - 5*x - 5*a
+            sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+            sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+            sage: PC = PowComputer_relative_maker(5, 20, 20, 60, False, f, shift_seed, 'fixed-mod')  # indirect doctest
+            sage: loads(dumps(PC)) == PC
+            True
+        """
+        return PowComputer_relative_maker, (self.prime, self.cache_limit, self.prec_cap, self.ram_prec_cap, self.in_field, self.polynomial(), self._shift_seed, self._prec_type)
+
+    def _repr_(self):
+        r"""
+        Return a string representation of this ``PowComputer``.
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.flint
+            sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+            sage: R.<a> = ZqFM(25,print_pos=False,show_prec=False)
+            sage: S.<x> = R[]
+            sage: f = x^3 + 5*x + 5*a
+            sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+            sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+            sage: PowComputer_relative_maker(5, 20, 20, 60, False, f, shift_seed, 'fixed-mod')  # indirect doctest
+            Relative PowComputer for modulus x^3 + 5*x + a*5
+        """
+        return "Relative PowComputer for modulus %s" % (self.modulus,)
+
+    cdef unsigned long capdiv(self, unsigned long n) noexcept:
+        r"""
+        Return `\lceil n/e \rceil`.
+        """
+        if self.e == 1:
+            return n
+        if n == 0:
+            return 0
+        return (n - 1)/self.e + 1
+
+    def polynomial(self, n=None, var='x'):
+        r"""
+        Return the modulus of the `p`-adic extension that is handled by this
+        ``PowComputer``.
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.flint
+            sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+            sage: R.<a> = ZqFM(25)
+            sage: S.<x> = R[]; f = x^3 - 5*x - 5*a
+            sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+            sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+            sage: PC = PowComputer_relative_maker(5, 20, 20, 60, False, f, shift_seed, 'fixed-mod')  # indirect doctest
+            sage: PC.polynomial() is f
+            True
+        """
+        return self.modulus
+
+
+cdef class PowComputer_relative_eis(PowComputer_relative):
+    r"""
+    A ``PowComputer`` for a relative extension defined by an Eisenstein polynomial.
+
+    For a description of inputs see :func:`PowComputer_relative_maker`.
+
+    EXAMPLES::
+
+        sage: # needs sage.libs.flint
+        sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_eis, PowComputer_relative_maker
+        sage: R.<a> = ZqFM(25)
+        sage: S.<x> = R[]; f = x^3 - 5*x - 5*a
+        sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+        sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+        sage: PC = PowComputer_relative_maker(5, 20, 20, 60, False, f, shift_seed, 'fixed-mod')
+
+    TESTS::
+
+        sage: isinstance(PC, PowComputer_relative_eis)                                  # needs sage.libs.flint
+        True
+    """
+    def __init__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly, shift_seed):
+        r"""
+        TESTS::
+
+            sage: # needs sage.libs.flint
+            sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+            sage: R.<a> = ZqFM(25)
+            sage: S.<x> = R[]; f = x^3 - 5*x - 5*a
+            sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+            sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+            sage: PC = PowComputer_relative_maker(5, 20, 20, 60, False, f, shift_seed, 'fixed-mod')
+            sage: TestSuite(PC).run()
+        """
+        PowComputer_relative.__init__(self, prime, cache_limit, prec_cap, ram_prec_cap, in_field, poly, shift_seed)
+        self._inv_shift_seed = self.invert(shift_seed, self.ram_prec_cap)
+
+    cpdef Polynomial_generic_dense invert(self, Polynomial_generic_dense a, long prec):
+        r"""
+        Return the inverse of ``a``.
+
+        INPUT:
+
+        - ``a`` -- a `p`-adic element, represented as a reduced
+          Polynomial in ``poly_ring``
+
+        - ``prec`` -- a ``long``, the required precision
+
+        OUTPUT: a polynomial ``b`` such that ``a*b`` is one modulo `π^\mathrm{prec}`
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.flint
+            sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+            sage: R.<a> = ZqFM(25,3)
+            sage: S.<x> = R[]; f = x^3 - 5*x - 5*a
+            sage: W.<w> = R.ext(f)
+            sage: g = 1 + 2*w; ginv = ~g
+            sage: ginv
+            1 + 3*w + 4*w^2 + 2*w^3 + (3*a + 3)*w^4 + ... + (3*a + 2)*w^8
+            sage: RFP = R.change(field=False, show_prec=False, type='floating-point')
+            sage: shift_seed = (-f[:3] // 5).change_ring(RFP)
+            sage: PC = PowComputer_relative_maker(5, 3, 3, 9, False, f, shift_seed, 'fixed-mod')
+            sage: g = 1 + 2*x
+            sage: ginv = PC.invert(g, 5); ginv
+            (4 + (3*a + 1)*5 + (2*a + 2)*5^2)*x^2 + (3 + (a + 1)*5 + (3*a + 2)*5^2)*x + 1 + 2*a*5 + 2*5^2
+        """
+        k = self.base_ring.residue_field()
+        a0 = k(a[0])
+        if a0.is_zero():
+            raise ValueError("element has no inverse")
+        K = self.base_ring.change(field=True)
+        Qpmodulus = self.modulus.change_ring(K)
+        Qpa = a.change_ring(K)
+        R = Qpa.parent()
+        inv = R([~a0])
+        curprec = 1
+        while curprec < prec:
+            # Newton iteration
+            inv = 2*inv - inv**2 * Qpa
+            curprec *= 2
+            inv = inv % Qpmodulus
+        return inv.change_ring(self.base_ring)
+
+    @cached_method
+    def px_pow(self, r):
+        r"""
+        Return `p/π^r` where π is the uniformizer and `p` is the uniformizer of
+        the base ring (not necessarily an integer.)
+
+        INPUT:
+
+        - ``r`` -- integer with 0 <= r < e
+
+        OUTPUT: a reduced polynomial in π
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.ntl
+            sage: R.<a> = Zq(25, prec=3)
+            sage: S.<x> = R[]; f = x^3 - 5*x - 5*a
+            sage: W.<w> = R.ext(f)
+            sage: elt = W.prime_pow.px_pow(2); elt
+            ((4*a + 4) + (4*a + 1)*5 + (4*a + 2)*5^2)*x^2 + ((2*a + 3) + (2*a + 4)*5 + (2*a + 4)*5^2)*x + (a + 1)*5 + 3*5^2 + 2*5^3
+        """
+        if r < 0:
+            raise ValueError("r must be nonnegative")
+        elif r == 0:
+            return self.poly_ring(self.base_ring.uniformizer())
+        elif r >= self.e:
+            raise NotImplementedError
+        else:
+            return (self._inv_shift_seed << (self.e-r)) % self.modulus
+
+    @cached_method
+    def pxe_pow(self, r):
+        r"""
+        Return the ``r``-th power of the unit `p/π^e` where `e` is the relative
+        ramification index and `p` is the uniformizer of the base ring (not necessarily an integer.)
+
+        INPUT:
+
+        - ``r`` -- nonnegative integer
+
+        OUTPUT: a reduced polynomial in π
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.ntl
+            sage: R.<a> = Zq(25, prec=3)
+            sage: S.<x> = R[]; f = x^3 - 5*x - 5*a
+            sage: W.<w> = R.ext(f)
+            sage: elt = W.prime_pow.pxe_pow(2); elt
+            ((4*a + 2) + (a + 4)*5 + 2*a*5^2)*x^2 + ((a + 2) + (a + 2)*5 + (2*a + 4)*5^2)*x + (a + 1) + (3*a + 2)*5 + (2*a + 2)*5^2
+        """
+        if r < 0:
+            raise ValueError("r must be nonnegative")
+        elif r == 0:
+            return self.poly_ring.one()
+        elif r == 1:
+            return self._inv_shift_seed
+        elif r % 2:
+            return (self.pxe_pow(r-1) * self.pxe_pow(1)) % self.modulus
+        else:
+            return (self.pxe_pow(r//2)*self.pxe_pow(r//2)) % self.modulus
+
+    @cached_method
+    def uniformizer_pow(self, r):
+        r"""
+        Return the ``r``-th power of the uniformizer.
+
+        INPUT:
+
+        - ``r`` -- nonnegative integer
+
+        OUTPUT: a reduced polynomial in π
+
+        EXAMPLES::
+
+            sage: # needs sage.libs.ntl
+            sage: R.<a> = Zq(25, prec=3)
+            sage: S.<x> = R[]; f = x^3 - 5*x - 5*a
+            sage: W.<w> = R.ext(f)
+            sage: W.prime_pow.uniformizer_pow(2)
+            x^2
+        """
+        if r < 0:
+            raise ValueError("r must be nonnegative")
+        elif r == 0:
+            return self.poly_ring.one()
+        elif r < self.e:
+            return self.poly_ring.one() << r
+        elif r % 2:
+            return (self.uniformizer_pow(r-1) << 1) % self.modulus
+        else:
+            return (self.uniformizer_pow(r//2) * self.uniformizer_pow(r//2)) % self.modulus
+
+
+def PowComputer_relative_maker(prime, cache_limit, prec_cap, ram_prec_cap, in_field, poly, shift_seed, prec_type):
+    r"""
+    Create a ``PowComputer``.
+
+    INPUT:
+
+    - ``prime`` -- a uniformizer in the base ring
+
+    - ``cache_limit`` -- nonnegative integer, controlling the caching. The
+      ``PowComputer`` caches frequently used things like powers of ``prime``
+      This parameter, e.g., controls up to which power these are cached.
+
+    - ``prec_cap`` -- the power of ``prime`` modulo which elements of largest
+      precision are defined
+
+    - ``ram_prec_cap`` -- approximately ``e*prec_cap``, where ``e`` is
+      the relative ramification degree of the extension.  For a ramified
+      extension this is what Sage calls the precision cap of the ring.  In
+      fact, it's possible to have rings with precision cap not a multiple of
+      `e`, in which case the actual relationship between ``ram_prec_cap`` and
+      ``prec_cap`` is that ``prec_cap = ceil(n/e)``
+
+    - ``in_field`` -- boolean; whether the associated ring is actually a
+      field
+
+    - ``poly`` -- the polynomial defining the extension
+
+    - ``prec_type`` -- one of ``'capped-rel'``, ``'capped-abs'`` or
+      ``'fixed-mod'``, ``'floating-point'``; the precision type of the ring
+
+    .. NOTE::
+
+        Because of the way templates work, this function imports the class of
+        its return value from the appropriate element files.  This means that
+        the returned PowComputer will have the appropriate compile-time-type
+        for Cython.
+
+    EXAMPLES::
+
+        sage: # needs sage.libs.flint
+        sage: from sage.rings.padics.pow_computer_relative import PowComputer_relative_maker
+        sage: R.<a> = ZqFM(25, prec=2)
+        sage: S.<x> = R[]
+        sage: f = x^3 - 5*x - 5*a
+        sage: W.<w> = R.extension(f)
+        sage: PC = W.prime_pow  # indirect doctest
+        sage: PC
+        Relative PowComputer for modulus x^3 + (4*5 + 4*5^2)*x + 4*a*5 + 4*a*5^2
+    """
+    PC = PowComputer_relative_eis(prime, cache_limit, prec_cap, ram_prec_cap, in_field, poly, shift_seed)
+    # We have to set this here because the signature of __cinit__ in PowComputer_base doesn't allow for prec_type to be passed.
+    PC._prec_type = prec_type
+    return PC

sage/rings/padics/qadic_flint_CA.pxd

@@ -0,0 +1,21 @@
+# sage_setup: distribution = sagemath-pari
+
+from sage.libs.flint.types cimport fmpz_poly_t
+from sage.rings.padics.pow_computer_flint cimport PowComputer_flint_unram
+from sage.rings.padics.qadic_flint_CR cimport CRElement
+
+cdef class PowComputer_(PowComputer_flint_unram):
+    pass
+ctypedef fmpz_poly_t celement
+
+include "CA_template_header.pxi"
+
+cdef class qAdicCappedAbsoluteElement(CAElement):
+    pass
+
+cdef class qAdicCoercion_Zq_Qq(RingHomomorphism):
+    cdef CRElement _zero
+    cdef Morphism _section
+
+cdef class qAdicConvert_Qq_Zq(Morphism):
+    cdef CAElement _zero

sage/rings/padics/qadic_flint_CA.pyx

@@ -0,0 +1,130 @@
+# sage_setup: distribution = sagemath-pari
+# sage.doctest: needs sage.libs.flint
+
+include "sage/libs/linkages/padics/fmpz_poly_unram.pxi"
+include "sage/libs/linkages/padics/unram_shared.pxi"
+include "CA_template.pxi"
+
+cdef class PowComputer_(PowComputer_flint_unram):
+    """
+    A PowComputer for a capped-absolute unramified ring.
+    """
+    def __init__(self, Integer prime, long cache_limit, long prec_cap, long ram_prec_cap, bint in_field, poly=None):
+        """
+        Initialization.
+
+        EXAMPLES::
+
+            sage: R.<a> = ZqCA(125)
+            sage: type(R.prime_pow)
+            <class 'sage.rings.padics.qadic_flint_CA.PowComputer_'>
+            sage: R.prime_pow._prec_type
+            'capped-abs'
+        """
+        self._prec_type = 'capped-abs'
+        PowComputer_flint_unram.__init__(self, prime, cache_limit, prec_cap, ram_prec_cap, in_field, poly)
+
+cdef class qAdicCappedAbsoluteElement(CAElement):
+    frobenius = frobenius_unram
+    trace = trace_unram
+    norm = norm_unram
+
+    def matrix_mod_pn(self):
+        r"""
+        Return the matrix of right multiplication by the element on
+        the power basis `1, x, x^2, \ldots, x^{d-1}` for this
+        extension field.  Thus the *rows* of this matrix give the
+        images of each of the `x^i`.  The entries of the matrices are
+        IntegerMod elements, defined modulo ``p^(self.absprec() / e)``.
+
+        EXAMPLES::
+
+            sage: R.<a> = ZqCA(5^5,5)
+            sage: b = (5 + 15*a)^3
+            sage: b.matrix_mod_pn()
+            [ 125 1125  250  250    0]
+            [   0  125 1125  250  250]
+            [2375 2125  125 1125  250]
+            [2375 1375 2125  125 1125]
+            [2875 1000 1375 2125  125]
+
+            sage: M = R(0,3).matrix_mod_pn(); M == 0
+            True
+            sage: M.base_ring()
+            Ring of integers modulo 125
+        """
+        return cmatrix_mod_pn(self.value, self.absprec, 0, self.prime_pow)
+
+    def _flint_rep(self, var='x'):
+        """
+        Replacement for _ntl_rep for use in printing and debugging.
+
+        EXAMPLES::
+
+            sage: R.<a> = ZqCA(27, 4)
+            sage: (1+a).inverse_of_unit()._flint_rep()
+            41*x^2 + 40*x + 42
+            sage: (1+a)*(41*a^2+40*a+42)
+            1 + O(3^4)
+        """
+        return self.prime_pow._new_fmpz_poly(self.value, var)
+
+    def _flint_rep_abs(self, var='x'):
+        """
+        Replacement for _ntl_rep_abs for use in printing and debugging.
+
+        EXAMPLES::
+
+            sage: R.<a> = ZqCA(27, 4)
+            sage: (3+3*a)._flint_rep_abs()
+            (3*x + 3, 0)
+        """
+        return self._flint_rep(var), Integer(0)
+
+    def _modp_rep(self, use_smallest_mode=False, return_list=True):
+        r"""
+        Return the element with the same reduction mod p that can be expressed
+        with coefficients between 0 and p-1.  The absolute precision will be maximal.
+
+        This method is used in printing and computing `p`-adic expansions.
+
+        INPUT:
+
+        - ``use_smallest_mode`` -- if ``True``, use reps between -p/2 and p/2 instead
+        - ``return_list`` -- if ``True``, return a list of coefficients (as integers);
+          for use in printing
+
+        EXAMPLES::
+
+            sage: R.<a> = Qq(27,4)
+            sage: b = a^2 + 5*a - 3
+            sage: b._modp_rep()
+            ((a^2 + 2*a) + O(3^4), [0, 2, 1])
+            sage: b._modp_rep(use_smallest_mode=True)[1]
+            [0, -1, 1]
+        """
+        cdef CAElement rep = self._new_c()
+        rep.absprec = self.prime_pow.prec_cap
+        L = cmodp_rep(rep.value, self.value, smallest_mode if use_smallest_mode else simple_mode, return_list, self.prime_pow)
+        if return_list:
+            return rep, L
+        else:
+            return rep
+
+    def __hash__(self):
+        r"""
+        Raise a :exc:`TypeError` since this element is not hashable
+        (:issue:`11895`).
+
+        TESTS::
+
+            sage: K.<a> = ZqCA(9)
+            sage: hash(a)
+            Traceback (most recent call last):
+            ...
+            TypeError: ...unhashable type: 'sage.rings.padics.qadic_flint_CA.qAdicCappedAbsoluteElement'...
+        """
+        # Eventually, hashing will be disabled for all (non-fixed-mod) p-adic
+        # elements (#11895), until then, we only to this for types which did
+        # not support hashing before we switched some elements to FLINT
+        raise TypeError("unhashable type: 'sage.rings.padics.qadic_flint_CA.qAdicCappedAbsoluteElement'")

sage/rings/padics/qadic_flint_CR.pxd

@@ -0,0 +1,13 @@
+# sage_setup: distribution = sagemath-pari
+
+from sage.libs.flint.types cimport fmpz_poly_t
+from sage.rings.padics.pow_computer_flint cimport PowComputer_flint_unram
+
+cdef class PowComputer_(PowComputer_flint_unram):
+    pass
+ctypedef fmpz_poly_t celement
+
+include "CR_template_header.pxi"
+
+cdef class qAdicCappedRelativeElement(CRElement):
+    pass