Package sage :: Package modular :: Package modsym :: Module ambient :: Class ModularSymbolsAmbient
[show private | hide private]
[frames | no frames]

Type ModularSymbolsAmbient

                  Gens --+    
                         |    
           HeckeModule --+    
                         |    
       ModularSymbolsSpace --+
                             |
                object --+   |
                         |   |
_uniqModularSymbolsAmbient --+
                             |
                            ModularSymbolsAmbient

Known Subclasses:
ModularSymbolsAmbient_wtk_eps, ModularSymbolsAmbient_wtk_g0_Q, ModularSymbolsAmbient_wtk_g1_Q

An ambient space of modular symbols for a congruence subgroup of SL_2(Z).

This class is an "abstract base class", so only derived classes should 
be instantiated. 
INPUT:
    weight -- int, the weight
    group -- congroup.CongruenceGroup, a congruence subgroup. 
    sign -- int, either -1, 0, or 1
    base_field -- rings.Ring (defaults to the rational numbers)

Method Summary
  __init__(self, group, weight, sign, base_field, character)
Initialize a space of modular symbols.
  __add__(self, other)
  __call__(self, x)
Coerce x into the modular symbols space.
  __getitem__(self, n)
  __len__(self)
  __repr__(self)
  ambient_space(self)
  ambient_vector(self, v)
Given a vector v in self.vector_space(), return the corresponding vector in the ambient modular symbols space.
  boundary_map(self)
The boundary map to the corresponding space of boundary modular symbols.
  commit(self)
Try to commit this modular symbols space to the database.
  compute_presentation(self)
  cuspidal_subspace(self)
The cuspidal subspace.
  degeneracy_map(self, level, t)
The t-th degeneracy map from self to modular symbols of the given level.
  dimension(self)
Returns the dimension of self.
  eisenstein_subspace(self)
  element(self, x)
Creates and returns an element of self from a modular or sage symbol, if possible.
  embedded_subspace(self)
Returns the vector subspace of the vector space of the ambient space that defines self as a subspace of modular symbols.
  fcp(self, n)
Returns the factorization of the characteristic polynomial of the Hecke operator T_n of index n.
  filename(self)
Returns the filename of self that should be used to store self in the database.
  hecke_algebra(self)
Returns the Hecke algebra associated to self.
  intersect(self, other)
Returns the intersection of self and other, which must both lie in a common ambient space of modular symbols.
  is_ambient(self)
Returns true if and only if self is an ambient space of modular symbols, i.e., created by specifying a group, weight, character, and sign, and not by using a decomposition or other command.
  is_cuspidal(self)
  is_eisenstein(self)
  is_new(self, p)
  is_subspace(self, V)
Returns True if and only if self is a subspace of V.
  load(self)
Try to load the ambient space self from the database.
  manin_basis(self)
  manin_generators(self)
  manin_gens_to_basis(self)
  manin_relations(self)
  manin_symbols(self)
  manin_symbols_basis(self)
A list of Manin symbols that form a basis for the ambient space self.
  new_subspace(self, p)
Returns the new or p-new subspace of self.
  p1list(self)
  relation_matrix(self)
  use_db(self)
Returns true if self is loaded and saved to disk.
  zero_subspace(self)
Returns the subspace of this space of modular symbols.
    Inherited from object
  __delattr__(...)
x.__delattr__('name') <==> del x.name
  __getattribute__(...)
x.__getattribute__('name') <==> x.name
  __hash__(x)
x.__hash__() <==> hash(x)
  __reduce__(...)
helper for pickle
  __reduce_ex__(...)
helper for pickle
  __setattr__(...)
x.__setattr__('name', value) <==> x.name = value
  __str__(x)
x.__str__() <==> str(x)
    Inherited from ModularSymbolsSpace
  __cmp__(self, other)
Compare self and other.
  base_field(self)
  base_ring(self)
  basis(self)
Returns a basis for self.
  character(self)
  eigenvalue(self, n)
Returns an eigenvalue of T_n acting on self, where self must be new and non-splittable.
  eigenvalues(self)
