passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/rings/finite_rings/hom_prime_finite_field.pxd

@@ -0,0 +1,15 @@
+# sage_setup: distribution = sagemath-categories
+from sage.rings.finite_rings.hom_finite_field cimport (SectionFiniteFieldHomomorphism_generic,
+    FiniteFieldHomomorphism_generic, FrobeniusEndomorphism_finite_field)
+
+
+cdef class SectionFiniteFieldHomomorphism_prime(SectionFiniteFieldHomomorphism_generic):
+    pass
+
+
+cdef class FiniteFieldHomomorphism_prime(FiniteFieldHomomorphism_generic):
+    pass
+
+
+cdef class FrobeniusEndomorphism_prime(FrobeniusEndomorphism_finite_field):
+    pass

sage/rings/finite_rings/hom_prime_finite_field.pyx

@@ -0,0 +1,164 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Finite field morphisms for prime fields
+
+Special implementation for prime finite field of:
+
+- embeddings of such field into general finite fields
+
+- Frobenius endomorphisms (= identity with our assumptions)
+
+.. 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)
+#
+#                  http://www.gnu.org/licenses/
+#****************************************************************************
+
+from sage.categories.homset import Hom
+from sage.structure.element cimport Element
+
+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.finite_field_base import FiniteField
+
+
+cdef class SectionFiniteFieldHomomorphism_prime(SectionFiniteFieldHomomorphism_generic):
+    cpdef Element _call_(self, x):
+        try:
+            return self._codomain._element_constructor_(x)
+        except TypeError:
+            raise ValueError("%s is not in the image of %s" % (x, self._inverse))
+
+
+cdef class FiniteFieldHomomorphism_prime(FiniteFieldHomomorphism_generic):
+    """
+    A class implementing embeddings of prime finite fields into
+    general finite fields.
+    """
+    def __init__(self, parent, im_gens=None, base_map=None, check=False, section_class=None):
+        """
+        TESTS::
+
+            sage: from sage.rings.finite_rings.hom_prime_finite_field import FiniteFieldHomomorphism_prime
+            sage: k = GF(3)
+            sage: K.<T> = GF(3^4)                                                       # needs sage.rings.finite_rings
+            sage: f = FiniteFieldHomomorphism_prime(Hom(k, K)); f                       # needs sage.rings.finite_rings
+            Ring morphism:
+              From: Finite Field of size 3
+              To:   Finite Field in T of size 3^4
+              Defn: 1 |--> 1
+
+            sage: k.<t> = GF(3^2)                                                       # needs sage.rings.finite_rings
+            sage: K.<T> = GF(3^4)                                                       # needs sage.rings.finite_rings
+            sage: f = FiniteFieldHomomorphism_prime(Hom(k, K)); f                       # needs sage.rings.finite_rings
+            Traceback (most recent call last):
+            ...
+            TypeError: The domain is not a finite prime field
+        """
+        domain = parent.domain()
+        if not isinstance(domain, FiniteField) or not domain.is_prime_field():
+            raise TypeError("The domain is not a finite prime field")
+        if section_class is None:
+            section_class = SectionFiniteFieldHomomorphism_prime
+        FiniteFieldHomomorphism_generic.__init__(self, parent, im_gens, base_map=base_map,
+                                                 check=check, section_class=section_class)
+
+    cpdef Element _call_(self, x):
+        """
+        TESTS::
+
+            sage: # needs sage.rings.finite_rings
+            sage: from sage.rings.finite_rings.hom_prime_finite_field import FiniteFieldHomomorphism_prime
+            sage: k = GF(3)
+            sage: K.<t> = GF(3^5)
+            sage: f = FiniteFieldHomomorphism_prime(Hom(k, K))
+            sage: a = f(4); a
+            1
+            sage: a.parent()
+            Finite Field in t of size 3^5
+        """
+        return self._codomain._element_constructor_(x)
+
+
+cdef class FrobeniusEndomorphism_prime(FrobeniusEndomorphism_finite_field):
+    """
+    A class implementing Frobenius endomorphism on prime finite
+    fields (i.e. identity map :-).
+    """
+    def __init__(self, domain, power=1):
+        if not isinstance(domain, FiniteField) or not domain.is_prime_field():
+            raise TypeError("The domain is not a finite prime field")
+        FrobeniusEndomorphism_finite_field.__init__(self, Hom(domain, domain))
+        self._order = 1
+        self._power = 0
+
+    cpdef Element _call_(self, x):
+        """
+        TESTS::
+
+            sage: k = GF(5)
+            sage: Frob = k.frobenius_endomorphism()
+            sage: Frob(2)
+            2
+        """
+        return x
+
+    def _composition(self, right):
+        """
+        Return ``self`` o ``right``.
+
+        It is always ``right``, since ``self`` is always identity because
+        the domain is a prime field.
+        """
+        return right
+
+    def __pow__(self, n, modulus):
+        """
+        Return the `n`-th iterate of this endomorphism
+        (that is the identity since the domain is a prime
+        field).
+        """
+        return self
+
+    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::
+
+            Since here the domain is a prime field, the subfield
+            is the same prime field and the embedding is necessarily
+            the identity map.
+
+        EXAMPLES::
+
+            sage: k.<t> = GF(5)
+            sage: f = k.frobenius_endomorphism(2); f
+            Identity endomorphism of Finite Field of size 5
+            sage: kfixed, embed = f.fixed_field()
+
+            sage: kfixed == k
+            True
+            sage: [ embed(x) == x for x in kfixed ]
+            [True, True, True, True, True]
+        """
+        return self.domain(), self.domain().hom(self.domain())

sage/rings/finite_rings/homset.py

@@ -0,0 +1,357 @@
+# sage_setup: distribution = sagemath-categories
+# sage.doctest: needs sage.rings.finite_rings
+"""
+Homset for finite fields
+
+This is the set of all field homomorphisms between two finite fields.
+
+EXAMPLES::
+
+    sage: R.<t> = ZZ[]
+    sage: E.<a> = GF(25, modulus = t^2 - 2)
+    sage: F.<b> = GF(625)
+    sage: H = Hom(E, F)
+    sage: f = H([4*b^3 + 4*b^2 + 4*b]); f
+    Ring morphism:
+      From: Finite Field in a of size 5^2
+      To:   Finite Field in b of size 5^4
+      Defn: a |--> 4*b^3 + 4*b^2 + 4*b
+    sage: f(2)
+    2
+    sage: f(a)
+    4*b^3 + 4*b^2 + 4*b
+    sage: len(H)
+    2
+    sage: [phi(2*a)^2 for phi in Hom(E, F)]
+    [3, 3]
+
+We can also create endomorphisms::
+
+    sage: End(E)
+    Automorphism group of Finite Field in a of size 5^2
+    sage: End(GF(7))[0]
+    Ring endomorphism of Finite Field of size 7
+      Defn: 1 |--> 1
+    sage: H = Hom(GF(7), GF(49, 'c'))
+    sage: H[0](2)
+    2
+"""
+
+from sage.rings.homset import RingHomset_generic
+from sage.rings.finite_rings.hom_finite_field import FiniteFieldHomomorphism_generic
+from sage.rings.finite_rings.finite_field_base import FiniteField
+from sage.rings.integer import Integer
+from sage.rings.morphism import RingHomomorphism_im_gens
+from sage.structure.sequence import Sequence
+
+
+class FiniteFieldHomset(RingHomset_generic):
+    """
+    Set of homomorphisms with domain a given finite field.
+    """
+#     def __init__(self, R, S, category=None):
+#         if category is None:
+#             from sage.categories.finite_fields import FiniteFields
+#             category = FiniteFields()
+#         RingHomset_generic.__init__(self, R, S, category)
+
+    def __call__(self, im_gens, base_map=None, check=True):
+        """
+        Construct the homomorphism defined by ``im_gens``.
+
+        EXAMPLES::
+
+            sage: R.<t> = ZZ[]
+            sage: E.<a> = GF(25, modulus = t^2 - 2)
+            sage: F.<b> = GF(625)
+            sage: End(E)
+            Automorphism group of Finite Field in a of size 5^2
+            sage: list(Hom(E, F))
+            [Ring morphism:
+              From: Finite Field in a of size 5^2
+              To:   Finite Field in b of size 5^4
+              Defn: a |--> 4*b^3 + 4*b^2 + 4*b,
+             Ring morphism:
+              From: Finite Field in a of size 5^2
+              To:   Finite Field in b of size 5^4
+              Defn: a |--> b^3 + b^2 + b]
+            sage: [phi(2*a)^2 for phi in Hom(E, F)]
+            [3, 3]
+            sage: End(GF(7))[0]
+            Ring endomorphism of Finite Field of size 7
+              Defn: 1 |--> 1
+            sage: H = Hom(GF(7), GF(49, 'c'))
+            sage: H[0](2)
+            2
+            sage: Hom(GF(49, 'c'), GF(7)).list()
+            []
+            sage: Hom(GF(49, 'c'), GF(81, 'd')).list()
+            []
+            sage: H = Hom(GF(9, 'a'), GF(81, 'b'))
+            sage: H == loads(dumps(H))
+            True
+        """
+        if isinstance(im_gens, FiniteFieldHomomorphism_generic):
+            if base_map is not None:
+                raise ValueError("Cannot specify base map when providing morphism")
+            return self._coerce_impl(im_gens)
+        try:
+            if self.domain().degree() == 1:
+                from sage.rings.finite_rings.hom_prime_finite_field import FiniteFieldHomomorphism_prime
+                return FiniteFieldHomomorphism_prime(self, im_gens, base_map=base_map, check=check)
+            if isinstance(self.codomain(), FiniteField):
+                return FiniteFieldHomomorphism_generic(self, im_gens, base_map=base_map, check=check)
+            # Currently, FiniteFieldHomomorphism_generic does not work if
+            # the codomain is not derived from the finite field base class;
+            # in that case, we have to fall back to the generic
+            # implementation for rings
+            else:
+                return RingHomomorphism_im_gens(self, im_gens, base_map=base_map, check=check)
+        except (NotImplementedError, ValueError):
+            try:
+                return self._coerce_impl(im_gens)
+            except TypeError:
+                raise TypeError("images do not define a valid homomorphism")
+
+    def _coerce_impl(self, x):
+        """
+        Coercion of other morphisms.
+
+        EXAMPLES::
+
+            sage: k.<a> = GF(25)
+            sage: l.<b> = GF(625)
+            sage: H = Hom(k, l)
+            sage: G = loads(dumps(H))
+            sage: H is G
+            True
+            sage: G.coerce(list(H)[0]) # indirect doctest
+            Ring morphism:
+              From: Finite Field in a of size 5^2
+              To:   Finite Field in b of size 5^4
+              Defn: a |--> 4*b^3 + 4*b^2 + 4*b + 3
+        """
+        if not isinstance(x, FiniteFieldHomomorphism_generic):
+            raise TypeError
+        if x.parent() is self:
+            return x
+        if x.parent() == self:
+            return FiniteFieldHomomorphism_generic(self, x.im_gens())
+        raise TypeError
+
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: Hom(GF(4, 'a'), GF(16, 'b'))._repr_()
+            'Set of field embeddings from Finite Field in a of size 2^2 to Finite Field in b of size 2^4'
+            sage: Hom(GF(4, 'a'), GF(4, 'c'))._repr_()
+            'Set of field embeddings from Finite Field in a of size 2^2 to Finite Field in c of size 2^2'
+            sage: Hom(GF(4, 'a'), GF(4, 'a'))._repr_()
+            'Automorphism group of Finite Field in a of size 2^2'
+        """
+        D = self.domain()
+        C = self.codomain()
+        if C == D:
+            return "Automorphism group of %s" % D
+        else:
+            return "Set of field embeddings from %s to %s" % (D, C)
+
+    def is_aut(self):
+        """
+        Check if ``self`` is an automorphism.
+
+        EXAMPLES::
+
+            sage: Hom(GF(4, 'a'), GF(16, 'b')).is_aut()
+            False
+            sage: Hom(GF(4, 'a'), GF(4, 'c')).is_aut()
+            False
+            sage: Hom(GF(4, 'a'), GF(4, 'a')).is_aut()
+            True
+        """
+        return self.domain() == self.codomain()
+
+    def order(self):
+        """
+        Return the order of this set of field homomorphisms.
+
+        EXAMPLES::
+
+            sage: K.<a> = GF(125)
+            sage: End(K)
+            Automorphism group of Finite Field in a of size 5^3
+            sage: End(K).order()
+            3
+            sage: L.<b> = GF(25)
+            sage: Hom(L, K).order() == Hom(K, L).order() == 0
+            True
+        """
+        try:
+            return self.__order
+        except AttributeError:
+            pass
+        n = len(self.list())
+        self.__order = n
+        return n
+
+    def __len__(self):
+        """
+        Return the number of elements of ``self``.
+
+        EXAMPLES::
+
+            sage: K.<a> = GF(25)
+            sage: len(End(K))
+            2
+        """
+        return self.order()
+
+    def list(self):
+        """
+        Return a list of all the elements in this set of field homomorphisms.
+
+        EXAMPLES::
+
+            sage: K.<a> = GF(25)
+            sage: End(K)
+            Automorphism group of Finite Field in a of size 5^2
+            sage: list(End(K))
+            [Ring endomorphism of Finite Field in a of size 5^2
+              Defn: a |--> 4*a + 1,
+             Ring endomorphism of Finite Field in a of size 5^2
+              Defn: a |--> a]
+            sage: L.<z> = GF(7^6)
+            sage: [g for g in End(L) if (g^3)(z) == z]
+            [Ring endomorphism of Finite Field in z of size 7^6
+              Defn: z |--> z,
+             Ring endomorphism of Finite Field in z of size 7^6
+              Defn: z |--> 5*z^4 + 5*z^3 + 4*z^2 + 3*z + 1,
+             Ring endomorphism of Finite Field in z of size 7^6
+              Defn: z |--> 3*z^5 + 5*z^4 + 5*z^2 + 2*z + 3]
+
+        Between isomorphic fields with different moduli::
+
+            sage: k1 = GF(1009)
+            sage: k2 = GF(1009, modulus='primitive')
+            sage: Hom(k1, k2).list()
+            [Ring morphism:
+               From: Finite Field of size 1009
+               To:   Finite Field of size 1009
+               Defn: 1 |--> 1]
+            sage: Hom(k2, k1).list()
+            [Ring morphism:
+               From: Finite Field of size 1009
+               To:   Finite Field of size 1009
+               Defn: 11 |--> 11]
+
+            sage: k1.<a> = GF(1009^2, modulus='first_lexicographic')
+            sage: k2.<b> = GF(1009^2, modulus='conway')
+            sage: Hom(k1, k2).list()
+            [Ring morphism:
+               From: Finite Field in a of size 1009^2
+               To:   Finite Field in b of size 1009^2
+               Defn: a |--> 290*b + 864,
+             Ring morphism:
+               From: Finite Field in a of size 1009^2
+               To:   Finite Field in b of size 1009^2
+               Defn: a |--> 719*b + 145]
+
+        TESTS:
+
+        Check that :issue:`11390` is fixed::
+
+            sage: K = GF(1<<16,'a'); L = GF(1<<32,'b')
+            sage: K.Hom(L)[0]
+            Ring morphism:
+              From: Finite Field in a of size 2^16
+              To:   Finite Field in b of size 2^32
+              Defn: a |--> b^29 + b^27 + b^26 + b^23 + b^21 + b^19 + b^18 + b^16 + b^14 + b^13 + b^11 + b^10 + b^9 + b^8 + b^7 + b^6 + b^5 + b^2 + b
+        """
+        try:
+            return self.__list
+        except AttributeError:
+            pass
+        D = self.domain()
+        C = self.codomain()
+        if D.characteristic() == C.characteristic() and Integer(D.degree()).divides(Integer(C.degree())):
+            f = D.modulus()
+            g = C['x'](f)
+            r = g.roots()
+            v = [self(D.hom(a, C)) for a, _ in r]
+            v = Sequence(v, immutable=True, cr=True)
+        else:
+            v = Sequence([], immutable=True, cr=False)
+        self.__list = v
+        return v
+
+    def __getitem__(self, n):
+        """
+        EXAMPLES::
+
+            sage: H = Hom(GF(32, 'a'), GF(1024, 'b'))
+            sage: H[1]
+            Ring morphism:
+              From: Finite Field in a of size 2^5
+              To:   Finite Field in b of size 2^10
+              Defn: a |--> b^7 + b^5
+            sage: H[2:4]
+            [Ring morphism:
+               From: Finite Field in a of size 2^5
+               To:   Finite Field in b of size 2^10
+               Defn: a |--> b^8 + b^6 + b^2,
+             Ring morphism:
+               From: Finite Field in a of size 2^5
+               To:   Finite Field in b of size 2^10
+               Defn: a |--> b^9 + b^7 + b^6 + b^5 + b^4]
+        """
+        return self.list()[n]
+
+    def index(self, item):
+        """
+        Return the index of ``self``.
+
+        EXAMPLES::
+
+            sage: K.<z> = GF(1024)
+            sage: g = End(K)[3]
+            sage: End(K).index(g) == 3
+            True
+        """
+        return self.list().index(item)
+
+    def _an_element_(self):
+        """
+        Return an element of ``self``.
+
+        TESTS::
+
+            sage: Hom(GF(3^3, 'a'), GF(3^6, 'b')).an_element()  # random
+            Ring morphism:
+              From: Finite Field in a of size 3^3
+              To:   Finite Field in b of size 3^6
+              Defn: a |--> 2*b^5 + 2*b^4
+
+            sage: Hom(GF(3^3, 'a'), GF(3^2, 'c')).an_element()
+            Traceback (most recent call last):
+            ...
+            EmptySetError: no homomorphisms from Finite Field in a of size 3^3 to Finite Field in c of size 3^2
+
+        .. TODO::
+
+            Use a more sophisticated algorithm; see also :issue:`8751`.
+        """
+        K = self.domain()
+        L = self.codomain()
+        if K.degree() == 1:
+            return L.coerce_map_from(K)
+        elif not K.degree().divides(L.degree()):
+            from sage.categories.sets_cat import EmptySetError
+            raise EmptySetError('no homomorphisms from %s to %s' % (K, L))
+        return K.hom([K.modulus().any_root(L)])
+
+
+from sage.misc.persist import register_unpickle_override
+register_unpickle_override('sage.rings.finite_field_morphism', 'FiniteFieldHomset', FiniteFieldHomset)

