42.14 Numerical computation of newforms

Module: sage.modular.modform.numerical

Numerical computation of newforms

Module-level Functions

support( v, eps)

Given a vector v and a threshold eps, return all indices where |v| is larger than eps.

sage: sage.modular.modform.numerical.support( numerical_eigenforms(61)._easy_vector(), 1.0 )
[]

sage: sage.modular.modform.numerical.support( numerical_eigenforms(61)._easy_vector(), 0.5 )
[0, 1]

Class: NumericalEigenforms

class NumericalEigenforms
numerical_eigenforms(group, weight=2, eps=1e-20, delta=1e-2, tp=[2,3,5])

Input:

group
- a congruence subgroup of a Dirichlet character of order 1 or 2
weight
- an integer >= 2
eps
- a small float; abs( ) < eps is what "equal to zero" is interpreted as for floating point numbers.
delta
- a small-ish float; eigenvalues are considered distinct if their difference has absolute value at least delta
tp
- use the Hecke operators T_p for p in tp when searching for a random Hecke operator with distinct Hecke eigenvalues.

Output: a numerical eigenforms object, with the following useful methods:
* ap(p)
- return all eigenvalues of $ T_p$
* eigenvalues(primes)
- list of eigenvalues corresponding to the given list of primes, e.g.,: [[eigenvalues of T_2], [eigenvalues of T_3], [eigenvalues of T_5], ...]
* systems_of_eigenvalues
- a list of the systems of eigenvalues of eigenforms such that the chosen random linear combination of Hecke operators has multiplicity 1 eigenvalues.

sage: n = numerical_eigenforms(23)
sage: n == loads(dumps(n))
True
sage: n.ap(2)
[3.0, 0.61803398875, -1.61803398875]
sage: n.systems_of_eigenvalues(7)
[
[-1.61803398875, 2.2360679775, -3.2360679775],
[0.61803398875, -2.2360679775, 1.2360679775],
[3.0, 4.0, 6.0]
]
sage: n.systems_of_abs(7)   # random low order bits
[
[0.61803398874989446, 2.2360679774997911, 1.2360679774997889],
[1.6180339887498947, 2.2360679774997894, 3.2360679774997894],
[3.0, 4.0, 6.0]
]
sage: n.eigenvalues([2,3,5])
[[3.0, 0.61803398875, -1.61803398875],
 [4.0, -2.2360679775, 2.2360679775],
 [6.0, 1.2360679775, -3.2360679775]]
NumericalEigenforms( self, group, [weight=2], [eps=1e-20], [delta=0.01], [tp=[2, 3, 5]])

Create a new space of numerical eigenforms.

sage: numerical_eigenforms(61) # indirect doctest
Numerical Hecke eigenvalues for Congruence Subgroup Gamma0(61) of weight 2

Functions: ap,$ \,$ eigenvalues,$ \,$ level,$ \,$ modular_symbols,$ \,$ systems_of_abs,$ \,$ systems_of_eigenvalues,$ \,$ weight

ap( self, p)

Return a list of the eigenvalues of the Hecke operator $ T_p$ on all the computed eigenforms. The eigenvalues match up between one prime and the next.

Input:

p
- integer, a prime number

Output:
list
- a list of double precision complex numbers

sage: n = numerical_eigenforms(11,4)
sage: n.ap(2)  # random low order bits
[9.0, 9.0, 2.73205080757, -0.732050807569]
sage: n.ap(3)  # random low order bits
[28.0, 28.0, -7.92820323028, 5.92820323028]
sage: m = n.modular_symbols()
sage: x = polygen(QQ, 'x')
sage: m.T(2).charpoly(x).factor()
(x - 9)^2 * (x^2 - 2*x - 2)
sage: m.T(3).charpoly(x).factor()
(x - 28)^2 * (x^2 + 2*x - 47)

eigenvalues( self, primes)

Return the eigenvalues of the Hecke operators corresponding to the primes in the input list of primes. The eigenvalues match up between one prime and the next.

Input:

primes
- a list of primes

Output: list of lists of eigenvalues.

sage: n = numerical_eigenforms(1,12)
sage: n.eigenvalues([3,5,13])            # random low-order bits
[[177148.0, 252.0], [48828126.0, 4830.0], [1.79216039404e+12,
-577737.99999]]

level( self)

Return the level of this set of modular eigenforms.

sage: n = numerical_eigenforms(61) ; n.level()
61

modular_symbols( self)

Return the space of modular symbols used for computing this set of modular eigenforms.

