code stringlengths 17 6.64M |
|---|
def is_HeckeModuleHomspace(x):
'\n Return ``True`` if x is a space of homomorphisms in the category of Hecke modules.\n\n EXAMPLES::\n\n sage: M = ModularForms(Gamma0(7), 4)\n sage: sage.modular.hecke.homspace.is_HeckeModuleHomspace(Hom(M, M))\n True\n sage: sage.modular.hecke.ho... |
class HeckeModuleHomspace(HomsetWithBase):
'\n A space of homomorphisms between two objects in the category of Hecke\n modules over a given base ring.\n '
def __init__(self, X, Y, category=None):
"\n Create the space of homomorphisms between X and Y, which must have the\n same ... |
def is_HeckeModule(x):
'\n Return ``True`` if ``x`` is a Hecke module.\n\n EXAMPLES::\n\n sage: from sage.modular.hecke.module import is_HeckeModule\n sage: is_HeckeModule(ModularForms(Gamma0(7), 4))\n True\n sage: is_HeckeModule(QQ^3)\n False\n sage: is_HeckeModule... |
class HeckeModule_generic(Module):
'\n A very general base class for Hecke modules.\n\n We define a Hecke module of weight `k` to be a module over a commutative\n ring equipped with an action of operators `T_m` for all positive integers `m`\n coprime to some integer `n`(the level), which satisfy `T_r ... |
class HeckeModule_free_module(HeckeModule_generic):
'\n A Hecke module modeled on a free module over a commutative ring.\n '
def __init__(self, base_ring, level, weight, category=None):
'\n Initialise a module.\n\n EXAMPLES::\n\n sage: M = sage.modular.hecke.module.Heck... |
def _dict_set(v, n, key, val):
'\n Rough-and-ready implementation of a two-layer-deep dictionary.\n\n EXAMPLES::\n\n sage: from sage.modular.hecke.module import _dict_set\n sage: v = {}\n sage: _dict_set(v, 1, 2, 3)\n sage: v\n {1: {2: 3}}\n sage: _dict_set(v, 1, 3,... |
def is_HeckeModuleMorphism(x):
'\n Return ``True`` if x is of type HeckeModuleMorphism.\n\n EXAMPLES::\n\n sage: sage.modular.hecke.morphism.is_HeckeModuleMorphism(ModularSymbols(6).hecke_operator(7).hecke_module_morphism())\n True\n '
return isinstance(x, HeckeModuleMorphism)
|
def is_HeckeModuleMorphism_matrix(x):
'\n\n EXAMPLES::\n\n sage: sage.modular.hecke.morphism.is_HeckeModuleMorphism_matrix(ModularSymbols(6).hecke_operator(7).matrix_form().hecke_module_morphism())\n True\n '
return isinstance(x, HeckeModuleMorphism_matrix)
|
class HeckeModuleMorphism(Morphism):
'\n Abstract base class for morphisms of Hecke modules.\n '
pass
|
class HeckeModuleMorphism_matrix(MatrixMorphism, HeckeModuleMorphism):
'\n Morphisms of Hecke modules when the morphism is given by a matrix.\n\n Note that care is needed when composing morphisms, because morphisms in\n Sage act on the left, but their matrices act on the right (!). So if F: A\n -> B a... |
def is_HeckeSubmodule(x):
'\n Return ``True`` if x is of type HeckeSubmodule.\n\n EXAMPLES::\n\n sage: sage.modular.hecke.submodule.is_HeckeSubmodule(ModularForms(1, 12))\n False\n sage: sage.modular.hecke.submodule.is_HeckeSubmodule(CuspForms(1, 12))\n True\n '
return isi... |
@richcmp_method
class HeckeSubmodule(module.HeckeModule_free_module):
'\n Submodule of a Hecke module.\n '
def __init__(self, ambient, submodule, dual_free_module=None, check=True):
'\n Initialise a submodule of an ambient Hecke module.\n\n INPUT:\n\n - ``ambient`` - an amb... |
def characteristic_polynomial_from_traces(traces, d, q, i, sign):
'\n Given a sequence of traces `t_1, \\dots, t_k`, return the\n corresponding characteristic polynomial with Weil numbers as roots.\n\n The characteristic polynomial is defined by the generating series\n\n .. MATH::\n\n P(T) = \\... |
def enumerate_hypergeometric_data(d, weight=None):
'\n Return an iterator over parameters of hypergeometric motives (up to swapping).\n\n INPUT:\n\n - ``d`` -- the degree\n\n - ``weight`` -- optional integer, to specify the motivic weight\n\n EXAMPLES::\n\n sage: from sage.modular.hypergeome... |
def possible_hypergeometric_data(d, weight=None):
'\n Return the list of possible parameters of hypergeometric motives (up to swapping).\n\n INPUT:\n\n - ``d`` -- the degree\n\n - ``weight`` -- optional integer, to specify the motivic weight\n\n EXAMPLES::\n\n sage: from sage.modular.hyperge... |
def cyclotomic_to_alpha(cyclo):
'\n Convert a list of indices of cyclotomic polynomials\n to a list of rational numbers.\n\n The input represents a product of cyclotomic polynomials.\n\n The output is the list of arguments of the roots of the\n given product of cyclotomic polynomials.\n\n This i... |
def alpha_to_cyclotomic(alpha):
'\n Convert from a list of rationals arguments to a list of integers.\n\n The input represents arguments of some roots of unity.\n\n The output represent a product of cyclotomic polynomials with exactly\n the given roots. Note that the multiplicity of `r/s` in the list\... |
def capital_M(n):
'\n Auxiliary function, used to describe the canonical scheme.\n\n INPUT:\n\n - ``n`` -- an integer\n\n OUTPUT:\n\n a rational\n\n EXAMPLES::\n\n sage: from sage.modular.hypergeometric_motive import capital_M\n sage: [capital_M(i) for i in range(1,8)]\n [1,... |
def cyclotomic_to_gamma(cyclo_up, cyclo_down):
'\n Convert a quotient of products of cyclotomic polynomials\n to a quotient of products of polynomials `x^n - 1`.\n\n INPUT:\n\n - ``cyclo_up`` -- list of indices of cyclotomic polynomials in the numerator\n - ``cyclo_down`` -- list of indices of cycl... |
def gamma_list_to_cyclotomic(galist):
'\n Convert a quotient of products of polynomials `x^n - 1`\n to a quotient of products of cyclotomic polynomials.\n\n INPUT:\n\n - ``galist`` -- a list of integers, where an integer `n` represents\n the power `(x^{|n|} - 1)^{\\operatorname{sgn}(n)}`\n\n O... |
class HypergeometricData():
_gauss_table = {}
def __init__(self, cyclotomic=None, alpha_beta=None, gamma_list=None):
'\n Creation of hypergeometric motives.\n\n INPUT:\n\n three possibilities are offered, each describing a quotient\n of products of cyclotomic polynomials.\... |
def lift_to_gamma1(g, m, n):
"\n If ``g = [a,b,c,d]`` is a list of integers defining a `2 \\times 2` matrix\n whose determinant is `1 \\pmod m`, return a list of integers giving the\n entries of a matrix which is congruent to `g \\pmod m` and to\n `\\begin{pmatrix} 1 & * \\\\ 0 & 1 \\end{pmatrix} \\pm... |
def lift_matrix_to_sl2z(A, N):
"\n Given a list of length 4 representing a 2x2 matrix over `\\ZZ / N\\ZZ` with\n determinant 1 (mod `N`), lift it to a 2x2 matrix over `\\ZZ` with\n determinant 1.\n\n This is a special case of :func:`~lift_to_gamma1`, and is coded as such.\n\n INPUT:\n\n - ``A`` ... |
def lift_gen_to_gamma1(m, n):
"\n Return four integers defining a matrix in `\\SL_2(\\ZZ)` which is\n congruent to `\\begin{pmatrix} 0 & -1 \\\\ 1 & 0 \\end{pmatrix} \\pmod m` and\n lies in the subgroup `\\begin{pmatrix} 1 & * \\\\ 0 & 1 \\end{pmatrix} \\pmod\n n`.\n\n This is a special case of :fu... |
def lift_uniformiser_odd(p, u, n):
'\n Construct a matrix over `\\ZZ` whose determinant is `p`, and which is\n congruent to `\\begin{pmatrix} 0 & -1 \\\\ p & 0 \\end{pmatrix} \\pmod{p^u}` and\n to `\\begin{pmatrix} p & 0 \\\\ 0 & 1\\end{pmatrix} \\pmod n`.\n\n This is required for the local components... |
def lift_ramified(g, p, u, n):
"\n Given four integers `a,b,c,d` with `p \\mid c` and `ad - bc = 1 \\pmod{p^u}`,\n find `a',b',c',d'` congruent to `a,b,c,d \\pmod{p^u}`, with `c' = c\n \\pmod{p^{u+1}}`, such that `a'd' - b'c'` is exactly 1, and `\\begin{pmatrix}\n a & b \\\\ c & d \\end{pmatrix}` is i... |
def lift_for_SL(A, N=None):
"\n Lift a matrix `A` from `SL_m(\\ZZ / N\\ZZ)` to `SL_m(\\ZZ)`.\n\n This follows [Shi1971]_, Lemma 1.38, p. 21.\n\n INPUT:\n\n - ``A`` -- a square matrix with coefficients in `\\ZZ / N\\ZZ` (or `\\ZZ`)\n\n - ``N`` -- the modulus (optional) required only if the matrix ``... |
def LocalComponent(f, p, twist_factor=None):
'\n Calculate the local component at the prime `p` of the automorphic\n representation attached to the newform `f`.\n\n INPUT:\n\n - ``f`` (:class:`~sage.modular.modform.element.Newform`) a newform of weight `k \\ge 2`\n - ``p`` (integer) a prime\n - ... |
class LocalComponentBase(SageObject):
'\n Base class for local components of newforms. Not to be directly instantiated; use the :func:`~LocalComponent` constructor function.\n '
def __init__(self, newform, prime, twist_factor):
"\n Standard initialisation function.\n\n EXAMPLES::\... |
class PrimitiveLocalComponent(LocalComponentBase):
'\n Base class for primitive (twist-minimal) local components.\n '
def is_primitive(self):
'\n Return True if this local component is primitive (has minimal level\n among its character twists).\n\n EXAMPLES::\n\n ... |
class PrincipalSeries(PrimitiveLocalComponent):
'\n A principal series representation. This is an abstract base class, not to\n be instantiated directly; see the subclasses\n :class:`~UnramifiedPrincipalSeries` and :class:`~PrimitivePrincipalSeries`.\n '
def species(self):
"\n The ... |
class UnramifiedPrincipalSeries(PrincipalSeries):
"\n An unramified principal series representation of `{\\rm GL}_2(\\QQ_p)`\n (corresponding to a form whose level is not divisible by `p`).\n\n EXAMPLES::\n\n sage: Pi = LocalComponent(Newform('50a'), 3)\n sage: Pi.conductor()\n 0\n ... |
class PrimitivePrincipalSeries(PrincipalSeries):
"\n A ramified principal series of the form `\\pi(\\chi_1, \\chi_2)`\n where `\\chi_1` is unramified but `\\chi_2` is not.\n\n EXAMPLES::\n\n sage: Pi = LocalComponent(Newforms(Gamma1(13), 2, names='a')[0], 13)\n sage: type(Pi)\n <clas... |
class PrimitiveSpecial(PrimitiveLocalComponent):
"\n A primitive special representation: that is, the Steinberg representation\n twisted by an unramified character. All such representations have conductor\n 1.\n\n EXAMPLES::\n\n sage: Pi = LocalComponent(Newform('37a'), 37)\n sage: Pi.sp... |
class PrimitiveSupercuspidal(PrimitiveLocalComponent):
'\n A primitive supercuspidal representation.\n\n Except for some exceptional cases when `p = 2` which we do not implement\n here, such representations are parametrized by smooth characters of tamely\n ramified quadratic extensions of `\\QQ_p`.\n\... |
class ImprimitiveLocalComponent(LocalComponentBase):
'\n A smooth representation which is not of minimal level among its character\n twists. Internally, this is stored as a pair consisting of a minimal local\n component and a character to twist by.\n '
def __init__(self, newform, prime, twist_fac... |
class SmoothCharacterGeneric(MultiplicativeGroupElement):
'\n A smooth (i.e. locally constant) character of `F^\\times`, for `F` some\n finite extension of `\\QQ_p`.\n '
def __init__(self, parent, c, values_on_gens):
'\n Standard init function.\n\n EXAMPLES::\n\n sag... |
class SmoothCharacterGroupGeneric(Parent):
'\n The group of smooth (i.e. locally constant) characters of a `p`-adic field,\n with values in some ring `R`. This is an abstract base class and should not\n be instantiated directly.\n '
Element = SmoothCharacterGeneric
def __init__(self, p, base_... |
class SmoothCharacterGroupQp(SmoothCharacterGroupGeneric):
'\n The group of smooth characters of `\\QQ_p^\\times`, with values in some fixed\n base ring.\n\n EXAMPLES::\n\n sage: from sage.modular.local_comp.smoothchar import SmoothCharacterGroupQp\n sage: G = SmoothCharacterGroupQp(7, QQ);... |
class SmoothCharacterGroupQuadratic(SmoothCharacterGroupGeneric):
'\n The group of smooth characters of `E^\\times`, where `E` is a quadratic extension of `\\QQ_p`.\n '
def discrete_log(self, level, x, gens=None):
'\n Express the class of `x` in `F^\\times / (1 + \\mathfrak{p}^c)^\\times... |
class SmoothCharacterGroupUnramifiedQuadratic(SmoothCharacterGroupQuadratic):
'\n The group of smooth characters of `\\QQ_{p^2}^\\times`, where `\\QQ_{p^2}` is\n the unique unramified quadratic extension of `\\QQ_p`. We represent\n `\\QQ_{p^2}^\\times` internally as the completion at the prime above `p` ... |
class SmoothCharacterGroupRamifiedQuadratic(SmoothCharacterGroupQuadratic):
'\n The group of smooth characters of `K^\\times`, where `K` is a ramified\n quadratic extension of `\\QQ_p`, and `p \\ne 2`.\n '
def __init__(self, prime, flag, base_ring, names='s'):
'\n Standard initialisat... |
@cached_function
def example_type_space(example_no=0):
"\n Quickly return an example of a type space. Used mainly to speed up\n doctesting.\n\n EXAMPLES::\n\n sage: from sage.modular.local_comp.type_space import example_type_space\n sage: example_type_space() # takes a while but caches stu... |
def find_in_space(f, A, base_extend=False):
'\n Given a Newform object `f`, and a space `A` of modular symbols of the same\n weight and level, find the subspace of `A` which corresponds to the Hecke\n eigenvalues of `f`.\n\n If ``base_extend = True``, this will return a 2-dimensional space generated\n... |
class TypeSpace(SageObject):
'\n The modular symbol type space associated to a newform, at a prime dividing\n the level.\n '
def __init__(self, f, p, base_extend=True):
'\n EXAMPLES::\n\n sage: from sage.modular.local_comp.type_space import example_type_space\n s... |
class ModularFormsAmbient(space.ModularFormsSpace, AmbientHeckeModule):
'\n An ambient space of modular forms.\n '
def __init__(self, group, weight, base_ring, character=None, eis_only=False):
'\n Create an ambient space of modular forms.\n\n EXAMPLES::\n\n sage: m = Mo... |
class ModularFormsAmbient_R(ambient.ModularFormsAmbient):
def __init__(self, M, base_ring):
'\n Ambient space of modular forms over a ring other than QQ.\n\n EXAMPLES::\n\n sage: M = ModularForms(23,2,base_ring=GF(7)) # indirect doctest\n sage: M\n Modular F... |
class ModularFormsAmbient_eps(ModularFormsAmbient):
'\n A space of modular forms with character.\n '
def __init__(self, character, weight=2, base_ring=None, eis_only=False):
"\n Create an ambient modular forms space with character.\n\n .. note::\n\n The base ring must be... |
class ModularFormsAmbient_g0_Q(ambient.ModularFormsAmbient):
'\n A space of modular forms for `\\Gamma_0(N)` over `\\QQ`.\n '
def __init__(self, level, weight):
"\n Create a space of modular symbols for `\\Gamma_0(N)` of given\n weight defined over `\\QQ`.\n\n EXAMPLES::\n\... |
class ModularFormsAmbient_gH_Q(ambient.ModularFormsAmbient):
'\n A space of modular forms for the group `\\Gamma_H(N)` over the rational numbers.\n '
def __init__(self, group, weight, eis_only):
"\n Create a space of modular forms for `\\Gamma_H(N)` of integral weight over the\n r... |
class ModularFormsAmbient_g1_Q(ModularFormsAmbient_gH_Q):
'\n A space of modular forms for the group `\\Gamma_1(N)` over the rational numbers.\n '
def __init__(self, level, weight, eis_only):
"\n Create a space of modular forms for `\\Gamma_1(N)` of integral weight over the\n rati... |
def canonical_parameters(group, level, weight, base_ring):
"\n Given a group, level, weight, and base_ring as input by the user,\n return a canonicalized version of them, where level is a Sage\n integer, group really is a group, weight is a Sage integer, and\n base_ring a Sage ring. Note that we can't... |
def ModularForms_clear_cache():
'\n Clear the cache of modular forms.\n\n EXAMPLES::\n\n sage: M = ModularForms(37,2)\n sage: sage.modular.modform.constructor._cache == {}\n False\n\n ::\n\n sage: sage.modular.modform.constructor.ModularForms_clear_cache()\n sage: sage.... |
def ModularForms(group=1, weight=2, base_ring=None, eis_only=False, use_cache=True, prec=defaults.DEFAULT_PRECISION):
"\n Create an ambient space of modular forms.\n\n INPUT:\n\n - ``group`` - A congruence subgroup or a Dirichlet character eps.\n\n - ``weight`` - int, the weight, which must be an inte... |
def CuspForms(group=1, weight=2, base_ring=None, use_cache=True, prec=defaults.DEFAULT_PRECISION):
'\n Create a space of cuspidal modular forms.\n\n See the documentation for the ModularForms command for a\n description of the input parameters.\n\n EXAMPLES::\n\n sage: CuspForms(11,2)\n ... |
def EisensteinForms(group=1, weight=2, base_ring=None, use_cache=True, prec=defaults.DEFAULT_PRECISION):
'\n Create a space of Eisenstein modular forms.\n\n See the documentation for the ModularForms command for a\n description of the input parameters.\n\n EXAMPLES::\n\n sage: EisensteinForms(1... |
def Newforms(group, weight=2, base_ring=None, names=None):
"\n Returns a list of the newforms of the given weight and level (or weight,\n level and character). These are calculated as\n `\\operatorname{Gal}(\\overline{F} / F)`-orbits, where `F` is the given base\n field.\n\n INPUT:\n\n\n - ``gr... |
def Newform(identifier, group=None, weight=2, base_ring=QQ, names=None):
"\n INPUT:\n\n\n - ``identifier`` - a canonical label, or the index of\n the specific newform desired\n\n - ``group`` - the congruence subgroup of the newform\n\n - ``weight`` - the weight of the newform (default 2)\n\n ... |
def parse_label(s):
"\n Given a string s corresponding to a newform label, return the\n corresponding group and index.\n\n EXAMPLES::\n\n sage: sage.modular.modform.constructor.parse_label('11a')\n (Congruence Subgroup Gamma0(11), 0)\n sage: sage.modular.modform.constructor.parse_lab... |
def eisenstein_series_qexp(k, prec=10, K=QQ, var='q', normalization='linear'):
'\n Return the `q`-expansion of the normalized weight `k` Eisenstein series on\n `\\SL_2(\\ZZ)` to precision prec in the ring `K`. Three normalizations\n are available, depending on the parameter ``normalization``; the default... |
def __common_minimal_basering(chi, psi):
'\n Find the smallest basering over which chi and psi are valued, and\n return new chi and psi valued in that ring.\n\n EXAMPLES::\n\n sage: # needs sage.rings.number_field\n sage: sage.modular.modform.eis_series.__common_minimal_basering(DirichletGr... |
def __find_eisen_chars(character, k):
'\n Find all triples `(\\psi_1, \\psi_2, t)` that give rise to an Eisenstein series of the given weight and character.\n\n EXAMPLES::\n\n sage: sage.modular.modform.eis_series.__find_eisen_chars(DirichletGroup(36).0, 4)\n []\n\n sage: pars = sage.m... |
def __find_eisen_chars_gammaH(N, H, k):
'\n Find all triples `(\\psi_1, \\psi_2, t)` that give rise to an Eisenstein series of weight `k` on\n `\\Gamma_H(N)`.\n\n EXAMPLES::\n\n sage: pars = sage.modular.modform.eis_series.__find_eisen_chars_gammaH(15, [2], 5)\n sage: [(x[0].values_on_gens... |
def __find_eisen_chars_gamma1(N, k):
'\n Find all triples `(\\psi_1, \\psi_2, t)` that give rise to an Eisenstein series of weight `k` on\n `\\Gamma_1(N)`.\n\n EXAMPLES::\n\n sage: pars = sage.modular.modform.eis_series.__find_eisen_chars_gamma1(12, 4)\n sage: [(x[0].values_on_gens(), x[1].... |
def eisenstein_series_lseries(weight, prec=53, max_imaginary_part=0, max_asymp_coeffs=40):
"\n Return the L-series of the weight `2k` Eisenstein series\n on `\\SL_2(\\ZZ)`.\n\n This actually returns an interface to Tim Dokchitser's program\n for computing with the L-series of the Eisenstein series\n\n... |
def compute_eisenstein_params(character, k):
'\n Compute and return a list of all parameters `(\\chi,\\psi,t)` that\n define the Eisenstein series with given character and weight `k`.\n\n Only the parity of `k` is relevant (unless k = 1, which is a slightly different case).\n\n If ``character`` is an ... |
class EisensteinSubmodule(submodule.ModularFormsSubmodule):
'\n The Eisenstein submodule of an ambient space of modular forms.\n '
def __init__(self, ambient_space):
'\n Return the Eisenstein submodule of the given space.\n\n EXAMPLES::\n\n sage: E = ModularForms(23,4).... |
class EisensteinSubmodule_params(EisensteinSubmodule):
@cached_method
def parameters(self):
'\n Return a list of parameters for each Eisenstein series\n spanning self. That is, for each such series, return a triple\n of the form (`\\psi`, `\\chi`, level), where `\\psi` and `\\chi... |
class EisensteinSubmodule_g0_Q(EisensteinSubmodule_params):
'\n Space of Eisenstein forms for `\\Gamma_0(N)`.\n '
def _pari_init_(self):
'\n Conversion to Pari.\n\n EXAMPLES::\n\n sage: E = EisensteinForms(17,4)\n sage: pari.mfdim(E)\n 2\n ... |
class EisensteinSubmodule_gH_Q(EisensteinSubmodule_params):
'\n Space of Eisenstein forms for `\\Gamma_H(N)`.\n '
def _parameters_character(self):
'\n Return the character defining self. Since self is\n a space of Eisenstein forms on GammaH(N) rather than a space with fixed\n ... |
class EisensteinSubmodule_g1_Q(EisensteinSubmodule_gH_Q):
'\n Space of Eisenstein forms for `\\Gamma_1(N)`.\n '
def _parameters_character(self):
'\n Return the character defining self.\n\n Since self is a space of Eisenstein\n forms on `\\Gamma_1(N)`, all characters modulo ... |
class EisensteinSubmodule_eps(EisensteinSubmodule_params):
'\n Space of Eisenstein forms with given Dirichlet character.\n\n EXAMPLES::\n\n sage: e = DirichletGroup(27,CyclotomicField(3)).0**2\n sage: M = ModularForms(e,2,prec=10).eisenstein_subspace()\n sage: M.dimension()\n 6\n... |
def cyclotomic_restriction(L, K):
'\n Given two cyclotomic fields L and K, compute the compositum\n M of K and L, and return a function and the index [M:K]. The\n function is a map that acts as follows (here `M = Q(\\zeta_m)`):\n\n INPUT:\n\n element alpha in L\n\n OUTPUT:\n\n a polynomial `f... |
def cyclotomic_restriction_tower(L, K):
'\n Suppose L/K is an extension of cyclotomic fields and L=Q(zeta_m).\n This function computes a map with the following property:\n\n\n INPUT:\n\n an element alpha in L\n\n OUTPUT:\n\n a polynomial `f(x)` in `K[x]` such that `f(zeta_m) = alpha`.\n\n EXA... |
def is_ModularFormElement(x):
'\n Return ``True`` if x is a modular form.\n\n EXAMPLES::\n\n sage: from sage.modular.modform.element import is_ModularFormElement\n sage: is_ModularFormElement(5)\n False\n sage: is_ModularFormElement(ModularForms(11).0)\n True\n '
re... |
def delta_lseries(prec=53, max_imaginary_part=0, max_asymp_coeffs=40, algorithm=None):
'\n Return the L-series of the modular form `\\Delta`.\n\n If algorithm is "gp", this returns an interface to Tim\n Dokchitser\'s program for computing with the L-series of the\n modular form `\\Delta`.\n\n If al... |
class ModularForm_abstract(ModuleElement):
'\n Constructor for generic class of a modular form. This\n should never be called directly; instead one should\n instantiate one of the derived classes of this\n class.\n '
def group(self):
'\n Return the group for which ``self`` is a ... |
class Newform(ModularForm_abstract):
def __init__(self, parent, component, names, check=True):
"\n Initialize a Newform object.\n\n INPUT:\n\n - ``parent`` - An ambient cuspidal space of modular forms for\n which self is a newform.\n\n - ``component`` - A simple compo... |
class ModularFormElement(ModularForm_abstract, element.HeckeModuleElement):
def __init__(self, parent, x, check=True):
'\n An element of a space of modular forms.\n\n INPUT:\n\n - ``parent`` - ModularForms (an ambient space of modular forms)\n\n - ``x`` - a vector on the basis... |
class ModularFormElement_elliptic_curve(Newform):
'\n A modular form attached to an elliptic curve over `\\QQ`.\n '
def __init__(self, parent, E):
"\n Modular form attached to an elliptic curve as an element\n of a space of modular forms.\n\n EXAMPLES::\n\n sage:... |
class EisensteinSeries(ModularFormElement):
'\n An Eisenstein series.\n\n EXAMPLES::\n\n sage: E = EisensteinForms(1,12)\n sage: E.eisenstein_series()\n [\n 691/65520 + q + 2049*q^2 + 177148*q^3 + 4196353*q^4 + 48828126*q^5 + O(q^6)\n ]\n sage: E = EisensteinForms(1... |
class GradedModularFormElement(ModuleElement):
'\n The element class for ``ModularFormsRing``. A ``GradedModularFormElement`` is basically a\n formal sum of modular forms of different weight: `f_1 + f_2 + ... + f_n`. Note that a\n ``GradedModularFormElement`` is not necessarily a modular form (as it can ... |
def half_integral_weight_modform_basis(chi, k, prec):
'\n A basis for the space of weight `k/2` forms with character\n `\\chi`. The modulus of `\\chi` must be divisible by\n `16` and `k` must be odd and `>1`.\n\n INPUT:\n\n - ``chi`` -- a Dirichlet character with modulus divisible by 16\n\n - ``... |
def hecke_operator_on_qexp(f, n, k, eps=None, prec=None, check=True, _return_list=False):
'\n Given the `q`-expansion `f` of a modular form with character\n `\\varepsilon`, this function computes the image of `f` under the\n Hecke operator `T_{n,k}` of weight `k`.\n\n EXAMPLES::\n\n sage: M = M... |
def _hecke_operator_on_basis(B, V, n, k, eps):
'\n Does the work for hecke_operator_on_basis once the input\n is normalized.\n\n EXAMPLES::\n\n sage: hecke_operator_on_basis(ModularForms(1,16).q_expansion_basis(30), 3, 16) # indirect doctest\n [ -3348 0]\n [ 0 14348908... |
def hecke_operator_on_basis(B, n, k, eps=None, already_echelonized=False):
'\n Given a basis `B` of `q`-expansions for a space of modular forms\n with character `\\varepsilon` to precision at least `\\#B\\cdot n+1`,\n this function computes the matrix of `T_n` relative to `B`.\n\n .. note::\n\n ... |
def j_invariant_qexp(prec=10, K=QQ):
'\n Return the `q`-expansion of the `j`-invariant to\n precision ``prec`` in the field `K`.\n\n .. SEEALSO::\n\n If you want to evaluate (numerically) the `j`-invariant at\n certain points, see the special function :func:`elliptic_j`.\n\n .. WARNING::... |
class GrossZagierLseries(SageObject):
def __init__(self, E, A, prec=53):
"\n Class for the Gross-Zagier L-series.\n\n This is attached to a pair `(E,A)` where `E` is an elliptic curve over\n `\\QQ` and `A` is an ideal class in an imaginary quadratic number field.\n\n For the e... |
@richcmp_method
class NumericalEigenforms(SageObject):
'\n numerical_eigenforms(group, weight=2, eps=1e-20, delta=1e-2, tp=[2,3,5])\n\n INPUT:\n\n - ``group`` - a congruence subgroup of a Dirichlet character of\n order 1 or 2\n\n - ``weight`` - an integer >= 2\n\n - ``eps`` - a small float; ab... |
def support(v, eps):
'\n Given a vector `v` and a threshold eps, return all\n indices where `|v|` is larger than eps.\n\n EXAMPLES::\n\n sage: sage.modular.modform.numerical.support( numerical_eigenforms(61)._easy_vector(), 1.0 )\n []\n\n sage: sage.modular.modform.numerical.support(... |
def _span_of_forms_in_weight(forms, weight, prec, stop_dim=None, use_random=False):
"\n Utility function. Given a nonempty list of pairs ``(k,f)``, where `k` is an\n integer and `f` is a power series, and a weight l, return all weight l\n forms obtained by multiplying together the given forms.\n\n INP... |
@richcmp_method
class ModularFormsRing(Parent):
"\n The ring of modular forms (of weights 0 or at least 2) for a congruence\n subgroup of `\\SL_2(\\ZZ)`, with coefficients in a specified base ring.\n\n EXAMPLES::\n\n sage: ModularFormsRing(Gamma1(13))\n Ring of Modular Forms for Congruence ... |
def is_ModularFormsSpace(x):
'\n Return True if x is a ```ModularFormsSpace```.\n\n EXAMPLES::\n\n sage: from sage.modular.modform.space import is_ModularFormsSpace\n sage: is_ModularFormsSpace(ModularForms(11,2))\n True\n sage: is_ModularFormsSpace(CuspForms(11,2))\n True... |
@richcmp_method
class ModularFormsSpace(hecke.HeckeModule_generic):
'\n A generic space of modular forms.\n '
Element = ModularFormElement
def __init__(self, group, weight, character, base_ring, category=None):
'\n Generic spaces of modular forms. For spaces of modular forms for\n ... |
def contains_each(V, B):
'\n Determine whether or not V contains every element of B. Used here\n for linear algebra, but works very generally.\n\n EXAMPLES::\n\n sage: contains_each = sage.modular.modform.space.contains_each\n sage: contains_each( range(20), prime_range(20) )\n True\... |
class ModularFormsSubmodule(ModularFormsSpace, sage.modular.hecke.submodule.HeckeSubmodule):
'\n A submodule of an ambient space of modular forms.\n '
def __init__(self, ambient_module, submodule, dual=None, check=False):
'\n INPUT:\n\n - ambient_module -- ModularFormsSpace\n ... |
class ModularFormsSubmoduleWithBasis(ModularFormsSubmodule):
pass
|
def theta2_qexp(prec=10, var='q', K=ZZ, sparse=False):
"\n Return the `q`-expansion of the series `\\theta_2 = \\sum_{n \\text{ odd}} q^{n^2}`.\n\n INPUT:\n\n - prec -- integer; the absolute precision of the output\n - var -- (default: 'q') variable name\n - K -- (default: ZZ) base ring of answer\n... |
def theta_qexp(prec=10, var='q', K=ZZ, sparse=False):
"\n Return the `q`-expansion of the standard `\\theta` series\n `\\theta = 1 + 2\\sum_{n=1}^{\\infty} q^{n^2}`.\n\n INPUT:\n\n - prec -- integer; the absolute precision of the output\n - var -- (default: 'q') variable name\n - K -- (default: ... |
def victor_miller_basis(k, prec=10, cusp_only=False, var='q'):
"\n Compute and return the Victor Miller basis for modular forms of\n weight `k` and level 1 to precision `O(q^{prec})`. If\n ``cusp_only`` is True, return only a basis for the cuspidal\n subspace.\n\n INPUT:\n\n - ``k`` -- an integ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.