def valuation_divisor(self, proof=False, **kwds): r"""Returns the valuation divisor of the Abelian differential of the first kind. Because Abelian differentials of the first kind are holomorphic on the Riemann surface, the valuation divisor is of the form .. math:: (\omega)_{val} = p_1 P_1 + \cdots + p_m P_m where :math:`\omega` has a zero of multiplicity :math:`p_k` at the place :math:`P_k`. Parameters ---------- proof : bool If set to `True`, will provably return the valuation divisor by computing the valuation at every necessary place on `X`. Slow. Notes ----- This valuation divisor overload takes advantage of the fact that the differential admits no poles. Therefore, as places on the Riemann surface are checked, the degree of the valuation divisor is non-decreasing. We can terminate the search the moment the degree reaches :math:`2g-2`. If `proof=True` then ignore this trick and compute over every possible place. """ xvalues = self._find_necessary_xvalues() # for each xvalue, compute the places above it and determine valuation # of the differential over each of these places. D = Divisor(self.RS,0) genus = self.RS.genus() target_genus = 2*genus - 2 for alpha in xvalues: places_above_alpha = self.RS(alpha) for P in places_above_alpha: n = P.valuation(self) D += n*P # abelian differentials of the first kind should have no poles if n < 0: raise ValueError( 'Could not compute valuation divisor of %s: ' 'found a pole of differential of first kind.'%self) # break out if the target degree is met if (D.degree == target_genus) and (not proof): return D if D.degree != target_genus: raise ValueError('Could not compute valuation divisor of %s: ' 'did not reach genus requirement.'%self) return D
def valuation_divisor(self, **kwds): r"""Returns the valuation divisor of the Abelian differential of the second kind. Parameters ---------- none Returns ------- Divisor """ xvalues = self._find_necessary_xvalues() # for each xvalue, compute the places above it and determine valuation # of the differential over each of these places. D = Divisor(self.RS,0) genus = self.RS.genus() target_genus = 2*genus - 2 num_poles = 0 for alpha in xvalues: places_above_alpha = self.RS(alpha) for P in places_above_alpha: n = P.valuation(self) D += n*P # differentials of the second kind should have a single # pole. raise an error if more are found if n < 0: num_poles += 1 if num_poles > 1: raise ValueError( 'Could not compute valuation divisor of %s: ' 'found more than one pole.'%self) # break out if (a) the degree requirement is met and (b) the # pole was found. if (D.degree == target_genus) and (num_poles): return D if D.degree != target_genus: raise ValueError('Could not compute valuation divisor of %s: ' 'did not reach genus requirement.'%self) return D
def valuation_divisor(self, **kwds): r"""Returns the valuation divisor of the differential. This is a generic algorithm for computing valuation divisors and should only be used if nothing is known about the differential in question. If the differential is Abelian of the first kind (holomorphic) then create an instance of :class:`AbelianDifferentialFirstKind`. Similarly, if the differential is Abelian of the second kind then create an instance of :class:`AbelianDifferentialSecondKind`. These implement versions of :meth:`valuation_divisor` that use properties of the differential to save on time. Parameters ---------- none Returns ------- Divisor """ xvalues = self._find_necessary_xvalues() # for each xvalue, compute the places above it and determine the # valuation of the differential over each of these places D = Divisor(self.RS,0) genus = self.RS.genus() for alpha in xvalues: places_above_alpha = self.RS(alpha) for P in places_above_alpha: n = P.valuation(self) D += n*P # the valuation divisor of a generic meromorphic differential is still # canonical. check the degree condition target_genus = 2*genus - 2 if D.degree != target_genus: raise ValueError( 'Could not compute valuation divisor of %s: ' 'did not reach genus requirement.'%self) return D
def test_zero(self): D = Divisor(None,0) self.assertTrue(D.is_zero()) D = self.P - self.P self.assertTrue(D.is_zero())