7.5.4.1 ModularSymbolsAmbient Objects

class ModularSymbolsAmbient
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, must be >= 2 group - congroup.CongruenceGroup, a congruence subgroup. sign - int, either -1, 0, or 1 base_field - rings.Ring (defaults to the rational numbers)

ModularSymbolsAmbient( [group=None], [weight=Rational Field], [sign=0], [base_field=2], [character=1])

Initialize a space of modular symbols.

Instances of class ModularSymbolsAmbient have the following methods (in addition to inherited methods and special methods):

ambient_vector,$  $ boundary_map,$  $ commit,$  $ cuspidal_subspace,$  $ degeneracy_map,$  $ dimension,$  $ element,$  $ embedded_subspace,$  $ fcp,$  $ filename,$  $ hecke_algebra,$  $ intersect,$  $ is_ambient,$  $ is_subspace,$  $ load,$  $ manin_symbols_basis,$  $ modular_symbols_of_level,$  $ new_subspace,$  $ use_db,$  $ zero_subspace

These methods are defined as follows:

ambient_vector( v)

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

boundary_map( )

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

commit( )

Try to commit this modular symbols space to the database.

cuspidal_subspace( )

The cuspidal subspace.

degeneracy_map( level, [t=1])

The t-th degeneracy map from self to modular symbols of the given level. The level of self must be a divisor or multiple of level, and t must be a divisor of the quotient.

NOTE: We use Proposition 2.6.15 in Merel's 1585 paper (or Prop 15 in the dvi 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 linear function from self to the space of modular symbols
    of given level with the same weight, character, sign,
    etc., as this space.

dimension( )

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.

sage: M = ModularSymbols(389)
sage: M.dimension()
65

element( x)

Creates and returns an element of self from a modular symbol, if possible.

INPUT:
   x -- an object of one of the following types:
        ModularSymbol, ManinSymbol.

OUTPUT:

ModularSymbol - a modular symbol with parent self.

embedded_subspace( )

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( 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.

sage: m = ModularSymbols(23, 2, sign=1)
sage: m.fcp(2)
[(x - 3, 1), (x^2 + x - 1, 1)]
sage: m.hecke_operator(2).charpoly().factor()
[(x - 3, 1), (x^2 + x - 1, 1)]

filename( )

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( )

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.

intersect( other)

Returns the intersection of self and other, which must both lie in a common ambient space of modular symbols.

sage: M = ModularSymbols(43, sign=1)
sage: A = M[0] + M[1]
sage: B = M[1] + M[2]
sage: A.dimension(), B.dimension()
(2, 3)
sage: C = A.intersect(B); C.dimension()  # TODO
1

is_ambient( )

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.

sage: m = ModularSymbols(10)
sage: m.is_ambient()
True

sage: a = m[0]  # the unique simple factor
sage: a == m
True
sage: a.is_ambient()
False

is_subspace( V)

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

load( )

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( )

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.

sage: m = ModularSymbols(23)
sage: m.manin_symbols_basis()
[(1,0), (1,17), (1,19), (1,20), (1,21)]
sage: m = ModularSymbols(6, weight=4, sign=-1)
sage: m.manin_symbols_basis()
[[X^2*Y^0,(2,1)]]

modular_symbols_of_level( N)

Returns a space of modular symbols with the same defining properties (weight, sign, etc.) as this space except with the level N.

For example, if self is the space of modular symbols of weight 2 for Gamma_0(22), and level is 11, then this function returns modular symbols of weight 2 for Gamma_0(11).

new_subspace( [p=None])

Returns the new or p-new subspace of self.

INPUT:
    p -- (default: None); if not None, return only the p-new
subspace.
    
OUTPUT:
    ModularSymbols -- the new or p-new subspace of self

sage: m = ModularSymbols(33); m.dimension()
9
sage: m.new_subspace().dimension()
3
sage: m.new_subspace(3).dimension()
4
sage: m.new_subspace(11).dimension()
8

use_db( )

Returns true if self is loaded and saved to disk.

INPUT:
   ModularSymbols self -- an ambient space of modular symbols
OUTPUT
   bool

zero_subspace( )

Returns the subspace of this space of modular symbols.

Instances of class ModularSymbolsAmbient also have the following special methods:

__call__( x)

Coerce x into the modular symbols space. The result is either an element of self or a subspace of self.

The allowed inputs for x are as follows:

See About this document... for information on suggesting changes.