sage: n = numerical_eigenforms(61) ; n.modular_symbols()
Modular Symbols space of dimension 5 for Gamma_0(61) of weight 2 with sign
1 over Rational Field

systems_of_abs( self, bound)

Return the absolute values of all systems of eigenvalues for self for primes up to bound.

sage: numerical_eigenforms(61).systems_of_abs(10) # random low-order bits
[
[0.311107817466, 2.90321192591, 2.52542756084, 3.21431974338],
[1.0, 2.0, 3.0, 1.0],
[1.48119430409, 0.806063433525, 3.15632517466, 0.675130870567],
[2.17008648663, 1.70927535944, 1.63089761382, 0.460811127189],
[3.0, 4.0, 6.0, 8.0]
]

systems_of_eigenvalues( self, bound)

Return all systems of eigenvalues for self for primes up to bound.

sage: numerical_eigenforms(61).systems_of_eigenvalues(10) # random low-order bits
[
[-1.48119430409 - 1.96762449532e-16*I, 0.806063433525 -
3.26296061512e-17*I, 3.15632517466 - 9.48824660168e-16*I, 0.675130870567 -
1.11836177094e-15*I],
[-1.0 + 4.41816383071e-16*I, -2.0 + 2.0333467033e-15*I, -3.0 +
7.16977409442e-16*I, 1.0 - 1.36105818506e-15*I],
[0.311107817466 - 4.2761561946e-16*I, 2.90321192591 + 1.61443450942e-16*I,
-2.52542756084 - 3.16669464906e-15*I, -3.21431974338 -
3.59709554755e-15*I],
[2.17008648663 - 3.97506148776e-15*I, -1.70927535944 - 1.01117101811e-15*I,
-1.63089761382 - 3.60715393447e-14*I, -0.460811127189 -
3.93805017121e-14*I],
[3.0, 4.0, 6.0, 8.0]
]

weight( self)

Return the weight of this set of modular eigenforms.

sage: n = numerical_eigenforms(61) ; n.weight()
2

Special Functions: __cmp__,$ \,$ __init__,$ \,$ _easy_vector,$ \,$ _eigendata,$ \,$ _eigenvectors,$ \,$ _repr_

__cmp__( self, other)

Compare two spaces of numerical eigenforms. Currently returns 0 if they come from the same space of modular symbols, and -1 otherwise.

sage: n = numerical_eigenforms(23)
sage: n.__cmp__(loads(dumps(n)))
0

_easy_vector( self)

Return a very sparse vector v such that v times the eigenvector matrix has all entries nonzero.

ALGORITHM: 1. Choose row with the most nonzero entries. (put 1 there) 2. Consider submatrix of columns corresponding to zero entries in row chosen in 1. 3. Find row of submatrix with most nonzero entries, and add appropriate multiple. Repeat.

sage: n = numerical_eigenforms(37)
sage: n._easy_vector()                 # slightly random output
(1.0, 1.0, 0)
sage: n = numerical_eigenforms(43)
sage: n._easy_vector()                 # slightly random output
(1.0, 0, 1.0, 0)
sage: n = numerical_eigenforms(125)
sage: n._easy_vector()                 # slightly random output
(0, 0, 0, 1.0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

_eigendata( self)

Return all eigendata for self._easy_vector().

sage: numerical_eigenforms(61)._eigendata() # random low-order bits
((1.0, 0.668205013164, 0.219198805797, 0.49263343893, 0.707106781187),
(1.0, 1.49654668896, 4.5620686498, 2.02990686579, 1.41421356237), [0, 1],
(1.0, 1.0))

_eigenvectors( self)

Find numerical approximations to simultaneous eigenvectors in self.modular_symbols() for all T_p in self._tp.

sage: n = numerical_eigenforms(61)                      
sage: n._eigenvectors() # random low-order bits
[              1.0    0.289473640239    0.176788851952    0.336707726757 
2.4182243084e-16]
[                0  -0.0702748344418    0.491416161212    0.155925712173   
0.707106781187]
[                0    0.413171180356    0.141163094698   0.0923242547901   
0.707106781187]
[                0    0.826342360711    0.282326189397     0.18464850958
6.79812569682e-16]
[                0      0.2402380858    0.792225196393    0.905370774276
4.70805946682e-16]

_repr_( self)

Print string representation of self.

sage: n = numerical_eigenforms(61) ; n
Numerical Hecke eigenvalues for Congruence Subgroup Gamma0(61) of weight 2

sage: n._repr_()
'Numerical Hecke eigenvalues for Congruence Subgroup Gamma0(61) of weight
2'

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