sage/rings/finite_rings/integer_mod.pxd

@@ -0,0 +1,56 @@
+# sage_setup: distribution = sagemath-categories
+from sage.libs.gmp.types cimport *
+from sage.rings.finite_rings.stdint cimport *
+from sage.rings.finite_rings.element_base cimport FiniteRingElement
+from sage.rings.integer cimport Integer
+
+
+cdef class NativeIntStruct:
+    cdef Integer sageInteger
+    cdef int_fast32_t int32
+    cdef int_fast64_t int64
+    cdef readonly list table     # list of elements of IntegerModRing(n)
+    cdef readonly list inverses  # list of inverses (None if not invertible)
+    cdef inline type element_class(self):
+        if self.int32 > 0:
+            return IntegerMod_int
+        elif self.int64 > 0:
+            return IntegerMod_int64
+        else:
+            return IntegerMod_gmp
+
+
+cdef class IntegerMod_abstract(FiniteRingElement):
+    cdef NativeIntStruct _modulus
+    cdef _new_c_from_long(self, long value)
+    cdef IntegerMod_abstract _new_c_fast(self, unsigned long value)
+    cdef void set_from_mpz(self, mpz_t value) noexcept
+    cdef void set_from_long(self, long value) noexcept
+    cdef void set_from_ulong_fast(self, unsigned long value) noexcept
+    cdef bint is_square_c(self) except -2
+    cpdef bint is_one(self) noexcept
+    cpdef bint is_unit(self) noexcept
+    cpdef _floordiv_(self, other)
+
+cdef class IntegerMod_gmp(IntegerMod_abstract):
+    cdef mpz_t value
+    cdef IntegerMod_gmp _new_c(self)
+    cdef shift(IntegerMod_gmp self, long k)
+
+cdef class IntegerMod_int(IntegerMod_abstract):
+    cdef int_fast32_t ivalue
+    cdef void set_from_int(IntegerMod_int self, int_fast32_t value) noexcept
+    cdef int_fast32_t get_int_value(IntegerMod_int self) noexcept
+    cdef IntegerMod_int _new_c(self, int_fast32_t value)
+    cdef shift(IntegerMod_int self, int k)
+
+cdef class IntegerMod_int64(IntegerMod_abstract):
+    cdef int_fast64_t ivalue
+    cdef void set_from_int(IntegerMod_int64 self, int_fast64_t value) noexcept
+    cdef int_fast64_t get_int_value(IntegerMod_int64 self) noexcept
+    cdef IntegerMod_int64 _new_c(self, int_fast64_t value)
+    cdef shift(IntegerMod_int64 self, int k)
+
+
+cdef int_fast32_t mod_inverse_int(int_fast32_t x, int_fast32_t n) except 0
+cdef bint use_32bit_type(int_fast64_t modulus) noexcept