Changeset 5509:7cbf74034d02


Ignore:
Timestamp:
07/27/07 13:45:58 (6 years ago)
Author:
William Stein <wstein@…>
Branch:
default
Message:

Add ability to specify generator name of Hecke eigenvalue field to Hecke modules.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • sage/modular/hecke/module.py

    r3550 r5509  
    185185    def is_zero(self): 
    186186        """ 
    187         Return True if this modular symbols space has dimension 0. 
     187        Return True if this Hecke module has dimension 0. 
    188188        """ 
    189189        return self.dimension() == 0 
    … …  
    318318        return T.apply_sparse(self.gen(i)) 
    319319 
    320     def _element_eigenvalue(self, x): 
     320    def _element_eigenvalue(self, x, name='alpha'): 
    321321        if not element.is_HeckeModuleElement(x): 
    322322            raise TypeError, "x must be a Hecke module element." 
    323323        if not x in self.ambient_hecke_module(): 
    324324            raise ArithmeticError, "x must be in the ambient Hecke module." 
    325         v = self.dual_eigenvector() 
     325        v = self.dual_eigenvector(name=name) 
    326326        return v.dot_product(x.element()) 
    327327 
    … …  
    541541        return self.free_module().degree() 
    542542 
    543     def dual_eigenvector(self): 
     543    def dual_eigenvector(self, name='alpha'): 
    544544        """ 
    545545        Return an eigenvector for the Hecke operators acting on the 
    … …  
    550550        INPUT: 
    551551            The input space must be simple. 
     552            name -- print name of generator for eigenvalue field.  
    552553             
    553554        OUTPUT: 
    … …  
    555556            ring.  This vector is an eigenvector for all Hecke operators 
    556557            acting via their transpose. 
     558 
     559        EXAMPLES: 
    557560 
    558561        NOTES: 
    … …  
    567570            modular symbols to a field.  This functional phi is an 
    568571            eigenvector for the dual action of Hecke operators on 
    569             functionals.  
    570         """ 
    571         try: 
    572             return self.__dual_eigenvector 
    573         except AttributeError: 
     572            functionals. 
     573        """ 
     574        try: 
     575            return self.__dual_eigenvector[name] 
     576        except KeyError: 
    574577            pass 
     578        except AttributeError: 
     579            self.__dual_eigenvector = {} 
    575580 
    576581        if not self.is_simple(): 
    … …  
    593598        if n > 1: 
    594599            R = f.parent() 
    595             K = R.quotient(f, 'alpha')    # Let K be the quotient R/(f), 
    596                                           # with generator printed "alpha". 
     600            K = R.quotient(f, name)    # Let K be the quotient R/(f), 
     601                                       # with generator printed name 
    597602            alpha = K.gen() 
    598603            beta = ~alpha   # multiplicative inverse of alpha 
    … …  
    632637        w_lift = w_lift * (~alpha) 
    633638         
    634         self.__dual_eigenvector = w_lift 
    635         return self.__dual_eigenvector 
     639        self.__dual_eigenvector[name] = w_lift 
     640        return w_lift 
    636641 
    637642    def dual_hecke_matrix(self, n): 
    … …  
    650655        return self._dual_hecke_matrices[n] 
    651656 
    652     def eigenvalue(self, n): 
     657    def eigenvalue(self, n, name='alpha'): 
    653658        """ 
    654659        Assuming that self is a simple space, return the eigenvalue of 
    655660        the $n$th Hecke operator on self. 
     661 
     662        INPUT: 
     663            n -- index of Hecke operator 
     664            name -- print representation of generator of eigenvalue field 
     665 
     666        EXAMPLES: 
     667            sage: A = ModularSymbols(125,sign=1).new_subspace()[0] 
     668            sage: A.eigenvalue(7) 
     669            -3 
     670            sage: A.eigenvalue(3) 
     671            -alpha - 2 
     672            sage: A.eigenvalue(3,'w') 
     673            -w - 2 
     674            sage: A.eigenvalue(3,'z').charpoly('x') 
     675            x^2 + 3*x + 1 
     676            sage: A.hecke_polynomial(3) 
     677            x^2 + 3*x + 1 
    656678 
    657679        NOTES: 
    … …  
    672694        n = int(n) 
    673695        try: 
    674             return self.__eigenvalues[n] 
     696            return self.__eigenvalues[n][name] 
    675697        except AttributeError: 
    676698            self.__eigenvalues = {} 
    … …  
    680702            raise IndexError, "n must be a positive integer" 
    681703 
    682         ## This was removed so that every element in  
    683         ## the return of system_of_eigenvalues had the same 
    684         ## parent. This was done below, so I just added the 
    685         ## n==1 case to the below if stmt. 
    686         ## -- Craig Citro, 07 Aug 06 
    687         ## 
    688 ##        if n == 1: 
    689 ##            a1 = self.base_ring()(1) 
    690 ##            self.__eigenvalues[1] = a1 
    691 ##            return a1 
     704        ev = self.__eigenvalues 
    692705 
    693706        if (arith.is_prime(n) or n==1): 
    694707            Tn_e = self._eigen_nonzero_element(n) 
    695             an = self._element_eigenvalue(Tn_e) 
    696             self.__eigenvalues[n] = an 
     708            an = self._element_eigenvalue(Tn_e, name=name) 
     709            dict_set(ev, n, name, an) 
    697710            return an 
    698711 
    … …  
    707720            (p, r) = (int(p), int(r)) 
    708721            pow = p**r 
    709             if not self.__eigenvalues.has_key(pow): 
     722            if not (ev.has_key(pow) and ev[pow].has_key(name)): 
    710723                # TODO: Optimization -- do something much more intelligent in case character is not defined. 
    711724                # For example, compute it using diamond operators <d> 
    … …  
    713726                if eps is None: 
    714727                    Tn_e = self._eigen_nonzero_element(pow) 
    715                     self.__eigenvalues[pow] = self._element_eigenvalue(Tn_e) 
     728                    dict_set(ev, pow, name, self._element_eigenvalue(Tn_e)) 
    716729                else: 
    717730                    # a_{p^r} := a_p * a_{p^{r-1}} - eps(p)p^{k-1} a_{p^{r-2}} 
    718                     apr1 = self.eigenvalue(pow//p) 
    719                     ap = self.eigenvalue(p) 
     731                    apr1 = self.eigenvalue(pow//p, name=name) 
     732                    ap = self.eigenvalue(p, name=name) 
    720733                    k = self.weight() 
    721                     apr2 = self.eigenvalue(pow//(p*p)) 
     734                    apr2 = self.eigenvalue(pow//(p*p), name=name) 
    722735                    apow = ap*apr1 - eps(p)*(p**(k-1)) * apr2 
    723                     self.__eigenvalues[pow] = apow 
    724             if prod == None: 
    725                 prod = self.__eigenvalues[pow] 
     736                    dict_set(ev, pow, name, apow) 
     737            if prod is None: 
     738                prod = ev[pow][name] 
    726739            else: 
    727                 prod *= self.__eigenvalues[pow] 
    728         self.__eigenvalues[n] = prod 
     740                prod *= ev[pow][name] 
     741        dict_set(ev, n, name, prod) 
    729742        return prod 
    730743         
    … …  
    888901            return self.__projection 
    889902         
    890     def system_of_eigenvalues(self, n): 
     903    def system_of_eigenvalues(self, n, name='alpha'): 
    891904        r""" 
    892905        Assuming that self is a simple space of modular symbols, return 
    893906        the eigenvalues $[a_1, \ldots, a_nmax]$ of the Hecke operators 
    894907        on self.  See \code{self.eigenvalue(n)} for more details. 
     908 
     909        INPUT: 
     910             n -- number of eigenvalues 
     911             alpha -- name of generate for eigenvalue field 
    895912 
    896913        EXAMPLES: 
    … …  
    902919            [[1, 1, 0], [1, -1, -alpha - 1]] 
    903920 
    904          
    905921        Next we define a function that does the above: 
    906922            sage: def b(N,k=2): 
    … …  
    921937            [1, alpha, -2*alpha - 1, -alpha - 1, 2*alpha, alpha - 2, 2*alpha + 2, -2*alpha - 1, 2, -2*alpha + 2] 
    922938            sage: v[0].parent() 
    923             Univariate Quotient Polynomial Ring in alpha over Rational Field with modulus x^2 + x - 1         
    924         """ 
    925         return [self.eigenvalue(m) for m in range(1,n+1)] 
     939            Univariate Quotient Polynomial Ring in alpha over Rational Field with modulus x^2 + x - 1 
     940 
     941        This example illustrates setting the print name of the eigenvalue field.  
     942            sage: A = ModularSymbols(125,sign=1).new_subspace()[0] 
     943            sage: A.system_of_eigenvalues(10) 
     944            [1, alpha, -alpha - 2, -alpha - 1, 0, -alpha - 1, -3, -2*alpha - 1, 3*alpha + 2, 0] 
     945            sage: A.system_of_eigenvalues(10,'x') 
     946            [1, x, -x - 2, -x - 1, 0, -x - 1, -3, -2*x - 1, 3*x + 2, 0] 
     947        """ 
     948        return [self.eigenvalue(m, name=name) for m in range(1,n+1)] 
    926949 
    927950    def weight(self): 
    928951        """ 
    929         Returns the weight of this modular symbols space. 
     952        Returns the weight of this Hecke module.  
    930953 
    931954        INPUT: 
    932            ModularSymbols self -- an arbitrary space of modular symbols 
     955           self -- an arbitrary Hecke module 
    933956            
    934957        OUTPUT: 
    … …  
    947970        """ 
    948971        Return the zero submodule of self. 
     972 
     973        EXAMPLES: 
     974             
    949975        """ 
    950976        return self.submodule(self.free_module().zero_submodule()) 
    951977     
    952978         
     979def dict_set(v, n, key, val): 
     980    if v.has_key(n): 
     981        v[n][key] = val 
     982    else: 
     983        v[n] = {key:val} 
     984 
Note: See TracChangeset for help on using the changeset viewer.