Added function that computes the multipliers of periodic points of af…

…fine morhpisms

Also modified documentation for the multiplier function in projective morphism.

src/sage/schemes/affine/affine_morphism.py

@@ -34,10 +34,12 @@
 
 from sage.calculus.functions import jacobian
 from sage.categories.homset        import Hom
+from sage.matrix.constructor       import matrix, identity_matrix
 from sage.misc.misc                import prod
 from sage.rings.all                import Integer, moebius
 from sage.rings.arith              import lcm, gcd
 from sage.rings.complex_field      import ComplexField
+from sage.rings.fraction_field     import FractionField
 from sage.rings.integer_ring       import ZZ
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 from sage.rings.quotient_ring      import QuotientRing_generic
@@ -630,6 +632,74 @@ def jacobian (self):
         self.__jacobian = jacobian(list(self),self.domain().gens())
         return self.__jacobian
 
+    def multiplier(self, P, n, check=True):
+        r"""
+        Returns the multiplier of ``self`` at the `QQ`-rational point ``P`` of period ``n``.
+        ``self`` must be an endomorphism of affine space.
+
+        INPUT:
+
+        - ``P`` - a point on domain of ``self``
+
+        - ``n`` - a positive integer, the period of ``P``
+
+        - ``check`` -- verify that ``P`` has period ``n``, Default:True
+
+        OUTPUT:
+
+        - a square matrix of size ``self.codomain().dimension_relative()`` in the ``base_ring`` of ``self``
+
+        EXAMPLES::
+
+            sage: P.<x,y> = AffineSpace(QQ,2)
+            sage: H = End(P)
+            sage: f = H([x^2,y^2])
+            sage: f.multiplier(P([1,1]),1)
+            [2 0]
+            [0 2]
+
+        ::
+
+            sage: P.<x,y,z> = AffineSpace(QQ,3)
+            sage: H = End(P)
+            sage: f = H([x,y^2,z^2 - y])
+            sage: f.multiplier(P([1/2,1,0]),2)
+            [1 0 0]
+            [0 4 0]
+            [0 0 0]
+
+        ::
+
+            sage: P.<x> = AffineSpace(CC,1)
+            sage: H = End(P)
+            sage: f = H([x^2 + 1/2])
+            sage: f.multiplier(P([0.5 + 0.5*I]),0)
+            [1.00000000000000]
+
+        ::
+
+            sage: R.<t> = PolynomialRing(CC,1)
+            sage: P.<x> = AffineSpace(R,1)
+            sage: H = End(P)
+            sage: f = H([x^2 - t^2 + t])
+            sage: f.multiplier(P([-t + 1]),0)
+            [1.00000000000000]
+        """
+        if not self.is_endomorphism():
+            raise NotImplementedError("Must be an endomorphism of affine space")
+        if check:
+            if self.nth_iterate(P, n) != P:
+                raise ValueError("%s is not periodic of period %s" % (P, n))
+        N = self.domain().ambient_space().dimension_relative()
+        l = identity_matrix(FractionField(self.codomain().base_ring()), N, N)
+        Q = P
+        J = self.jacobian()
+        for i in range(0, n):
+            R = self(Q)
+            l = J(tuple(Q))*l #get the correct order for chain rule matrix multiplication
+            Q = R
+        return l
+
 class SchemeMorphism_polynomial_affine_space_field(SchemeMorphism_polynomial_affine_space):
     pass
 

src/sage/schemes/projective/projective_morphism.py

@@ -1700,7 +1700,7 @@ def height_difference_bound(self, prec=None):
     def multiplier(self, P, n, check=True):
         r"""
         Returns the multiplier of ``self`` at the `QQ`-rational point ``P`` of period ``n``.
-        ``self`` must be an endomorphism of projective space
+        ``self`` must be an endomorphism of projective space.
 
         INPUT:
 
@@ -1767,15 +1767,13 @@ def multiplier(self, P, n, check=True):
             Traceback (most recent call last):
             ...
             ValueError: (0 : 1) is not periodic of period 1
-
-        ..  TODO:: would be better to keep the dehomogenizations for reuse
         """
         if not self.is_endomorphism():
             raise NotImplementedError("Must be an endomorphism of projective space")
         if check:
             if self.nth_iterate(P, n) != P:
                 raise ValueError("%s is not periodic of period %s" % (P, n))
-        N = self.domain().dimension_relative()
+        N = self.domain().ambient_space().dimension_relative()
         l = identity_matrix(FractionField(self.codomain().base_ring()), N, N)
         Q = P
         Q.normalize_coordinates()