passagemath-modules 10.5.46__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/modules/free_module.py

@@ -985,7 +985,7 @@ class Module_free_ambient(Module):
         """
         return self.__degree
 
-    def is_sparse(self):
+    def is_sparse(self) -> bool:
         """
         Return ``True`` if the underlying representation of this module uses
         sparse vectors, and ``False`` otherwise.
@@ -999,7 +999,7 @@ class Module_free_ambient(Module):
         """
         return self.__is_sparse
 
-    def is_exact(self):
+    def is_exact(self) -> bool:
         """
         Test whether elements of this module are represented exactly.
 
@@ -1518,7 +1518,7 @@ class Module_free_ambient(Module):
         # in the same ambient space
         return self.is_submodule(other) and other.is_submodule(self)
 
-    def is_submodule(self, other):
+    def is_submodule(self, other) -> bool:
         r"""
         Return ``True`` if ``self`` is a submodule of ``other``.
 
@@ -2307,7 +2307,7 @@ class FreeModule_generic(Module_free_ambient):
             return self.echelonized_basis_matrix() == other.echelonized_basis_matrix()
         return self.is_submodule(other) and other.is_submodule(self)
 
-    def is_submodule(self, other):
+    def is_submodule(self, other) -> bool:
         r"""
         Return ``True`` if ``self`` is a submodule of ``other``.
 
@@ -3117,6 +3117,135 @@ class FreeModule_generic(Module_free_ambient):
             codomain = R**n
         return super().hom(im_gens, codomain, **kwds)
 