Return a_n, psi, i, where a_n is the n-th eigenvalue, psi : Z --> V is a map and i:V-->K is an isomorphism of V with a number field (or Q), such that the composition iso(psi(n)) is the eigenvalue of the n-th Hecke operator acting on a fixed element of self (which must be new and non-splittable).
  gen(self, n)
The n-th generator of self.
  group(self)
Returns the group of this modular symbols space.
  hecke_matrix(self, n)
The matrix of the n-th Hecke operator acting on the basis for self.
  hecke_operator(self, n)
Returns the n-th Hecke operator as a Matrix Function.
  level(self)
Returns the level of this modular symbols space.
  ngens(self)
The number of generators of self.
  projection(self)
Return the projection map from the ambient space to self.
  qeigenform(self, prec)
Returns the q-expansion to precision prec of a newform associated to self, where self must be new, cuspidal, and non-splittable.
  sign(self)
Returns the sign of self.
  sturm_bound(self)
Returns the Sturm bound for this space of modular symbols.
  T(self, n)
Returns the n-th Hecke operator T_n.
  vector_space(self)
Returns the underlying vector space of self.
  weight(self)
Returns the weight of this modular symbols space.
    Inherited from HeckeModule
  decomposition(self, anemic)
  factor_number(self)
  is_splittable(self)
Returns true if and only if only it is possible to split off a nontrivial generalized eigenspace of self as the kernel of some Hecke operator.
  is_splittable_anemic(self)
Returns true if and only if only it is possible to split off a nontrivial generalized eigenspace of self as the kernel of some Hecke operator of index coprime to the level.
  set_factor_number(self, i)
    Inherited from Gens
  __getattr__(self, attrname)
  __getslice__(self, n, m)
  gens(self)
  list(self)

Instance Method Details

__init__(self, group=1, weight=2, sign=0, base_field=Rational Field, character=None)
(Constructor)

Initialize a space of modular symbols.
Overrides:
__builtin__.object.__init__

__call__(self, x)
(Call operator)

Coerce x into the modular symbols space.

ambient_vector(self, v)

Given a vector v in self.vector_space(), return the corresponding vector in the ambient modular symbols space.

boundary_map(self)

The boundary map to the corresponding space of boundary modular symbols.

commit(self)

Try to commit this modular symbols space to the database.

cuspidal_subspace(self)

The cuspidal subspace.

degeneracy_map(self, level, t=1)

The t-th degeneracy map from self to modular symbols of the
given level.

EXAMPLES:
NOTE: We use Proposition 2.6.15 in Merel's 1585 paper (or
      Prop 15 in the electronic version of that paper). 
INPUT:
    level -- int, the level of the codomain of the map (positive int).
    t  -- int, the parameter of the degeneracy map, i.e., the map is
          related to f(q) |--> f(q^t).
OUTPUT:
    A function from self to the space of modular symbols
    of given level with the same weight, character, sign,
    etc., as this space.

dimension(self)

Returns the dimension of self.

INPUT:
   ModularSymbols self -- arbitrary space of modular symbols
OUTPUT:
   int -- the dimension
ALGORITHM:
   If self is a subspace, then it is defined by a vector
   space, and the dimension is known.  If self is ambient,
   this function computes a presentation for self, and return
   the number of free generators in the presentation.  The
   dimension could also be computed in many cases using
   dimension formulas, but we don't do this.
EXAMPLES:
>>> M = modsym.ModularSymbols(389)
>>> M.dimension()
65
Overrides:
sage.modular.modsym.space.ModularSymbolsSpace.dimension

element(self, x)

Creates and returns an element of self from a modular or
sage symbol, if possible.
INPUT:
   x -- an object of one of the following types:
        ModularSymbol, ManinSymbol.  We ignore the group,
        weight, and character of the input modular or sage symbol.
OUTPUT:
   ModularSymbol -- a modular symbol with parent self.

embedded_subspace(self)

Returns the vector subspace of the vector space of the ambient
space that defines self as a subspace of modular symbols.
INPUT:
   ModularSymbols self -- a space of modular symbols
OUTPUT:
   VectorSpace -- a vector space.

fcp(self, n)

