passagemath-pari 10.6.32__cp314-cp314-musllinux_1_2_x86_64.whl

sage/rings/finite_rings/finite_field_pari_ffelt.py

@@ -0,0 +1,238 @@
+# sage_setup: distribution = sagemath-pari
+"""
+Finite fields implemented via PARI's FFELT type
+
+AUTHORS:
+
+- Peter Bruin (June 2013): initial version, based on
+  finite_field_ext_pari.py by William Stein et al.
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2013 Peter Bruin <peter.bruin@math.uzh.ch>
+#
+#  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.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+
+from .element_pari_ffelt import FiniteFieldElement_pari_ffelt
+from .finite_field_base import FiniteField
+from .finite_field_constructor import GF
+
+
+class FiniteField_pari_ffelt(FiniteField):
+    """
+    Finite fields whose cardinality is a prime power (not a prime),
+    implemented using PARI's ``FFELT`` type.
+
+    INPUT:
+
+    - ``p`` -- prime number
+
+    - ``modulus`` -- an irreducible polynomial of degree at least 2
+      over the field of `p` elements
+
+    - ``name`` -- string: name of the distinguished generator
+      (default: variable name of ``modulus``)
+
+    OUTPUT:
+
+    A finite field of order `q = p^n`, generated by a distinguished
+    element with minimal polynomial ``modulus``.  Elements are
+    represented as polynomials in ``name`` of degree less than `n`.
+
+    .. NOTE::
+
+        Direct construction of :class:`FiniteField_pari_ffelt` objects
+        requires specifying a characteristic and a modulus.  To
+        construct a finite field by specifying a cardinality and an
+        algorithm for finding an irreducible polynomial, use the
+        ``FiniteField`` constructor with ``impl='pari_ffelt'``.
+
+    EXAMPLES:
+
+    Some computations with a finite field of order 9::
+
+        sage: k = FiniteField(9, 'a', impl='pari_ffelt')
+        sage: k
+        Finite Field in a of size 3^2
+        sage: k.is_field()
+        True
+        sage: k.characteristic()
+        3
+        sage: a = k.gen()
+        sage: a
+        a
+        sage: a.parent()
+        Finite Field in a of size 3^2
+        sage: a.charpoly('x')
+        x^2 + 2*x + 2
+        sage: [a^i for i in range(8)]
+        [1, a, a + 1, 2*a + 1, 2, 2*a, 2*a + 2, a + 2]
+        sage: TestSuite(k).run()                                                        # needs sage.modules
+
+    Next we compute with a finite field of order 16::
+
+        sage: k16 = FiniteField(16, 'b', impl='pari_ffelt')
+        sage: z = k16.gen()
+        sage: z
+        b
+        sage: z.charpoly('x')
+        x^4 + x + 1
+        sage: k16.is_field()
+        True
+        sage: k16.characteristic()
+        2
+        sage: z.multiplicative_order()
+        15
+
+    Illustration of dumping and loading::
+
+        sage: K = FiniteField(7^10, 'b', impl='pari_ffelt')
+        sage: loads(K.dumps()) == K
+        True
+
+        sage: K = FiniteField(10007^10, 'a', impl='pari_ffelt')
+        sage: loads(K.dumps()) == K
+        True
+    """
+    def __init__(self, p, modulus, name=None):
+        """
+        Create a finite field of characteristic `p` defined by the
+        polynomial ``modulus``, with distinguished generator called
+        ``name``.
+
+        EXAMPLES::
+
+            sage: from sage.rings.finite_rings.finite_field_pari_ffelt import FiniteField_pari_ffelt
+            sage: R.<x> = PolynomialRing(GF(3))
+            sage: k = FiniteField_pari_ffelt(3, x^2 + 2*x + 2, 'a'); k
+            Finite Field in a of size 3^2
+        """
+        n = modulus.degree()
+        if n < 2:
+            raise ValueError("the degree must be at least 2")
+
+        FiniteField.__init__(self, base=GF(p), names=name, normalize=True)
+
+        self._modulus = modulus
+        self._degree = n
+
+        self._gen_pari = modulus._pari_with_name(self._names[0]).ffgen()
+        self._zero_element = self.element_class(self, 0)
+        self._one_element = self.element_class(self, 1)
+        self._gen = self.element_class(self, self._gen_pari)
+
+        # Cache for Frobenius endomorphisms (O(n) field elements)
+        self.__pari_frobenius_powers = []
+
+    Element = FiniteFieldElement_pari_ffelt
+
+    def __reduce__(self):
+        """
+        For pickling.
+
+        EXAMPLES::
+
+            sage: k.<b> = FiniteField(5^20, impl='pari_ffelt')
+            sage: type(k)
+            <class 'sage.rings.finite_rings.finite_field_pari_ffelt.FiniteField_pari_ffelt_with_category'>
+            sage: k is loads(dumps(k))
+            True
+        """
+        return self._factory_data[0].reduce_data(self)
+
+    def gen(self, n=0):
+        """
+        Return a generator of ``self`` over its prime field, which is a
+        root of ``self.modulus()``.
+
+        INPUT:
+
+        - ``n`` -- must be 0
+
+        OUTPUT:
+
+        An element `a` of ``self`` such that ``self.modulus()(a) == 0``.
+
+        .. WARNING::
+
+            This generator is not guaranteed to be a generator for the
+            multiplicative group.  To obtain the latter, use
+            :meth:`~sage.rings.finite_rings.finite_field_base.FiniteFields.multiplicative_generator()`
+            or use the ``modulus="primitive"`` option when constructing
+            the field.
+
+        EXAMPLES::
+
+            sage: R.<x> = PolynomialRing(GF(2))
+            sage: FiniteField(2^4, 'b', impl='pari_ffelt').gen()
+            b
+            sage: k = FiniteField(3^4, 'alpha', impl='pari_ffelt')
+            sage: a = k.gen()
+            sage: a
+            alpha
+            sage: a^4
+            alpha^3 + 1
+        """
+        if n:
+            raise IndexError("only one generator")
+        return self._gen
+
+    def characteristic(self):
+        """
+        Return the characteristic of ``self``.
+
+        EXAMPLES::
+
+            sage: F = FiniteField(3^4, 'a', impl='pari_ffelt')
+            sage: F.characteristic()
+            3
+        """
+        # This works since self is not its own prime field.
+        return self.base_ring().characteristic()
+
+    def degree(self):
+        """
+        Return the degree of ``self`` over its prime field.
+
+        EXAMPLES::
+
+            sage: F = FiniteField(3^20, 'a', impl='pari_ffelt')
+            sage: F.degree()
+            20
+        """
+        return self._degree
+
+    def _pari_frobenius(self, k=1):
+        """
+        Return a cached PARI Frobenius endomorphism (internally defined
+        by the image of the generator).
+
+        TESTS::
+
+            sage: F = FiniteField(37^10, 'a', impl='pari_ffelt')
+            sage: x = F.random_element()                                                # needs sage.modules
+            sage: all(x**(37**k) == F(F._pari_frobenius(k).ffmap(x))                    # needs sage.modules
+            ....:     for k in range(1, 30) if k % 10 != 0)
+            True
+            sage: F(F._pari_frobenius(-1).ffmap(x))**37 == x                            # needs sage.modules
+            True
+        """
+        k = k % self.degree()
+        if k == 0:
+            raise ValueError("_pari_frobenius requires a nonzero exponent")
+        g = self.gen()
+        i = len(self.__pari_frobenius_powers)
+        if i == 0:
+            self.__pari_frobenius_powers.append(g.__pari__().fffrobenius(1))
+            i = 1
+        f1 = self.__pari_frobenius_powers[0]
+        while i < k:
+            i += 1
+            fi = self.__pari_frobenius_powers[-1].ffcompomap(f1)
+            self.__pari_frobenius_powers.append(fi)
+        return self.__pari_frobenius_powers[k-1]

sage/rings/finite_rings/hom_finite_field_givaro.pxd

@@ -0,0 +1,28 @@
+# sage_setup: distribution = sagemath-pari
+from sage.rings.finite_rings.hom_finite_field cimport (SectionFiniteFieldHomomorphism_generic,
+    FiniteFieldHomomorphism_generic, FrobeniusEndomorphism_finite_field)
+
+from sage.structure.element cimport Element
+from sage.rings.finite_rings.element_givaro cimport Cache_givaro
+
+
+cdef class SectionFiniteFieldHomomorphism_givaro(SectionFiniteFieldHomomorphism_generic):
+    cdef long _order_codomain
+    cdef long _gcd
+    cdef long _power
+    cdef Cache_givaro _codomain_cache
+
+    cpdef Element _call_(self, x)
+
+
+cdef class FiniteFieldHomomorphism_givaro(FiniteFieldHomomorphism_generic):
+    cdef long _order_domain
+    cdef long _order_codomain
+    cdef long _power
+    cdef Cache_givaro _codomain_cache
+
+    cpdef Element _call_(self, x)
+
+
+cdef class FrobeniusEndomorphism_givaro(FrobeniusEndomorphism_finite_field):
+    pass

sage/rings/finite_rings/hom_finite_field_givaro.pyx

@@ -0,0 +1,280 @@
+# sage_setup: distribution = sagemath-pari
+# distutils: extra_compile_args = -std=c++11
+# distutils: libraries = givaro gmp M_LIBRARIES
+# distutils: language = c++
+"""
+Givaro finite field morphisms
+
+Special implementation for givaro finite fields of:
+
+- embeddings between finite fields
+
+- frobenius endomorphisms
+
+SEEALSO::
+
+    :mod:`sage.rings.finite_rings.hom_finite_field`
+
+AUTHOR:
+
+- Xavier Caruso (2012-06-29)
+"""
+
+# ###########################################################################
+#    Copyright (C) 2012 Xavier Caruso <xavier.caruso@normalesup.org>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+
+from sage.rings.finite_rings.finite_field_constructor import FiniteField
+
+from sage.rings.finite_rings.hom_finite_field cimport SectionFiniteFieldHomomorphism_generic
+from sage.rings.finite_rings.hom_finite_field cimport FiniteFieldHomomorphism_generic
+from sage.rings.finite_rings.hom_finite_field cimport FrobeniusEndomorphism_finite_field
+
+from sage.rings.finite_rings.hom_prime_finite_field cimport FiniteFieldHomomorphism_prime
+
+from sage.categories.homset import Hom
+from sage.structure.element cimport Element
+
+from sage.rings.finite_rings.finite_field_givaro import FiniteField_givaro
+from sage.rings.finite_rings.element_givaro cimport FiniteField_givaroElement
+#from element_givaro cimport make_FiniteField_givaroElement
+
+from sage.structure.parent cimport Parent
+from sage.rings.finite_rings.element_givaro cimport Cache_givaro
+
+
+cdef class SectionFiniteFieldHomomorphism_givaro(SectionFiniteFieldHomomorphism_generic):
+    def __init__(self, inverse):
+        """
+        TESTS::
+
+            sage: from sage.rings.finite_rings.hom_finite_field_givaro import FiniteFieldHomomorphism_givaro
+            sage: k.<t> = GF(3^2)
+            sage: K.<T> = GF(3^4)
+            sage: f = FiniteFieldHomomorphism_givaro(Hom(k, K))
+            sage: g = f.section(); g # random
+            Section of Ring morphism:
+              From: Finite Field in t of size 3^2
+              To:   Finite Field in T of size 3^4
+              Defn: t |--> 2*T^3 + 2*T^2 + 1
+            sage: a = k.random_element()
+            sage: b = k.random_element()
+            sage: g(f(a) + f(b)) == g(f(a)) + g(f(b)) == a + b
+            True
+        """
+        if not isinstance(inverse, FiniteFieldHomomorphism_givaro):
+            raise TypeError("The given map is not an instance of FiniteFieldHomomorphism_givaro")
+        SectionFiniteFieldHomomorphism_generic.__init__(self, inverse)
+
+        cdef long inverse_power = (<FiniteFieldHomomorphism_givaro>inverse)._power
+        cdef long order = self.domain().cardinality() - 1
+        self._order_codomain = self.codomain().cardinality() - 1
+
+        # Compute a = gcd(inverse_power, order)
+        # and solve inverse_power*x = a (mod order)
+        cdef long a = inverse_power, b = order
+        cdef unsigned long q
+        cdef long x = 1, y = 0
+        cdef long sb, sy
+        while b != 0:
+            q = a // b
+            sb = b
+            b = a - q * b
+            a = sb
+            sy = y
+            y = x - q * y
+            x = sy
+
+        self._gcd = a
+        if x < 0:
+            x += order
+        self._power = x % self._order_codomain
+
+        self._codomain_cache = (<FiniteField_givaroElement>(self._codomain.gen()))._cache
+
+    cpdef Element _call_(self, x):
+        """
+        TESTS::
+
+            sage: from sage.rings.finite_rings.hom_finite_field_givaro import FiniteFieldHomomorphism_givaro
+            sage: k.<t> = GF(3^2)
+            sage: K.<T> = GF(3^4)
+            sage: f = FiniteFieldHomomorphism_givaro(Hom(k, K))
+            sage: g = f.section()
+            sage: g(f(t+1))
+            t + 1
+
+            sage: g(T)
+            Traceback (most recent call last):
+            ...
+            ValueError: T is not in the image of Ring morphism:
+              From: Finite Field in t of size 3^2
+              To:   Finite Field in T of size 3^4
+              Defn: t |--> ...
+        """
+        if x.parent() != self.domain():
+            raise TypeError("%s is not in %s" % (x, self.domain()))
+        cdef FiniteField_givaroElement y = <FiniteField_givaroElement?>x
+        if y._cache.objectptr.isZero(y.element):
+            return make_FiniteField_givaroElement(self._codomain_cache, self._codomain_cache.objectptr.zero)
+        if y._cache.objectptr.isOne(y.element):
+            return make_FiniteField_givaroElement(self._codomain_cache, self._codomain_cache.objectptr.one)
+        cdef int log = y.element
+        cdef int q = log / self._gcd
+        if log == q*self._gcd:
+            q = (q*self._power) % self._order_codomain
+            return make_FiniteField_givaroElement(self._codomain_cache, q)
+        else:
+            raise ValueError("%s is not in the image of %s" % (x, self._inverse))
+
+
+cdef class FiniteFieldHomomorphism_givaro(FiniteFieldHomomorphism_generic):
+    def __init__(self, parent, im_gens=None, check=False):
+        """
+        TESTS::
+
+            sage: from sage.rings.finite_rings.hom_finite_field_givaro import FiniteFieldHomomorphism_givaro
+            sage: k.<t> = GF(3^2)
+            sage: K.<T> = GF(3^4)
+            sage: f = FiniteFieldHomomorphism_givaro(Hom(k, K)); f # random
+            Ring morphism:
+              From: Finite Field in t of size 3^2
+              To:   Finite Field in T of size 3^4
+              Defn: t |--> 2*T^3 + 2*T^2 + 1
+            sage: a = k.random_element()
+            sage: b = k.random_element()
+            sage: f(a) + f(b) == f(a + b)
+            True
+
+            sage: k.<t> = GF(3^10)
+            sage: K.<T> = GF(3^20)
+            sage: f = FiniteFieldHomomorphism_givaro(Hom(k, K)); f
+            Traceback (most recent call last):
+            ...
+            TypeError: The codomain is not an instance of FiniteField_givaro
+        """
+        domain = parent.domain()
+        codomain = parent.codomain()
+        if not isinstance(domain, FiniteField_givaro):
+            raise TypeError("The domain is not an instance of FiniteField_givaro")
+        if not isinstance(codomain, FiniteField_givaro):
+            raise TypeError("The codomain is not an instance of FiniteField_givaro")
+
+        FiniteFieldHomomorphism_generic.__init__(self, parent, im_gens, check=check,
+                                                 section_class=SectionFiniteFieldHomomorphism_givaro)
+
+        cdef Cache_givaro domain_cache = (<FiniteField_givaroElement>(domain.gen()))._cache
+        self._codomain_cache = (<FiniteField_givaroElement>(codomain.gen()))._cache
+
+        cdef FiniteField_givaroElement g = make_FiniteField_givaroElement(domain_cache, 1)
+        cdef FiniteField_givaroElement G = FiniteFieldHomomorphism_generic._call_(self, g)
+        self._power = G.element
+
+        self._order_domain = domain.cardinality() - 1
+        self._order_codomain = codomain.cardinality() - 1
+
+    cpdef Element _call_(self, x):
+        """
+        TESTS::
+
+            sage: from sage.rings.finite_rings.hom_finite_field_givaro import FiniteFieldHomomorphism_givaro
+            sage: k.<t> = GF(3^2)
+            sage: K.<T> = GF(3^4)
+            sage: f = FiniteFieldHomomorphism_givaro(Hom(k, K))
+            sage: f(t) # random
+            2*T^3 + 2*T^2 + 1
+            sage: f(t) == f.im_gens()[0]
+            True
+        """
+        if x.parent() != self.domain():
+            raise TypeError("%s is not in %s" % (x, self.domain()))
+        cdef FiniteField_givaroElement y = <FiniteField_givaroElement?>x
+        if y._cache.objectptr.isZero(y.element):
+            return make_FiniteField_givaroElement(self._codomain_cache, self._codomain_cache.objectptr.zero)
+        if y._cache.objectptr.isOne(y.element):
+            return make_FiniteField_givaroElement(self._codomain_cache, self._codomain_cache.objectptr.one)
+        cdef int log = y.element
+        log = (log*self._power) % self._order_codomain
+        return make_FiniteField_givaroElement(self._codomain_cache, log)
+
+
+cdef class FrobeniusEndomorphism_givaro(FrobeniusEndomorphism_finite_field):
+    def __init__(self, domain, power=1):
+        """
+        TESTS::
+
+            sage: k.<t> = GF(5^3)
+            sage: Frob = k.frobenius_endomorphism(); Frob
+            Frobenius endomorphism t |--> t^5 on Finite Field in t of size 5^3
+            sage: type(Frob)
+            <class 'sage.rings.finite_rings.hom_finite_field_givaro.FrobeniusEndomorphism_givaro'>
+
+            sage: k.<t> = GF(5^20)
+            sage: Frob = k.frobenius_endomorphism(); Frob
+            Frobenius endomorphism t |--> t^5 on Finite Field in t of size 5^20
+            sage: type(Frob)
+            <class 'sage.rings.finite_rings.hom_finite_field.FrobeniusEndomorphism_finite_field'>
+        """
+        if not isinstance(domain, FiniteField_givaro):
+            raise TypeError("The domain is not an instance of FiniteField_givaro")
+        FrobeniusEndomorphism_finite_field.__init__(self, domain, power)
+
+    def fixed_field(self):
+        """
+        Return the fixed field of ``self``.
+
+        OUTPUT:
+
+        - a tuple `(K, e)`, where `K` is the subfield of the domain
+          consisting of elements fixed by ``self`` and `e` is an
+          embedding of `K` into the domain.
+
+        .. NOTE::
+
+            The name of the variable used for the subfield (if it
+            is not a prime subfield) is suffixed by ``_fixed``.
+
+        EXAMPLES::
+
+            sage: k.<t> = GF(5^6)
+            sage: f = k.frobenius_endomorphism(2)
+            sage: kfixed, embed = f.fixed_field()
+            sage: kfixed
+            Finite Field in t_fixed of size 5^2
+            sage: embed # random
+            Ring morphism:
+              From: Finite Field in t_fixed of size 5^2
+              To:   Finite Field in t of size 5^6
+              Defn: t_fixed |--> 4*t^5 + 2*t^4 + 4*t^2 + t
+
+            sage: tfixed = kfixed.gen()
+            sage: embed(tfixed) # random
+            4*t^5 + 2*t^4 + 4*t^2 + t
+        """
+        if self._degree_fixed == 1:
+            k = FiniteField(self.domain().characteristic())
+            f = FiniteFieldHomomorphism_prime(Hom(k, self.domain()))
+        else:
+            k = FiniteField(self.domain().characteristic()**self._degree_fixed,
+                            name=self.domain().variable_name() + "_fixed")
+            f = FiniteFieldHomomorphism_givaro(Hom(k, self.domain()))
+        return k, f
+
+
+# copied from element_givaro.pyx
+cdef inline FiniteField_givaroElement make_FiniteField_givaroElement(Cache_givaro cache, int x):
+    cdef FiniteField_givaroElement y
+
+    if cache._has_array:
+        return <FiniteField_givaroElement>cache._array[x]
+    else:
+        y = FiniteField_givaroElement.__new__(FiniteField_givaroElement)
+        y._parent = <Parent> cache.parent
+        y._cache = cache
+        y.element = x
+        return y

sage/rings/finite_rings/residue_field_givaro.pyx

@@ -0,0 +1,133 @@
+# sage_setup: distribution = sagemath-pari
+r"""
+Finite residue fields (Givaro implementation)
+"""
+
+# *****************************************************************************
+#       Copyright (C) 2007-2019 David Roe <roed@math.harvard.edu>
+#                     2007      William Stein <wstein@gmail.com>
+#                     2008      John Cremona
+#                     2008      Robert Bradshaw
+#                     2009      Nick Alexander
+#                     2010      Robert L. Miller
+#                     2010-2013 Simon King
+#                     2010-2017 Jeroen Demeyer
+#                     2012      Travis Scrimshaw
+#                     2016-2021 Frédéric Chapoton
+#                     2021-2022 Antonio Rojas
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  http://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.rings.finite_rings.finite_field_givaro import FiniteField_givaro
+from sage.rings.finite_rings.residue_field import ResidueField_generic, ResidueFieldHomomorphism_global, ReductionMap
+
+
+class ResidueFiniteField_givaro(ResidueField_generic, FiniteField_givaro):
+    """
+    The class representing residue fields of number fields that have non-prime
+    order strictly less than `2^16`.
+
+    EXAMPLES::
+
+        sage: # needs sage.rings.number_field
+        sage: R.<x> = QQ[]
+        sage: K.<a> = NumberField(x^3 - 7)
+        sage: P = K.ideal(29).factor()[0][0]
+        sage: k = K.residue_field(P)
+        sage: k.degree()
+        2
+        sage: OK = K.maximal_order()
+        sage: c = OK(a)
+        sage: b = k(c)
+        sage: b*c^2
+        7
+        sage: b*c
+        13*abar + 5
+
+        sage: R.<t> = GF(7)[]; P = R.ideal(t^2 + 4)
+        sage: k.<a> = R.residue_field(P); type(k)
+        <class 'sage.rings.finite_rings.residue_field_givaro.ResidueFiniteField_givaro_with_category'>
+        sage: k(1/t)
+        5*a
+    """
+    def __init__(self, p, q, name, modulus, to_vs, to_order, PB):
+        r"""
+        INPUT:
+
+        - ``p`` -- the prime ideal defining this residue field
+
+        - ``q`` -- the order of this residue field (a power of intp)
+
+        - ``name`` -- the name of the generator of this extension
+
+        - ``modulus`` -- the polynomial modulus for this extension
+
+        - ``to_vs`` -- the map from the number field (or function field) to
+          the appropriate vector space (over `\QQ` or `F_p(t)`)
+
+        - ``to_order`` -- the map from a lattice in that vector space to the maximal order
+
+        - ``PB`` -- a matrix used in defining the reduction and lifting maps
+
+        EXAMPLES::
+
+            sage: R.<x> = QQ[]
+            sage: K.<a> = NumberField(x^4 + 3*x^2 - 17)                                 # needs sage.rings.number_field
+            sage: P = K.ideal(61).factor()[0][0]                                        # needs sage.rings.number_field
+            sage: k = K.residue_field(P)                                                # needs sage.rings.number_field
+
+            sage: R.<t> = GF(3)[]; P = R.ideal(t^4 - t^3 + t + 1); k.<a> = P.residue_field(); type(k)
+            <class 'sage.rings.finite_rings.residue_field_givaro.ResidueFiniteField_givaro_with_category'>
+            sage: a^5
+            a^3 + 2*a^2 + a + 2
+        """
+        ResidueField_generic.__init__(self, p)
+        FiniteField_givaro.__init__(self, q, name, modulus)
+        K = OK = p.ring()
+        if OK.is_field():
+            OK = OK.ring_of_integers()
+        else:
+            K = K.fraction_field()
+        if PB is None:
+            PBinv = None
+        else:
+            PBinv = PB**(-1)
+        self._populate_coercion_lists_(coerce_list=[self.base_ring(),
+                                                    ResidueFieldHomomorphism_global(OK, self, to_vs, to_order, PB, PBinv)],
+                                       convert_list=[ReductionMap(K, self, to_vs, to_order, PB, PBinv)])
+
+    def _element_constructor_(self, x):
+        """
+        INPUT:
+
+            - ``x`` -- something to cast into ``self``
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.number_field
+            sage: R.<x> = QQ[]
+            sage: K.<a> = NumberField(x^4 + 3*x^2 - 17)
+            sage: P = K.ideal(61).factor()[0][0]
+            sage: k = K.residue_field(P)
+            sage: k(77*a^7 + 4)
+            2*abar + 4
+            sage: V = k.vector_space(map=False); v = V([3,-2])
+            sage: type(k.convert_map_from(V))
+            <class 'sage.structure.coerce_maps.DefaultConvertMap_unique'>
+            sage: k(v)  # indirect doctest
+            59*abar + 3
+
+            sage: R.<t> = GF(3)[]; P = R.ideal(t^4 - t^3 + t + 1); k.<a> = P.residue_field()
+            sage: V = k.vector_space(map=False); v = V([0,1,2,3])                       # needs sage.modules
+            sage: k(v)  # indirect doctest                                              # needs sage.modules
+            2*a^2 + a
+        """
+        try:
+            return FiniteField_givaro._element_constructor_(self, x)
+        except TypeError:
+            return ResidueField_generic._element_constructor_(self, x)