code stringlengths 17 6.64M |
|---|
def _delta_poly(prec=10):
'\n Return the q-expansion of Delta as a FLINT polynomial. Used internally by\n the :func:`~delta_qexp` function. See the docstring of :func:`~delta_qexp`\n for more information.\n\n INPUT:\n\n - ``prec`` -- integer; the absolute precision of the output\n\n OUTPUT:\n\n ... |
def _delta_poly_modulo(N, prec=10):
'\n Return the q-expansion of `\\Delta` modulo `N`. Used internally by\n the :func:`~delta_qexp` function. See the docstring of :func:`~delta_qexp`\n for more information.\n\n INPUT:\n\n - `N` -- positive integer modulo which we want to compute `\\Delta`\n\n -... |
def delta_qexp(prec=10, var='q', K=ZZ):
"\n Return the `q`-expansion of the weight 12 cusp form `\\Delta` as a power\n series with coefficients in the ring K (`= \\ZZ` by default).\n\n INPUT:\n\n - ``prec`` -- integer (default 10), the absolute precision of the output\n (must be positive)\n\n ... |
@cached_function
def modular_ratio_space(chi):
"\n Compute the space of 'modular ratios', i.e. meromorphic modular forms f\n level N and character chi such that f * E is a holomorphic cusp form for\n every Eisenstein series E of weight 1 and character 1/chi.\n\n Elements are returned as q-expansions u... |
def modular_ratio_to_prec(chi, qexp, prec):
'\n Given a q-expansion of a modular ratio up to sufficient precision to\n determine it uniquely, compute it to greater precision.\n\n EXAMPLES::\n\n sage: from sage.modular.modform.weight1 import modular_ratio_to_prec\n sage: R.<q> = QQ[[]]\n ... |
@cached_function
def hecke_stable_subspace(chi, aux_prime=ZZ(2)):
'\n Compute a q-expansion basis for S_1(chi).\n\n Results are returned as q-expansions to a certain fixed (and fairly high)\n precision. If more precision is required this can be obtained with\n :func:`modular_ratio_to_prec`.\n\n EXA... |
@cached_function
def dimension_wt1_cusp_forms(chi):
'\n Return the dimension of the space of cusp forms of weight 1 and character chi.\n\n EXAMPLES::\n\n sage: chi = DirichletGroup(59, QQ).0\n sage: sage.modular.modform.weight1.dimension_wt1_cusp_forms(chi)\n 1\n '
return len(hec... |
@cached_function
def dimension_wt1_cusp_forms_gH(group):
'\n Return the dimension of the space of cusp forms of weight 1 for the given\n group (which should be of GammaH type). Computed by summing over Galois\n orbits of characters modulo H.\n\n EXAMPLES::\n\n sage: sage.modular.modform.weight1... |
class FormsRing_abstract(Parent):
'\n Abstract (Hecke) forms ring.\n\n This should never be called directly. Instead one should\n instantiate one of the derived classes of this class.\n '
from .graded_ring_element import FormsRingElement
Element = FormsRingElement
from .analytic_type impor... |
class FormsSpace_abstract(FormsRing_abstract):
'\n Abstract (Hecke) forms space.\n\n This should never be called directly. Instead one should\n instantiate one of the derived classes of this class.\n '
from .element import FormsElement
Element = FormsElement
def __init__(self, group, base... |
class AnalyticTypeElement(LatticePosetElement):
'\n Analytic types of forms and/or spaces.\n\n An analytic type element describes what basic analytic\n properties are contained/included in it.\n\n EXAMPLES::\n\n sage: from sage.modular.modform_hecketriangle.analytic_type import (AnalyticType, A... |
class AnalyticType(FiniteLatticePoset):
'\n Container for all possible analytic types of forms and/or spaces.\n\n The ``analytic type`` of forms spaces or rings describes all possible\n occurring basic ``analytic properties`` of elements in the space/ring\n (or more).\n\n For ambient spaces/rings t... |
def rational_type(f, n=ZZ(3), base_ring=ZZ):
'\n Return the basic analytic properties that can be determined\n directly from the specified rational function ``f``\n which is interpreted as a representation of an\n element of a FormsRing for the Hecke Triangle group\n with parameter ``n`` and the sp... |
def FormsSpace(analytic_type, group=3, base_ring=ZZ, k=QQ(0), ep=None):
'\n Return the FormsSpace with the given ``analytic_type``, ``group``\n ``base_ring`` and degree (``k``, ``ep``).\n\n INPUT:\n\n - ``analytic_type`` -- An element of ``AnalyticType()`` describing\n the analytic type of the sp... |
def FormsRing(analytic_type, group=3, base_ring=ZZ, red_hom=False):
'\n Return the FormsRing with the given ``analytic_type``, ``group``\n ``base_ring`` and variable ``red_hom``.\n\n INPUT:\n\n - ``analytic_type`` -- An element of ``AnalyticType()`` describing\n the analytic type of the space.\n\... |
class FormsElement(FormsRingElement):
'\n (Hecke) modular forms.\n '
def __init__(self, parent, rat):
'\n An element of a space of (Hecke) modular forms.\n\n INPUT:\n\n - ``parent`` -- a modular form space\n\n - ``rat`` -- a rational function which corresponds to a\n... |
def _get_base_ring(ring, var_name='d'):
'\n Return the base ring of the given ``ring``:\n\n If ``ring`` is of the form ``FractionField(PolynomialRing(R,\'d\'))``:\n Return ``R``.\n\n If ``ring`` is of the form ``FractionField(R)``:\n Return ``R``.\n\n If ``ring`` is of the form ``PolynomialRing(... |
def _common_subgroup(group1, group2):
'\n Return a common (Hecke triangle) subgroup of both given groups\n ``group1`` and ``group2`` if it exists. Otherwise return ``None``.\n\n EXAMPLES::\n\n sage: from sage.modular.modform_hecketriangle.functors import _common_subgroup\n sage: from sage.m... |
def ConstantFormsSpaceFunctor(group):
'\n Construction functor for the space of constant forms.\n\n When determining a common parent between a ring\n and a forms ring or space this functor is first\n applied to the ring.\n\n EXAMPLES::\n\n sage: from sage.modular.modform_hecketriangle.functo... |
class FormsSubSpaceFunctor(ConstructionFunctor):
'\n Construction functor for forms sub spaces.\n '
rank = 10
def __init__(self, ambient_space_functor, generators):
'\n Construction functor for the forms sub space\n for the given ``generators`` inside the ambient space\n ... |
class FormsSpaceFunctor(ConstructionFunctor):
'\n Construction functor for forms spaces.\n\n NOTE:\n\n When the base ring is not a ``BaseFacade`` the functor is first\n merged with the ConstantFormsSpaceFunctor. This case occurs in\n the pushout constructions (when trying to find a common parent\n... |
class FormsRingFunctor(ConstructionFunctor):
'\n Construction functor for forms rings.\n\n NOTE:\n\n When the base ring is not a ``BaseFacade`` the functor is first\n merged with the ConstantFormsSpaceFunctor. This case occurs in\n the pushout constructions. (when trying to find a common parent\n... |
class BaseFacade(Parent, UniqueRepresentation):
"\n BaseFacade of a ring.\n\n This class is used to distinguish the construction of\n constant elements (modular forms of weight 0) over the given ring\n and the construction of ``FormsRing`` or ``FormsSpace``\n based on the BaseFacade of the given ri... |
def canonical_parameters(group, base_ring, red_hom, n=None):
'\n Return a canonical version of the parameters.\n\n EXAMPLES::\n\n sage: from sage.modular.modform_hecketriangle.graded_ring import canonical_parameters\n sage: canonical_parameters(4, ZZ, 1)\n (Hecke triangle group for n = ... |
class QuasiMeromorphicModularFormsRing(FormsRing_abstract, UniqueRepresentation):
'\n Graded ring of (Hecke) quasi meromorphic modular forms\n for the given group and base ring.\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, red_hom=False, n=None):
'\... |
class QuasiWeakModularFormsRing(FormsRing_abstract, UniqueRepresentation):
'\n Graded ring of (Hecke) quasi weakly holomorphic modular forms\n for the given group and base ring.\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, red_hom=False, n=None):
'\... |
class QuasiModularFormsRing(FormsRing_abstract, UniqueRepresentation):
'\n Graded ring of (Hecke) quasi modular forms\n for the given group and base ring\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, red_hom=False, n=None):
'\n Return a (cache... |
class QuasiCuspFormsRing(FormsRing_abstract, UniqueRepresentation):
'\n Graded ring of (Hecke) quasi cusp forms\n for the given group and base ring.\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, red_hom=False, n=None):
'\n Return a (cached) in... |
class MeromorphicModularFormsRing(FormsRing_abstract, UniqueRepresentation):
'\n Graded ring of (Hecke) meromorphic modular forms\n for the given group and base ring\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, red_hom=False, n=None):
'\n Ret... |
class WeakModularFormsRing(FormsRing_abstract, UniqueRepresentation):
'\n Graded ring of (Hecke) weakly holomorphic modular forms\n for the given group and base ring\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, red_hom=False, n=None):
'\n Ret... |
class ModularFormsRing(FormsRing_abstract, UniqueRepresentation):
'\n Graded ring of (Hecke) modular forms\n for the given group and base ring\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, red_hom=False, n=None):
'\n Return a (cached) instance... |
class CuspFormsRing(FormsRing_abstract, UniqueRepresentation):
'\n Graded ring of (Hecke) cusp forms\n for the given group and base ring\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, red_hom=False, n=None):
'\n Return a (cached) instance with ... |
class FormsRingElement(CommutativeAlgebraElement, UniqueRepresentation, metaclass=InheritComparisonClasscallMetaclass):
'\n Element of a FormsRing.\n '
from .analytic_type import AnalyticType
AT = AnalyticType()
@staticmethod
def __classcall__(cls, parent, rat):
'\n Return a ... |
def coerce_AA(p):
'\n Return the argument first coerced into ``AA`` and then simplified.\n\n This leads to a major performance gain with some operations.\n\n EXAMPLES::\n\n sage: # needs sage.rings.number_field sage.symbolic\n sage: from sage.modular.modform_hecketriangle.hecke_triangle_gro... |
def cyclic_representative(L):
'\n Return a unique representative among all cyclic permutations\n of the given list/tuple.\n\n INPUT:\n\n - ``L`` -- A list or tuple.\n\n OUTPUT:\n\n The maximal element among all cyclic permutations with respect\n to lexicographical ordering.\n\n EXAMPLES::\... |
class HeckeTriangleGroupElement(MatrixGroupElement_generic):
'\n Elements of HeckeTriangleGroup.\n '
def __init__(self, parent, M, check=True, **kwargs):
"\n An element of HeckeTriangle group given by a matrix ``M``.\n\n INPUT:\n\n - ``parent`` -- A ``HeckeTriangleGroup``.\... |
class HeckeTriangleGroup(FinitelyGeneratedMatrixGroup_generic, UniqueRepresentation):
'\n Hecke triangle group `(2, n, \\infty)`.\n '
Element = HeckeTriangleGroupElement
@staticmethod
def __classcall__(cls, n=3):
'\n Return a (cached) instance with canonical parameters.\n\n ... |
class MFSeriesConstructor(SageObject, UniqueRepresentation):
'\n Constructor for the Fourier expansion of some\n (specific, basic) modular forms.\n\n The constructor is used by forms elements in case\n their Fourier expansion is needed or requested.\n '
@staticmethod
def __classcall__(cls,... |
def canonical_parameters(group, base_ring, k, ep, n=None):
'\n Return a canonical version of the parameters.\n\n EXAMPLES::\n\n sage: from sage.modular.modform_hecketriangle.space import canonical_parameters\n sage: canonical_parameters(5, ZZ, 20/3, int(1))\n (Hecke triangle group for n... |
class QuasiMeromorphicModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Module of (Hecke) quasi meromorphic modular forms\n for the given group, base ring, weight and multiplier\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=Non... |
class QuasiWeakModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Module of (Hecke) quasi weakly holomorphic modular forms\n for the given group, base ring, weight and multiplier\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=Non... |
class QuasiModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Module of (Hecke) quasi modular forms\n for the given group, base ring, weight and multiplier\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=None, n=None):
'\n... |
class QuasiCuspForms(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Module of (Hecke) quasi cusp forms\n for the given group, base ring, weight and multiplier\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=None, n=None):
'\n ... |
class MeromorphicModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Module of (Hecke) meromorphic modular forms\n for the given group, base ring, weight and multiplier\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=None, n=None):... |
class WeakModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Module of (Hecke) weakly holomorphic modular forms\n for the given group, base ring, weight and multiplier\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=None, n=None):... |
class ModularForms(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Module of (Hecke) modular forms\n for the given group, base ring, weight and multiplier\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=None, n=None):
'\n Ret... |
class CuspForms(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Module of (Hecke) cusp forms\n for the given group, base ring, weight and multiplier\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=None, n=None):
'\n Return a ... |
class ZeroForm(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Zero Module for the zero form for the given group, base ring\n weight and multiplier\n '
@staticmethod
def __classcall__(cls, group=HeckeTriangleGroup(3), base_ring=ZZ, k=QQ(0), ep=None, n=None):
'\n Return a (... |
def canonical_parameters(ambient_space, basis, check=True):
'\n Return a canonical version of the parameters.\n In particular the list/tuple ``basis`` is replaced by a\n tuple of linearly independent elements in the ambient space.\n\n If ``check=False`` (default: ``True``) then ``basis``\n is assum... |
def ModularFormsSubSpace(*args, **kwargs):
'\n Create a modular forms subspace generated by the supplied arguments if possible.\n Instead of a list of generators also multiple input arguments can be used.\n If ``reduce=True`` then the corresponding ambient space is choosen as small as possible.\n If n... |
class SubSpaceForms(FormsSpace_abstract, Module, UniqueRepresentation):
'\n Submodule of (Hecke) forms in the given ambient space for the given basis.\n '
@staticmethod
def __classcall__(cls, ambient_space, basis=(), check=True):
'\n Return a (cached) instance with canonical paramete... |
class ModularSymbolsAmbient(ModularSymbolsSpace, AmbientHeckeModule):
'\n An ambient space of modular symbols for a congruence subgroup of\n `SL_2(\\ZZ)`.\n\n This class is an abstract base class, so only derived classes\n should be instantiated.\n\n INPUT:\n\n - ``weight`` - an integer\n - `... |
class ModularSymbolsAmbient_wtk_g0(ModularSymbolsAmbient):
'\n Modular symbols for `\\Gamma_0(N)` of integer weight\n `k > 2` over the field `F`.\n\n For weight `2`, it is faster to use ``ModularSymbols_wt2_g0``.\n\n INPUT:\n\n\n - ``N`` - int, the level\n\n - ``k`` - integer weight = 2.\n\n ... |
class ModularSymbolsAmbient_wt2_g0(ModularSymbolsAmbient_wtk_g0):
'\n Modular symbols for `\\Gamma_0(N)` of integer weight `2` over the field\n `F`.\n\n INPUT:\n\n - ``N`` - int, the level\n\n - ``sign`` - int, either -1, 0, or 1\n\n\n OUTPUT:\n\n The space of modular symbols of weight `2`,... |
class ModularSymbolsAmbient_wtk_g1(ModularSymbolsAmbient):
'\n INPUT:\n\n\n - ``level`` - int, the level\n\n - ``weight`` - int, the weight = 2\n\n - ``sign`` - int, either -1, 0, or 1\n\n - ``F`` - field\n\n\n EXAMPLES::\n\n sage: ModularSymbols(Gamma1(17),2)\n Modular Symbols... |
class ModularSymbolsAmbient_wtk_gamma_h(ModularSymbolsAmbient):
def __init__(self, group, weight, sign, F, custom_init=None, category=None):
'\n Initialize a space of modular symbols for `\\Gamma_H(N)`.\n\n INPUT:\n\n\n - ``group`` - a congruence subgroup\n `\\Gamma_H(N)`.... |
class ModularSymbolsAmbient_wtk_eps(ModularSymbolsAmbient):
def __init__(self, eps, weight, sign, base_ring, custom_init=None, category=None):
'\n Space of modular symbols with given weight, character, base ring and\n sign.\n\n INPUT:\n\n\n - ``eps`` - dirichlet.DirichletChar... |
class BoundarySpaceElement(hecke.HeckeModuleElement):
def __init__(self, parent, x):
"\n Create a boundary symbol.\n\n INPUT:\n\n\n - ``parent`` - BoundarySpace; a space of boundary\n modular symbols\n\n - ``x`` - a dict with integer keys and values in the\n ... |
@richcmp_method
class BoundarySpace(hecke.HeckeModule_generic):
def __init__(self, group=arithgroup.Gamma0(1), weight=2, sign=0, base_ring=QQ, character=None):
'\n Space of boundary symbols for a congruence subgroup of SL_2(Z).\n\n This class is an abstract base class, so only derived class... |
class BoundarySpace_wtk_g0(BoundarySpace):
def __init__(self, level, weight, sign, F):
"\n Initialize a space of boundary symbols of weight k for Gamma_0(N)\n over base field F.\n\n INPUT:\n\n\n - ``level`` - int, the level\n\n - ``weight`` - integer weight = 2.\n\n ... |
class BoundarySpace_wtk_g1(BoundarySpace):
def __init__(self, level, weight, sign, F):
'\n Initialize a space of boundary modular symbols for Gamma1(N).\n\n INPUT:\n\n\n - ``level`` - int, the level\n\n - ``weight`` - int, the weight = 2\n\n - ``sign`` - int, either ... |
class BoundarySpace_wtk_gamma_h(BoundarySpace):
def __init__(self, group, weight, sign, F):
'\n Initialize a space of boundary modular symbols for GammaH(N).\n\n INPUT:\n\n\n - ``group`` - congruence subgroup Gamma_H(N).\n\n - ``weight`` - int, the weight = 2\n\n - `... |
class BoundarySpace_wtk_eps(BoundarySpace):
def __init__(self, eps, weight, sign=0):
'\n Space of boundary modular symbols with given weight, character, and\n sign.\n\n INPUT:\n\n\n - ``eps`` - dirichlet.DirichletCharacter, the\n "Nebentypus" character.\n\n -... |
def is_ModularSymbolsElement(x) -> bool:
'\n Return True if x is an element of a modular symbols space.\n\n EXAMPLES::\n\n sage: sage.modular.modsym.element.is_ModularSymbolsElement(ModularSymbols(11, 2).0)\n True\n sage: sage.modular.modsym.element.is_ModularSymbolsElement(13)\n ... |
def set_modsym_print_mode(mode='manin'):
"\n Set the mode for printing of elements of modular symbols spaces.\n\n INPUT:\n\n - ``mode`` - a string. The possibilities are as\n follows:\n\n - ``'manin'`` - (the default) formal sums of Manin\n symbols [P(X,Y),(u,v)]\n\n - ``'modular'`` ... |
class ModularSymbolsElement(hecke.HeckeModuleElement):
'\n An element of a space of modular symbols.\n\n TESTS::\n\n sage: x = ModularSymbols(3, 12).cuspidal_submodule().gen(0)\n sage: x == loads(dumps(x))\n True\n '
def __init__(self, parent, x, check=True):
'\n ... |
@richcmp_method
class G1list(SageObject):
'\n A class representing a list of coset representatives for `\\Gamma_1(N)` in\n `\\SL_2(\\ZZ)`. What we actually calculate is a list of elements of\n `(\\ZZ/N\\ZZ)^2` of exact order `N`.\n\n TESTS::\n\n sage: L = sage.modular.modsym.g1list.G1list(18)\n... |
class _G1list_old_pickle(G1list):
'\n This class exists only for dealing with old pickles.\n\n This needs to handle both old-style class pickles, where there is\n no input to the class on the initial ``__init__`` call, and the\n new class pickles, we need to have ``__setstate__`` handle it.\n '
... |
@richcmp_method
class GHlist(SageObject):
'\n A class representing a list of coset representatives for `\\Gamma_H(N)` in\n `\\SL_2(\\ZZ)`.\n\n TESTS::\n\n sage: L = sage.modular.modsym.ghlist.GHlist(GammaH(18,[13]))\n sage: loads(dumps(L)) == L\n True\n '
def __init__(self, g... |
class _GHlist_old_pickle(GHlist):
'\n This class exists only for dealing with old pickles.\n\n This needs to handle both old-style class pickles, where there is\n no input to the class on the initial ``__init__`` call, and the\n new class pickles, we need to have ``__setstate__`` handle it.\n '
... |
class HeckeOperator(sage.modular.hecke.hecke_operator.HeckeOperator):
def apply_sparse(self, x):
'\n Return the image of ``x`` under ``self``.\n\n If ``x`` is not in ``self.domain()``, raise a ``TypeError``.\n\n EXAMPLES::\n\n sage: M = ModularSymbols(17,4,-1)\n ... |
@richcmp_method
class ManinSymbolList(Parent):
'\n Base class for lists of all Manin symbols for a given weight, group or character.\n '
Element = ManinSymbol
def __init__(self, weight, lst):
'\n Constructor for a ManinSymbolList.\n\n INPUT:\n\n - ``weight`` -- the weig... |
class ManinSymbolList_group(ManinSymbolList):
'\n Base class for Manin symbol lists for a given group.\n\n INPUT:\n\n - ``level`` -- integer level\n\n - ``weight`` -- integer weight\n\n - ``syms`` -- something with ``normalize`` and ``list`` methods,\n e.g. :class:`~sage.modular.modsym.p1list... |
class ManinSymbolList_gamma0(ManinSymbolList_group):
'\n Class for Manin symbols for `\\Gamma_0(N)`.\n\n INPUT:\n\n - ``level`` - (integer): the level.\n\n - ``weight`` - (integer): the weight.\n\n EXAMPLES::\n\n sage: from sage.modular.modsym.manin_symbol_list import ManinSymbolList_gamma0\... |
class ManinSymbolList_gamma1(ManinSymbolList_group):
'\n Class for Manin symbols for `\\Gamma_1(N)`.\n\n INPUT:\n\n - ``level`` - (integer): the level.\n\n - ``weight`` - (integer): the weight.\n\n EXAMPLES::\n\n sage: from sage.modular.modsym.manin_symbol_list import ManinSymbolList_gamma1\... |
class ManinSymbolList_gamma_h(ManinSymbolList_group):
'\n Class for Manin symbols for `\\Gamma_H(N)`.\n\n INPUT:\n\n - ``group`` - (integer): the congruence subgroup.\n\n - ``weight`` - (integer): the weight.\n\n EXAMPLES::\n\n sage: from sage.modular.modsym.manin_symbol_list import ManinSym... |
class ManinSymbolList_character(ManinSymbolList):
'\n List of Manin symbols with character.\n\n INPUT:\n\n - ``character`` -- (DirichletCharacter) the Dirichlet character\n\n - ``weight`` -- (integer) the weight\n\n EXAMPLES::\n\n sage: # needs sage.rings.number_field\n sage: eps = Di... |
def canonical_parameters(group, weight, sign, base_ring):
"\n Return the canonically normalized parameters associated to a choice\n of group, weight, sign, and base_ring. That is, normalize each of\n these to be of the correct type, perform all appropriate type\n checking, etc.\n\n EXAMPLES::\n\n ... |
def ModularSymbols_clear_cache():
'\n Clear the global cache of modular symbols spaces.\n\n EXAMPLES::\n\n sage: sage.modular.modsym.modsym.ModularSymbols_clear_cache()\n sage: sorted(sage.modular.modsym.modsym._cache)\n []\n sage: M = ModularSymbols(6,2)\n sage: sorted(sa... |
def ModularSymbols(group=1, weight=2, sign=0, base_ring=None, use_cache=True, custom_init=None):
'\n Create an ambient space of modular symbols.\n\n INPUT:\n\n - ``group`` - A congruence subgroup or a Dirichlet character eps.\n - ``weight`` - int, the weight, which must be >= 2.\n - ``sign`` - int,... |
@richcmp_method
class ModularSymbol(SageObject):
'\n The modular symbol `X^i\\cdot Y^{k-2-i}\\cdot \\{\\alpha, \\beta\\}`.\n '
def __init__(self, space, i, alpha, beta):
"\n Initialise a modular symbol.\n\n INPUT:\n\n - ``space`` -- space of Manin symbols\n\n - ``i``... |
def P1NFList_clear_level_cache():
"\n Clear the global cache of data for the level ideals.\n\n EXAMPLES::\n\n sage: x = polygen(QQ, 'x')\n sage: k.<a> = NumberField(x^3 + 11)\n sage: N = k.ideal(a+1)\n sage: alpha = MSymbol(N, 2*a^2, 5)\n sage: alpha.normalize()\n M... |
@richcmp_method
class MSymbol(SageObject):
"\n The constructor for an M-symbol over a number field.\n\n INPUT:\n\n - ``N`` -- integral ideal (the modulus or level).\n\n - ``c`` -- integral element of the underlying number field or an MSymbol of\n level N.\n\n - ``d`` -- (optional) when presen... |
@richcmp_method
class P1NFList(SageObject):
"\n The class for `\\mathbb{P}^1(R/N)`, the projective line modulo `N`, where\n `R` is the ring of integers of a number field `K` and `N` is an integral ideal.\n\n INPUT:\n\n - ``N`` - integral ideal (the modulus or level).\n\n OUTPUT:\n\n A P1NFList ... |
def p1NFlist(N):
"\n Return a list of the normalized elements of `\\mathbb{P}^1(R/N)`, where\n `N` is an integral ideal.\n\n INPUT:\n\n - ``N`` - integral ideal (the level or modulus).\n\n EXAMPLES::\n\n sage: x = polygen(QQ, 'x')\n sage: k.<a> = NumberField(x^2 + 23)\n sage: ... |
def lift_to_sl2_Ok(N, c, d):
"\n Lift a pair (c, d) to an element of `SL(2, O_k)`, where `O_k` is the ring\n of integers of the corresponding number field.\n\n INPUT:\n\n - ``N`` -- number field ideal\n\n - ``c`` -- integral element of the number field\n\n - ``d`` -- integral element of the numb... |
def make_coprime(N, c, d):
"\n Return (c, d') so d' is congruent to d modulo N, and such that c and d' are\n coprime (<c> + <d'> = R).\n\n INPUT:\n\n - ``N`` -- number field ideal\n\n - ``c`` -- integral element of the number field\n\n - ``d`` -- integral element of the number field\n\n OUTPU... |
def psi(N):
"\n The index `[\\Gamma : \\Gamma_0(N)]`, where `\\Gamma = GL(2, R)` for `R` the\n corresponding ring of integers, and `\\Gamma_0(N)` standard congruence\n subgroup.\n\n EXAMPLES::\n\n sage: from sage.modular.modsym.p1list_nf import psi\n sage: x = polygen(QQ, 'x')\n s... |
def modS_relations(syms):
'\n Compute quotient of Manin symbols by the S relations.\n\n Here S is the 2x2 matrix [0, -1; 1, 0].\n\n INPUT:\n\n - ``syms`` -- :class:`ManinSymbolList`\n\n OUTPUT:\n\n\n - ``rels`` - set of pairs of pairs (j, s), where if\n mod[i] = (j,s), then x_i = s\\*x_j ... |
def modI_relations(syms, sign):
"\n Compute quotient of Manin symbols by the I relations.\n\n INPUT:\n\n - ``syms`` -- :class:`ManinSymbolList`\n\n - ``sign`` - int (either -1, 0, or 1)\n\n OUTPUT:\n\n - ``rels`` - set of pairs of pairs (j, s), where if\n mod[i] = (j,s), then x_i = s\\*x... |
def T_relation_matrix_wtk_g0(syms, mod, field, sparse):
"\n Compute a matrix whose echelon form gives the quotient by 3-term T\n relations. Despite the name, this is used for all modular symbols spaces\n (including those with character and those for `\\Gamma_1` and `\\Gamma_H`\n groups), not just `\\G... |
def gens_to_basis_matrix(syms, relation_matrix, mod, field, sparse):
'\n Compute echelon form of 3-term relation matrix, and read off each\n generator in terms of basis.\n\n INPUT:\n\n - ``syms`` -- :class:`ManinSymbolList`\n\n - ``relation_matrix`` - as output by\n ``__compute_T_relation_ma... |
def compute_presentation(syms, sign, field, sparse=None):
"\n Compute the presentation for self, as a quotient of Manin symbols\n modulo relations.\n\n INPUT:\n\n - ``syms`` -- :class:`ManinSymbolList`\n\n - ``sign`` - integer (-1, 0, 1)\n\n - ``field`` - a field\n\n\n OUTPUT:\n\n - spa... |
def relation_matrix_wtk_g0(syms, sign, field, sparse):
'\n Compute the matrix of relations. Despite the name, this is used for all\n spaces (not just for Gamma0). For a description of the algorithm, see the\n docstring for ``compute_presentation``.\n\n INPUT:\n\n - ``syms`` -- :class:`ManinSymbolLi... |
def sparse_2term_quotient(rels, n, F):
'\n Perform Sparse Gauss elimination on a matrix all of whose columns\n have at most 2 nonzero entries. We use an obvious algorithm, which\n runs fast enough. (Typically making the list of relations takes\n more time than computing this quotient.) This algorithm ... |
def is_ModularSymbolsSpace(x):
'\n Return ``True`` if ``x`` is a space of modular symbols.\n\n EXAMPLES::\n\n sage: M = ModularForms(3, 2)\n sage: sage.modular.modsym.space.is_ModularSymbolsSpace(M)\n False\n sage: sage.modular.modsym.space.is_ModularSymbolsSpace(M.modular_symbol... |
@richcmp_method
class ModularSymbolsSpace(HeckeModule_free_module):
'\n Base class for spaces of modular symbols.\n '
Element = ModularSymbolsElement
def __init__(self, group, weight, character, sign, base_ring, category=None):
'\n Create a space of modular symbols.\n\n EXAMPL... |
class PeriodMapping(SageObject):
'\n Base class for representing a period mapping attached to a space of modular\n symbols.\n\n To be used via the derived classes :class:`RationalPeriodMapping` and\n :class:`IntegralPeriodMapping`.\n '
def __init__(self, modsym, A):
'\n Standard... |
class RationalPeriodMapping(PeriodMapping):
def _repr_(self):
"\n Return the string representation of ``self``.\n\n EXAMPLES::\n\n sage: ModularSymbols(40,2).rational_period_mapping()._repr_()\n 'Rational period mapping associated to Modular Symbols space of dimension ... |
class IntegralPeriodMapping(PeriodMapping):
def _repr_(self):
"\n Return the string representation of ``self``.\n\n EXAMPLES::\n\n sage: ModularSymbols(40,2).cuspidal_submodule().integral_period_mapping()._repr_()\n 'Integral period mapping associated to Modular Symbol... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.