Changeset 7500:24ab26bdb823

Timestamp:

11/26/07 20:09:07 (5 years ago)

Author:

Jen Balakrishnan <jen@…>

Branch:

default

Message:

wrappers for Dokchitser L-series for various types of modular forms

Location:

sage/modular/modform

Files:

• all.py (modified) (2 diffs)
• eis_series.py (modified) (3 diffs)
• element.py (modified) (5 diffs)

sage/modular/modform/all.py

@@ -9 +9 @@
 from constructor import ModularForms, CuspForms, EisensteinForms
 
-from eis_series import eisenstein_series_qexp
+from eis_series import eisenstein_series_qexp, eisenstein_series_Lseries
 
 from half_integral import half_integral_weight_modform_basis
@@ -23 +23 @@
 from numerical import NumericalEigenforms as numerical_eigenforms
 
-from element import is_ModularFormElement
+from element import is_ModularFormElement, delta_Lseries
 
 #from find_generators import ModularFormsRing, span_of_series, modform_generators

sage/modular/modform/eis_series.py

@@ -14 +14 @@
 
 import sage.modular.dirichlet as dirichlet
+
+from sage.rings.all import ComplexField, RealField, Integer
+
+from sage.functions.constants import pi
 
 from sage.rings.all import (bernoulli, CyclotomicField,
@@ -199 +203 @@
     return triples
 
-    
+def eisenstein_series_Lseries(weight, prec=53,
+               max_imaginary_part=0,
+               max_asymp_coeffs=40):
+    r"""
+    Return the L-series of the weight $2k$ Eisenstein series 
+    on $\SL_2(\Z)$.
+
+    This actually returns an interface to Tim Dokchitser's program
+    for computing with the L-series of the Eisenstein series
+
+    INPUT:
+       weight -- even integer
+       prec -- integer (bits precision)
+       max_imaginary_part -- real number
+       max_asymp_coeffs -- integer
+
+    OUTPUT:
+       The L-series of the Eisenstein series.
+
+    EXAMPLES:
+    We compute with the L-series of $E_{16}$:
+       sage: L = eisenstein_series_Lseries(16)
+       sage: L(1)
+       -0.291657724743873
+    We compute with the L-series of $E_{20}$:
+       sage: L = eisenstein_series_Lseries(20)
+       sage: L(2)
+       -5.02355351645987 
+    """
+    f = eisenstein_series_qexp(weight,prec)
+    from sage.lfunctions.all import Dokchitser
+    key = (prec, max_imaginary_part, max_asymp_coeffs)
+    j = weight
+    L = Dokchitser(conductor = 1,
+                   gammaV = [0,1],
+                   weight = j,
+                   eps = (-1)**Integer((j/2)),
+                   poles = [j],
+                   residues = [(-1)**Integer((j/2))*(float(pi))**(0.5)*bernoulli(j)/j],
+                   prec = prec)
+
+    s = 'coeff = %s;'%f.list()
+    L.init_coeffs('coeff[k+1]',pari_precode = s,    
+                  max_imaginary_part=max_imaginary_part,
+                  max_asymp_coeffs=max_asymp_coeffs)
+    L.check_functional_equation()
+    L.rename('L-series associated to the weight %s Eisenstein series %s on SL_2(Z)'%(j,f))
+    return L    
 
 def compute_eisenstein_params(character, k):
@@ -223 +274 @@
     else:
         return __find_eisen_chars_gamma1(N, k)
-
-

sage/modular/modform/element.py

@@ -14 +14 @@
 import sage.modular.hecke.element as element
 import sage.rings.all as rings
+from sage.modular.modsym.modsym import ModularSymbols
 
 def is_ModularFormElement(x):
@@ -26 +27 @@
     """
     return isinstance(x, ModularFormElement)
+
+def delta_Lseries(prec=53,
+                 max_imaginary_part=0,
+                 max_asymp_coeffs=40):
+    r"""
+    Return the L-series of the modular form Delta.
+
+    This actually returns an interface to Tim Dokchitser's program
+    for computing with the L-series of the modular form $\Delta$.
+
+    INPUT:
+        prec -- integer (bits precision)
+        max_imaginary_part -- real number
+        max_asymp_coeffs -- integer
+
+    OUTPUT:
+        The L-series of $\Delta$.
+
+    EXAMPLES:
+        sage: L = delta_Lseries()
+        sage: L(1)
+        0.0374412812685155
+    """
+    from sage.lfunctions.all import Dokchitser
+    key = (prec, max_imaginary_part, max_asymp_coeffs)
+    L = Dokchitser(conductor = 1,
+                   gammaV = [0,1],
+                   weight = 12,
+                   eps = 1,
+                   prec = prec)
+    s = 'tau(n) = (5*sigma(n,3)+7*sigma(n,5))*n/12-35*sum(k=1,n-1,(6*k-4*(n-k))*sigma(k,3)*sigma(n-k,5));'
+    L.init_coeffs('tau(k)',pari_precode = s,
+                  max_imaginary_part=max_imaginary_part,
+                  max_asymp_coeffs=max_asymp_coeffs)
+    L.set_coeff_growth('2*n^(11/2)')
+    L.rename('L-series associated to the modular form Delta')
+    return L
 
 class ModularFormElement(element.HeckeModuleElement):
@@ -200 +238 @@
         """
         return self.q_expansion(prec)
+ 
+    def cuspform_Lseries(self, prec=53,
+                         max_imaginary_part=0,
+                         max_asymp_coeffs=40):
+        r"""
+        Return the L-series of the weight k cusp form 
+        f on $\Gamma_0(N)$.
+  
+        This actually returns an interface to Tim Dokchitser's program
+        for computing with the L-series of the cusp form.
+  
+        INPUT:
+           prec -- integer (bits precision)
+           max_imaginary_part -- real number
+           max_asymp_coeffs -- integer
+
+        OUTPUT:
+           The L-series of the cusp form.
+
+        EXAMPLES:
+           sage: f = CuspForms(2,8).0
+           sage: L = f.cuspform_Lseries()
+           sage: L(1)
+           0.0884317737041015
+           sage: L(0.5)
+           0.0296568512531983
+           
+        Consistency check with delta_Lseries (which computes coefficients in pari):
+           sage: delta = CuspForms(1,12).0
+           sage: L = delta.cuspform_Lseries()
+           sage: L(1)
+           0.0374412812685155 
+           sage: L = delta_Lseries()
+           sage: L(1)
+           0.0374412812685155
+        """
+        if self.q_expansion().list()[0] !=0:
+            raise TypeError,"f = %s is not a cusp form"%self
+        from sage.lfunctions.all import Dokchitser
+        key = (prec, max_imaginary_part, max_asymp_coeffs)
+        l = self.weight()
+        N = self.level()
+        if N == 1:
+            e = (-1)**l
+        else:
+            m = ModularSymbols(N,l,sign=1)
+            n = m.cuspidal_subspace().new_subspace()
+            e = (-1)**(l/2)*n.atkin_lehner_operator().matrix()[0,0]
+        L = Dokchitser(conductor = N,
+                       gammaV = [0,1],
+                       weight = l,
+                       eps = e,
+                       prec = prec)
+        s = 'coeff = %s;'%self.q_expansion(prec).list()
+        L.init_coeffs('coeff[k+1]',pari_precode = s,    
+                      max_imaginary_part=max_imaginary_part,
+                      max_asymp_coeffs=max_asymp_coeffs)
+        L.check_functional_equation()
+        L.rename('L-series associated to the cusp form %s'%self)
+        return L
+        
+    def modform_Lseries(self, prec=53,
+                        max_imaginary_part=0,
+                        max_asymp_coeffs=40):
+        r"""
+        Return the L-series of the weight $k$ modular form 
+        $f$ on $\SL_2(\Z)$.
+
+        This actually returns an interface to Tim Dokchitser's program
+        for computing with the L-series of the modular form.
+
+        INPUT:
+           prec -- integer (bits precision)
+           max_imaginary_part -- real number
+           max_asymp_coeffs -- integer
+
+        OUTPUT:
+           The L-series of the modular form.
+
+        EXAMPLES:
+        We commpute with the L-series of the Eisenstein series $E_4$:
+           sage: f = ModularForms(1,4).0
+           sage: L = f.modform_Lseries()
+           sage: L(1)
+           -0.0304484570583933
+        """
+        a = self.q_expansion(prec).list()
+        if a[0] == 0:
+            raise TypeError,"f = %s is a cusp form; please use f.cuspform_Lseries() instead!"%self
+        if self.level() != 1:
+            raise TypeError, "f = %s is not a modular form for SL_2(Z)"%self
+        from sage.lfunctions.all import Dokchitser
+        key = (prec, max_imaginary_part, max_asymp_coeffs)
+        l = self.weight()
+        L = Dokchitser(conductor = 1,
+                       gammaV = [0,1],
+                       weight = l,
+                       eps = (-1)**l,
+                       poles = [l],
+                       prec = prec)
+        b = a[1]
+        for i in range(len(a)):    ##to renormalize so that coefficient of q is 1
+            a[i] =(1/b)*a[i]
+        s = 'coeff = %s;'%a
+        L.init_coeffs('coeff[k+1]',pari_precode = s,    
+                      max_imaginary_part=max_imaginary_part,
+                      max_asymp_coeffs=max_asymp_coeffs)
+        L.check_functional_equation()
+        L.rename('L-series associated to the weight %s modular form on SL_2(Z)'%l)
+        return L        
     
     def weight(self):
@@ -214 +362 @@
         self.__valuation = v
         return v
-
-
-
+        
 class ModularFormElement_elliptic_curve(ModularFormElement):
     """
@@ -355 +501 @@
         We have $MLt \mid N$, and 
         $$
-          E_k(chi,psi,t) = 
+          E_k(chi,psi,t) =
            c_0 + sum_{m \geq 1}[sum_{n|m} psi(n) * chi(m/n) * n^(k-1)] q^{mt},
         $$