+    def pseudoHom(self, twist, codomain=None):
+        r"""
+        Return the pseudo-Hom space corresponding to given data.
+
+        INPUT:
+
+        - ``twist`` -- the twisting morphism or the twisting derivation
+
+        - ``codomain`` -- (default: ``None``) the codomain of the pseudo
+          morphisms; if ``None``, the codomain is the same as the domain
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.finite_rings
+            sage: F = GF(25)
+            sage: Frob = F.frobenius_endomorphism()
+            sage: M = F^2
+            sage: M.pseudoHom(Frob)
+            Set of Pseudoendomorphisms (twisted by z2 |--> z2^5) of Vector space of dimension 2 over Finite Field in z2 of size 5^2
+
+        .. SEEALSO::
+
+            :meth:`pseudohom`
+        """
+        from sage.modules.free_module_pseudohomspace import FreeModulePseudoHomspace
+        if codomain is None:
+            codomain = self
+        return FreeModulePseudoHomspace(self, codomain, twist)
+
+    def pseudohom(self, f, twist, codomain=None, side="left"):
+        r"""
+        Return the pseudohomomorphism corresponding to the given data.
+
+        We recall that, given two `R`-modules `M` and `M'` together with
+        a ring homomorphism `\theta: R \to R` and a `\theta`-derivation,
+        `\delta: R \to R` (that is, a map such that
+        `\delta(xy) = \theta(x)\delta(y) + \delta(x)y`), a
+        pseudomorphism `f : M \to M'` is an additive map such that
+
+        .. MATH::
+
+            f(\lambda x) = \theta(\lambda) f(x) + \delta(\lambda) x
+
+        When `\delta` is nonzero, this requires that `M` coerces into `M'`.
+
+        .. NOTE::
+
+            Internally, pseudomorphisms are represented by matrices with
+            coefficient in the base ring `R`. See class
+            :class:`sage.modules.free_module_pseudomorphism.FreeModulePseudoMorphism`
+            for details.
+
+        INPUT:
+
+        - ``f`` -- a matrix (or any other data) defining the
+          pseudomorphism
+
+        - ``twist`` -- the twisting morphism or the twisting derivation
+          (if a derivation is given, the corresponding morphism `\theta`
+          is automatically infered;
+          see also :class:`sage.rings.polynomial.ore_polynomial_ring.OrePolynomialRing`)
+
+        - ``codomain`` -- (default: ``None``) the codomain of the pseudo
+          morphisms; if ``None``, the codomain is the same than the domain
+
+        - ``side`` -- (default: ``left``) side of the vectors acted on by
+          the matrix
+
+        EXAMPLES::
+
+            sage: # needs sage.rings.finite_rings
+            sage: K.<z> = GF(5^5)
+            sage: Frob = K.frobenius_endomorphism()
+            sage: V = K^2; W = K^3
+            sage: f = V.pseudohom([[1, z, z^2], [1, z^2, z^4]], Frob, codomain=W)
+            sage: f
+            Free module pseudomorphism (twisted by z |--> z^5) defined by the matrix
+            [  1   z z^2]
+            [  1 z^2 z^4]
+            Domain: Vector space of dimension 2 over Finite Field in z of size 5^5
+            Codomain: Vector space of dimension 3 over Finite Field in z of size 5^5
+
+        We check that `f` is indeed semi-linear::
+
+            sage: # needs sage.rings.finite_rings
+            sage: v = V([z+1, z+2])
+            sage: f(z*v)
+            (2*z^2 + z + 4, z^4 + 2*z^3 + 3*z^2 + z, 4*z^4 + 2*z^2 + 3*z + 2)
+            sage: z^5 * f(v)
+            (2*z^2 + z + 4, z^4 + 2*z^3 + 3*z^2 + z, 4*z^4 + 2*z^2 + 3*z + 2)
+
+        An example with a derivation::
+
+            sage: # needs sage.rings.finite_rings
+            sage: R.<t> = ZZ[]
+            sage: d = R.derivation()
+            sage: M = R^2
+            sage: Nabla = M.pseudohom([[1, t], [t^2, t^3]], d, side='right')
+            sage: Nabla
+            Free module pseudomorphism (twisted by d/dt) defined as left-multiplication by the matrix
+            [  1   t]
+            [t^2 t^3]
+            Domain: Ambient free module of rank 2 over the integral domain Univariate Polynomial Ring in t over Integer Ring
+            Codomain: Ambient free module of rank 2 over the integral domain Univariate Polynomial Ring in t over Integer Ring
+            sage: v = M([1,1])
+            sage: Nabla(v)
+            (t + 1, t^3 + t^2)
+            sage: Nabla(t*v)
+            (t^2 + t + 1, t^4 + t^3 + 1)
+            sage: Nabla(t*v) == t * Nabla(v) + v
+            True
+
+        If the twisting derivation is not zero, the domain must
+        coerce into the codomain::
+
+            sage: # needs sage.rings.finite_rings
+            sage: N = R^3
+            sage: M.pseudohom([[1, t, t^2], [1, t^2, t^4]], d, codomain=N)
+            Traceback (most recent call last):
+            ...
+            ValueError: the domain does not coerce into the codomain
+
+        .. SEEALSO::
+
+            :meth:`pseudoHom`
+        """
+        H = self.pseudoHom(twist, codomain)
+        return H(f, side)
+
     def inner_product_matrix(self):
         """
         Return the default identity inner product matrix associated to this
@@ -3164,7 +3293,7 @@ class FreeModule_generic(Module_free_ambient):
         """
         return True
 
-    def is_ambient(self):
+    def is_ambient(self) -> bool:
         """
         Return ``False`` since this is not an ambient free module.
 
@@ -3189,7 +3318,7 @@ class FreeModule_generic(Module_free_ambient):
         """
         return False
 
-    def is_dense(self):
+    def is_dense(self) -> bool:
         """
         Return ``True`` if the underlying representation of
         this module uses dense vectors, and ``False`` otherwise.
@@ -3203,7 +3332,7 @@ class FreeModule_generic(Module_free_ambient):
         """
         return not self.is_sparse()
 
-    def is_full(self):
+    def is_full(self) -> bool:
         """
         Return ``True`` if the rank of this module equals its
         degree.
@@ -3218,7 +3347,7 @@ class FreeModule_generic(Module_free_ambient):
         """
         return self.rank() == self.degree()
 
-    def is_finite(self):
+    def is_finite(self) -> bool:
         """
         Return ``True`` if the underlying set of this free module is finite.
 
@@ -4634,7 +4763,7 @@ class FreeModule_generic_field(FreeModule_generic_pid):
         B = [A1.linear_combination_of_rows(v.list()[:n]) for v in K.basis()]
         return self.ambient_vector_space().submodule(B, check=False)
 
-    def is_subspace(self, other):
+    def is_subspace(self, other) -> bool:
         """
         ``True`` if this vector space is a subspace of ``other``.
 