Returns the factorization of the characteristic polynomial of
the Hecke operator T_n of index n.
INPUT:
   ModularSymbols self -- space of modular symbols invariant
                           under the Hecke operator of index n.
   int n -- a positive integer.
OUTPUT:
   list -- list of the pairs (g,e), where g is an irreducible
           factor of the characteristic polynomial of T_n, and
           e is its multiplicity.
ALGORITHM:
   Call hecke_operator to compute the hecke operator, call
   charpoly on that, and call factor on the result of
   charpoly.  Thus the implementation is just a one-line call
   to other functions.
EXAMPLES:
>>> m = modsym.ModularSymbols(23, 2, sign=1)
>>> m.fcp(2)
[(x - 3, 1), (x^2 + x - 1, 1)]
>>> m.hecke_operator(2).charpoly().factor()
[(x - 3, 1), (x^2 + x - 1, 1)]

filename(self)

Returns the filename of self that should be used to store self
in the database.
INPUT:
   self -- space of modular symbols
OUTPUT:
   str -- a string

hecke_algebra(self)

Returns the Hecke algebra associated to self.

INPUT:
   ModularSymbols -- Hecke stable space of modular symbols
OUTPUT:
   hecke.HeckeAlgebra -- the Hecke algebra attached to self.
ALGORITHM:
   Creates the hecke.HeckeAlgebra attached to self.  For how
   that works, see the documentation of the hecke module.
Overrides:
sage.modular.modsym.space.ModularSymbolsSpace.hecke_algebra

intersect(self, other)

Returns the intersection of self and other, which must both lie in a common ambient space of modular symbols. EXAMPLES: >>> M = modsym.ModularSymbols(43, sign=1)

>.>> A = M[0] + M[1] >.>> B = M[1] + M[2] >.>> A.dimension(), B.dimension() (2, 3) >.>> C = A.intersect(B); C.dimension() 1

is_ambient(self)

Returns true if and only if self is an ambient space of modular symbols, i.e., created by specifying a group, weight, character, and sign, and not by using a decomposition or other command.

WARNING: self could be equal to an ambient space, but not be an ambient space. For example, decomposing a simple ambient space yields a single factor, and that factor is not an ambient space.

EXAMPLES: >>> m = modsym.ModularSymbols(10) >>> m.is_ambient() True

>.>> a = m[0] # the unique simple factor >.>> a == m True >.>> a.is_ambient() False
Overrides:
sage.modular.modsym.space.ModularSymbolsSpace.is_ambient

is_subspace(self, V)

Returns True if and only if self is a subspace of V.

load(self)

Try to load the ambient space self from the database.
INPUT:
   ModularSymbols self -- an ambient space of modular symbols
OUTPUT:
   bool --  True on success and False on failure.

manin_symbols_basis(self)

A list of Manin symbols that form a basis for the ambient
space self.
INPUT:
   ModularSymbols self -- an ambient space of modular symbols
OUTPUT:
   list -- a list of 2-tuples (if the weight is 2) or 3-tuples, 
           which represent the Manin symbols basis for self.
EXAMPLES:
>>> m = modsym.ModularSymbols(23)
>>> m.manin_symbols_basis()
[(0, 1, 0), (0, 1, 17), (0, 1, 19), (0, 1, 20), (0, 1, 21)]
>>> m = modsym.ModularSymbols(6, weight=4, sign=-1)
>>> m.manin_symbols_basis()
[(2, 2, 1)]

new_subspace(self, p=None)

Returns the new or p-new subspace of self.
INPUT:
   ModularSymbols self -- arbitrary space of modular symbols
OUTPUT:
   ModularSymbols -- the new or p-new subspace of self
EXAMPLES:
>>> m = modsym.ModularSymbols(33); m.dimension()
9

>.>> m.new_subspace().dimension()
3
>.>> m.new_subspace(3).dimension()
4
>.>> m.new_subspace(11).dimension()
5

use_db(self)

Returns true if self is loaded and saved to disk.
INPUT:
   ModularSymbols self -- an ambient space of modular symbols
OUTPUT
   bool

zero_subspace(self)

Returns the subspace of this space of modular symbols.

Generated by Epydoc 2.1 on Mon Jun 20 15:43:22 2005 http://epydoc.sf.net