@@ -5681,7 +5810,7 @@ class FreeModule_ambient(FreeModule_generic):
             t = "(%s)" % t
         return "%s^{%s}" % (t, self.rank())
 
-    def is_ambient(self):
+    def is_ambient(self) -> bool:
         """
         Return ``True`` since this module is an ambient
         module.
@@ -7513,7 +7642,7 @@ class FreeModule_submodule_with_basis_pid(FreeModule_generic_pid):
         """
         return FreeModule(self.base_ring().fraction_field(), self.rank())(self.echelon_coordinates(v, check=check))
 
-    def has_user_basis(self):
+    def has_user_basis(self) -> bool:
         """
         Return ``True`` if the basis of this free module is
         specified by the user, as opposed to being the default echelon
@@ -7663,7 +7792,7 @@ class FreeModule_submodule_pid(FreeModule_submodule_with_basis_pid):
         """
         return self.echelon_coordinate_vector(v, check=check)
 
-    def has_user_basis(self):
+    def has_user_basis(self) -> bool:
         r"""
         Return ``True`` if the basis of this free module is
         specified by the user, as opposed to being the default echelon
@@ -7895,9 +8024,9 @@ class FreeModule_submodule_with_basis_field(FreeModule_generic_field, FreeModule
         # Return the first rank rows (i.e., the nonzero rows).
         return E.rows()[:E.rank()]
 
-    def is_ambient(self):
+    def is_ambient(self) -> bool:
         """
-        Return False since this is not an ambient module.
+        Return ``False`` since this is not an ambient module.
 
         EXAMPLES::
 
@@ -8150,7 +8279,7 @@ class FreeModule_submodule_field(FreeModule_submodule_with_basis_field):
         """
         return self.echelon_coordinate_vector(v, check=check)
 
-    def has_user_basis(self):
+    def has_user_basis(self) -> bool:
         """
         Return ``True`` if the basis of this free module is
         specified by the user, as opposed to being the default echelon

sage/modules/free_module_element.pyx

@@ -3620,9 +3620,9 @@ cdef class FreeModuleElement(Vector):   # abstract base class
             ...
             ArithmeticError: degrees (1 and 2) must be the same
         """
-        return (self.conjugate()).dot_product(right)
+        return self.conjugate().dot_product(right)
 
-    def is_dense(self):
+    def is_dense(self) -> bool:
         """
         Return ``True`` if this is a dense vector, which is just a
         statement about the data structure, not the number of nonzero
@@ -3640,7 +3640,7 @@ cdef class FreeModuleElement(Vector):   # abstract base class
     cdef bint is_dense_c(self) noexcept:
         return self.parent().is_dense()
 
-    def is_sparse(self):
+    def is_sparse(self) -> bool:
         """
         Return ``True`` if this is a sparse vector, which is just a
         statement about the data structure, not the number of nonzero
@@ -3658,7 +3658,7 @@ cdef class FreeModuleElement(Vector):   # abstract base class
     cdef bint is_sparse_c(self) noexcept:
         return self.parent().is_sparse()
 
-    def is_vector(self):
+    def is_vector(self) -> bool:
         """
         Return ``True``, since this is a vector.
 

sage/modules/free_module_integer.py

@@ -319,7 +319,7 @@ class FreeModule_submodule_with_basis_integer(FreeModule_submodule_with_basis_pi
             True
 
             sage: LLL = L.LLL()
-            sage: LLL == L.reduced_basis or bool(LLL[0].norm() >= M[0].norm())
+            sage: LLL == L.reduced_basis or bool(LLL[0].norm() >= M[0].norm())          # needs sage.symbolic
             True
         """
         return self._reduced_basis
@@ -511,7 +511,7 @@ class FreeModule_submodule_with_basis_integer(FreeModule_submodule_with_basis_pi
         return abs(self.gram_matrix().determinant())
 
     @cached_method
-    def is_unimodular(self):
+    def is_unimodular(self) -> bool:
         """
         Return ``True`` if this lattice is unimodular.
 

sage/modules/free_module_morphism.py

@@ -659,7 +659,7 @@ class BaseIsomorphism1D(Morphism):
                 Multivariate Polynomial Ring in x, y over Rational Field
           To:   Multivariate Polynomial Ring in x, y over Rational Field
     """
-    def _repr_type(self):
+    def _repr_type(self) -> str:
         r"""
         EXAMPLES::
 
@@ -670,7 +670,7 @@ class BaseIsomorphism1D(Morphism):
         """
         return "Isomorphism"
 
-    def is_injective(self):
+    def is_injective(self) -> bool:
         r"""
         EXAMPLES::
 
@@ -681,7 +681,7 @@ class BaseIsomorphism1D(Morphism):
         """
         return True
 
-    def is_surjective(self):
+    def is_surjective(self) -> bool:
         r"""
         EXAMPLES::
 

sage/modules/free_module_pseudohomspace.py

@@ -0,0 +1,352 @@
+# sage_setup: distribution = sagemath-modules
+# sage.doctest: needs sage.rings.finite_rings
+"""
+Space of pseudomorphisms of free modules
+
+AUTHORS:
+
+- Xavier Caruso, Yossef Musleh (2024-09): initial version
+"""
+# ****************************************************************************
+#  Copyright (C) 2024 Xavier Caruso <xavier.caruso@normalesup.org>
+#                     Yossef Musleh <specialholonomy@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty
+#    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+#  See the GNU General Public License for more details; the full text
+#  is available at:
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.structure.unique_representation import UniqueRepresentation
+
+from sage.categories.homset import HomsetWithBase
+from sage.matrix.matrix_space import MatrixSpace
+from sage.structure.sequence import Sequence
+from sage.rings.polynomial.ore_polynomial_ring import OrePolynomialRing
+from sage.modules.free_module_pseudomorphism import FreeModulePseudoMorphism
+
+
+class FreeModulePseudoHomspace(UniqueRepresentation, HomsetWithBase):
+    r"""
+    This class implements the space of pseudomorphisms with a fixed twist.
+
+    For free modules, the elements of a pseudomorphism correspond to matrices
+    which define the mapping on elements of a basis.
+
+    This class is not supposed to be instantiated directly; the user should
+    use instead the method :meth:`sage.rings.module.free_module.FreeModule_generic.pseudoHom`
+    to create a space of pseudomorphisms.
+
+    TESTS::
+
+        sage: F = GF(125)
+        sage: M = F^2
+        sage: Frob = F.frobenius_endomorphism()
+        sage: PHS = M.pseudoHom(Frob)
+        sage: h = PHS([[1, 2], [1, 1]])
+        sage: e = M((4*F.gen()^2 + F.gen() + 2, 4*F.gen()^2 + 4*F.gen() + 4))
+        sage: h(e)
+        (z3, 2*z3^2 + 3*z3 + 3)
+    """
+    Element = FreeModulePseudoMorphism
+
+    @staticmethod
+    def __classcall_private__(cls, domain, codomain, twist):
+        r"""
+        Constructs the space of pseudomorphisms with a given twist.
+
+        INPUT:
+
+        - ``domain`` -- a free module,  the domain of this pseudomorphism
+
+        - ``codomain`` -- a free module, the codomain of this pseudomorphism
+
+        - ``twist`` -- a twisting morphism/derivation or the corresponding
+          Ore polynomial ring
+
+        TESTS::
+
+            sage: F = GF(125)
+            sage: Frob = F.frobenius_endomorphism()
+            sage: M = F^2
+            sage: H = M.pseudoHom(Frob)
+            sage: type(H)
+            <class 'sage.modules.free_module_pseudohomspace.FreeModulePseudoHomspace_with_category'>
+
+            sage: TestSuite(H).run()
+        """
+        ring = domain.base_ring()
+        if codomain.base_ring() is not ring:
+            raise ValueError("the domain and the codomain must be defined over the same ring")
+        if isinstance(twist, OrePolynomialRing):
+            ore = twist
+            if ore.base_ring() is not ring:
+                raise ValueError("base rings do not match")
+        else:
+            ore = OrePolynomialRing(ring, twist, names='x', polcast=False)
+        if ore._derivation is not None:
+            if not codomain.has_coerce_map_from(domain):
+                raise ValueError("the domain does not coerce into the codomain")
+        return cls.__classcall__(cls, domain, codomain, ore)
+
+    def __init__(self, domain, codomain, ore):
+        r"""
+        Initialize this pseudohom space.
+
+        INPUT:
+
+        - ``domain`` -- a free module,  the domain of this pseudomorphism
+
+        - ``codomain`` -- a free module, the codomain of this pseudomorphism
+
+        - ``ore`` -- the underlying Ore polynomial ring (built from the
+          twisting morphism and derivation)
+
+        TESTS::
+
+            sage: F = GF(125)
+            sage: Frob = F.frobenius_endomorphism()
+            sage: M = F^2
+            sage: M.pseudoHom(Frob)
+            Set of Pseudoendomorphisms (twisted by z3 |--> z3^5) of
+            Vector space of dimension 2 over Finite Field in z3 of size 5^3
+        """
+        self._domain = domain
+        self._codomain = codomain
+        super().__init__(domain, codomain, category=None)
+        self._ore = ore
+        if isinstance(ore, OrePolynomialRing):
+            self._morphism = ore._morphism
+            self._derivation = ore._derivation
+        else:
+            self._morphism = self._derivation = None
+        ring = ore.base_ring()
+        self._matrix_space = MatrixSpace(ring, domain.dimension(), codomain.dimension())
+
+    def _element_constructor_(self, f, side="left"):
+        r"""
+        Return the element of this parent constructed from the
+        given data.
+
+        TESTS::
+
+            sage: F.<z> = GF(5^3)
+            sage: Frob = F.frobenius_endomorphism()
+            sage: V = F^2
+            sage: H = V.pseudoHom(Frob)
+
+            sage: H([[1, z], [z, z^2]])
+            Free module pseudomorphism (twisted by z |--> z^5) defined by the matrix
+            [  1   z]
+            [  z z^2]
+            Domain: Vector space of dimension 2 over Finite Field in z of size 5^3
+            Codomain: Vector space of dimension 2 over Finite Field in z of size 5^3
+        """
+        return self.element_class(self, f, side)
+
+    def __reduce__(self):
+        r"""
+        TESTS::
+
+            sage: F = GF(125)
+            sage: Frob = F.frobenius_endomorphism()
+            sage: M = F^2
+            sage: H = M.pseudoHom(Frob)
+            sage: loads(dumps(M)) is M
+            True
+        """
+        if self._derivation is None:
+            twist = self._morphism
+        else:
+            twist = self._derivation
+        return FreeModulePseudoHomspace, (self.domain(), self.codomain(), twist)
+
+    def _repr_(self):
+        r"""
+        Returns a string representation of this pseudomorphism space.
+
+        EXAMPLES::
+
+            sage: Fq = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: V.pseudoHom(Frob)  # indirect doctest
+            Set of Pseudoendomorphisms (twisted by z3 |--> z3^7) of
+            Vector space of dimension 2 over Finite Field in z3 of size 7^3
+
+        ::
+
+            sage: V.pseudoHom(Frob, codomain=Fq^3)  # indirect doctest
+            Set of Pseudomorphism (twisted by z3 |--> z3^7)
+            from Vector space of dimension 2 over Finite Field in z3 of size 7^3
+            to Vector space of dimension 3 over Finite Field in z3 of size 7^3
+
+        ::
+
+            sage: A.<t> = QQ[]
+            sage: d = A.derivation()
+            sage: M = A^3
+            sage: M.pseudoHom(d)
+            Set of Pseudoendomorphisms (twisted by d/dt) of Ambient free module of rank 3 over
+            the principal ideal domain Univariate Polynomial Ring in t over Rational Field
+        """
+        twist = self._ore._repr_twist()
+        if self.domain() is self.codomain():
+            return "Set of Pseudoendomorphisms (%s) of %s" % (twist, self.domain())
+        else:
+            return "Set of Pseudomorphism (%s) from %s to %s" % (twist, self.domain(), self.codomain())
+
+    def ore_ring(self, var='x'):
+        r"""
+        Return the underlying Ore polynomial ring, that is
+        the Ore polynomial ring over the base field twisted
+        by the twisting morphism and the twisting derivation
+        attached to this homspace.
+
+        INPUT:
+
+        - ``var`` -- string (default: ``x``) the name of
+          the variable
+
+        EXAMPLES::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: H = V.pseudoHom(Frob)
+
+            sage: H.ore_ring()
+            Ore Polynomial Ring in x over Finite Field in z of size 7^3 twisted by z |--> z^7
+
+            sage: H.ore_ring('y')
+            Ore Polynomial Ring in y over Finite Field in z of size 7^3 twisted by z |--> z^7
+        """
+        return self._ore.change_var(var)
+
+    def matrix_space(self):
+        r"""
+        Return the matrix space used for representing the
+        pseudomorphisms in this space.
+
+        EXAMPLES::
+
+            sage: Fq.<z> = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: W = Fq^3
+            sage: H = V.pseudoHom(Frob, codomain=W)
+            sage: H.matrix_space()
+            Full MatrixSpace of 2 by 3 dense matrices over Finite Field in z of size 7^3
+        """
+        return self._matrix_space
+
+    def basis(self, side="left"):
+        r"""
+        Return a basis for the underlying matrix space.
+
+        The result does not depend on the `side` of the homspace, i.e.
+        if matrices are acted upon on the left or on the right.
+
+        EXAMPLES::
+
+            sage: Fq = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: PHS = V.pseudoHom(Frob)
+            sage: PHS.basis()
+            [Free module pseudomorphism (twisted by z3 |--> z3^7) defined by the matrix
+            [1 0]
+            [0 0]
+            Domain: Vector space of dimension 2 over Finite Field in z3 of size 7^3
+            Codomain: Vector space of dimension 2 over Finite Field in z3 of size 7^3,
+            Free module pseudomorphism (twisted by z3 |--> z3^7) defined by the matrix
+            [0 1]
+            [0 0]
+            Domain: Vector space of dimension 2 over Finite Field in z3 of size 7^3
+            Codomain: Vector space of dimension 2 over Finite Field in z3 of size 7^3,
+            Free module pseudomorphism (twisted by z3 |--> z3^7) defined by the matrix
+            [0 0]
+            [1 0]
+            Domain: Vector space of dimension 2 over Finite Field in z3 of size 7^3
+            Codomain: Vector space of dimension 2 over Finite Field in z3 of size 7^3,
+            Free module pseudomorphism (twisted by z3 |--> z3^7) defined by the matrix
+            [0 0]
+            [0 1]
+            Domain: Vector space of dimension 2 over Finite Field in z3 of size 7^3
+            Codomain: Vector space of dimension 2 over Finite Field in z3 of size 7^3]
+        """
+        return Sequence(self(mat) for mat in self._matrix_space.basis())
+
+    def _test_additive_associativity(self, tester):
+        r"""
+        Test associativity for (not necessarily all) elements in this parent.
+
+        This test is not relevant for pseudomorphisms because they are not
+        stable by addition.
+
+        TESTS::
+
+            sage: Fq = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: PHS = V.pseudoHom(Frob)
+            sage: TestSuite(PHS).run()  # indirect doctest
+        """
+        pass
+
+    def _test_distributivity(self, tester):
+        r"""
+        Test distributivity for (not necessarily all) elements in this parent.
+
+        This test is not relevant for pseudomorphisms because they are not
+        stable by addition.
+
+        TESTS::
+
+            sage: Fq = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: PHS = V.pseudoHom(Frob)
+            sage: TestSuite(PHS).run()  # indirect doctest
+        """
+        pass
+
+    def _test_one(self, tester):
+        r"""
+        Test properties the identity element.
+
+        This test is not relevant for pseudomorphisms because the identity
+        is not a pseudomorphism in general.
+
+        TESTS::
+
+            sage: Fq = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: PHS = V.pseudoHom(Frob)
+            sage: TestSuite(PHS).run()  # indirect doctest
+        """
+        pass
+
+    def _test_zero(self, tester):
+        r"""
+        Test properties of the zero element.
+
+        This test is not relevant for pseudomorphisms because the zero
+        map is not a pseudomorphism in general.
+
+        TESTS::
+
+            sage: Fq = GF(7^3)
+            sage: Frob = Fq.frobenius_endomorphism()
+            sage: V = Fq^2
+            sage: PHS = V.pseudoHom(Frob)
+            sage: TestSuite(PHS).run()  # indirect doctest
+        """
+        pass