Analytic types of modular forms

Properties of modular forms and their generalizations are assembled into one partially ordered set. See AnalyticType for a list of handled properties.

AUTHORS:

  • Jonas Jermann (2013): initial version

class sage.modular.modform_hecketriangle.analytic_type.AnalyticType[source]

Bases: FiniteLatticePoset

Container for all possible analytic types of forms and/or spaces.

The analytic type of forms spaces or rings describes all possible occurring basic analytic properties of elements in the space/ring (or more).

For ambient spaces/rings this means that all elements with those properties (and the restrictions of the space/ring) are contained in the space/ring.

The analytic type of an element is the analytic type of its minimal ambient space/ring.

The basic analytic properties are:

  • quasi – whether the element is quasi modular (and not modular) or modular.

  • mero – meromorphic – if the element is meromorphic and meromorphic at infinity

  • weak – weakly holomorphic – if the element is holomorphic and meromorphic at infinity

  • holo – holomorphic – if the element is holomorphic and holomorphic at infinity

  • cusp – cuspidal – if the element additionally has a positive order at infinity

The zero elements/property have no analytic properties (or only quasi).

For ring elements the property describes whether one of its homogeneous components satisfies that property and the “union” of those properties is returned as the analytic type.

Similarly for quasi forms the property describes whether one of its quasi components satisfies that property.

There is a (natural) partial order between the basic properties (and analytic types) given by “inclusion”. We name the analytic type according to its maximal analytic properties.

For \(n=3\) the quasi form el = E6 - E2^3 has the quasi components E6 which is holomorphic and E2^3 which is quasi holomorphic. So the analytic type of el is quasi holomorphic despite the fact that the sum (el) describes a function which is zero at infinity.

EXAMPLES:

sage: from sage.modular.modform_hecketriangle.space import QuasiModularForms
sage: x,y,z,d = var("x,y,z,d")                                                  # needs sage.symbolic
sage: el = QuasiModularForms(n=3, k=6, ep=-1)(y-z^3)                            # needs sage.symbolic
sage: el.analytic_type()                                                        # needs sage.symbolic
quasi modular

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.space import QuasiModularForms
>>> x,y,z,d = var("x,y,z,d")                                                  # needs sage.symbolic
>>> el = QuasiModularForms(n=Integer(3), k=Integer(6), ep=-Integer(1))(y-z**Integer(3))                            # needs sage.symbolic
>>> el.analytic_type()                                                        # needs sage.symbolic
quasi modular

Similarly the type of the ring element el2 = E4/Delta - E6/Delta is weakly holomorphic despite the fact that the sum (el2) describes a function which is holomorphic at infinity:

sage: from sage.modular.modform_hecketriangle.graded_ring import WeakModularFormsRing
sage: x,y,z,d = var("x,y,z,d")                                                  # needs sage.symbolic
sage: el2 = WeakModularFormsRing(n=3)(x/(x^3-y^2)-y/(x^3-y^2))                  # needs sage.symbolic
sage: el2.analytic_type()                                                       # needs sage.symbolic
weakly holomorphic modular

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.graded_ring import WeakModularFormsRing
>>> x,y,z,d = var("x,y,z,d")                                                  # needs sage.symbolic
>>> el2 = WeakModularFormsRing(n=Integer(3))(x/(x**Integer(3)-y**Integer(2))-y/(x**Integer(3)-y**Integer(2)))                  # needs sage.symbolic
>>> el2.analytic_type()                                                       # needs sage.symbolic
weakly holomorphic modular
Element[source]

alias of AnalyticTypeElement

base_poset()[source]

Return the base poset from which everything of self was constructed. Elements of the base poset correspond to the basic analytic properties.

EXAMPLES:

sage: from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
sage: from sage.combinat.posets.posets import FinitePoset
sage: AT = AnalyticType()
sage: P = AT.base_poset()
sage: P
Finite poset containing 5 elements with distinguished linear extension
sage: isinstance(P, FinitePoset)
True

sage: P.is_lattice()
False
sage: P.is_finite()
True
sage: P.cardinality()
5
sage: P.is_bounded()
False
sage: P.list()
[cusp, holo, weak, mero, quasi]

sage: len(P.relations())
11
sage: P.cover_relations()
[[cusp, holo], [holo, weak], [weak, mero]]
sage: P.has_top()
False
sage: P.has_bottom()
False

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
>>> from sage.combinat.posets.posets import FinitePoset
>>> AT = AnalyticType()
>>> P = AT.base_poset()
>>> P
Finite poset containing 5 elements with distinguished linear extension
>>> isinstance(P, FinitePoset)
True

>>> P.is_lattice()
False
>>> P.is_finite()
True
>>> P.cardinality()
5
>>> P.is_bounded()
False
>>> P.list()
[cusp, holo, weak, mero, quasi]

>>> len(P.relations())
11
>>> P.cover_relations()
[[cusp, holo], [holo, weak], [weak, mero]]
>>> P.has_top()
False
>>> P.has_bottom()
False
lattice_poset()[source]

Return the underlying lattice poset of self.

EXAMPLES:

sage: from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
sage: AnalyticType().lattice_poset()
Finite lattice containing 10 elements

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
>>> AnalyticType().lattice_poset()
Finite lattice containing 10 elements
class sage.modular.modform_hecketriangle.analytic_type.AnalyticTypeElement(poset, element, vertex)[source]

Bases: LatticePosetElement

Analytic types of forms and/or spaces.

An analytic type element describes what basic analytic properties are contained/included in it.

EXAMPLES:

sage: from sage.modular.modform_hecketriangle.analytic_type import (AnalyticType, AnalyticTypeElement)
sage: from sage.combinat.posets.elements import LatticePosetElement
sage: AT = AnalyticType()
sage: el = AT(["quasi", "cusp"])
sage: el
quasi cuspidal
sage: isinstance(el, AnalyticTypeElement)
True
sage: isinstance(el, LatticePosetElement)
True
sage: el.parent() == AT
True
sage: sorted(el.element,key=str)
[cusp, quasi]
sage: from sage.sets.set import Set_object_enumerated
sage: isinstance(el.element, Set_object_enumerated)
True
sage: first = sorted(el.element,key=str)[0]; first
cusp
sage: first.parent() == AT.base_poset()
True

sage: el2 = AT("holo")
sage: sum = el + el2
sage: sum
quasi modular
sage: sorted(sum.element,key=str)
[cusp, holo, quasi]
sage: el * el2
cuspidal

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.analytic_type import (AnalyticType, AnalyticTypeElement)
>>> from sage.combinat.posets.elements import LatticePosetElement
>>> AT = AnalyticType()
>>> el = AT(["quasi", "cusp"])
>>> el
quasi cuspidal
>>> isinstance(el, AnalyticTypeElement)
True
>>> isinstance(el, LatticePosetElement)
True
>>> el.parent() == AT
True
>>> sorted(el.element,key=str)
[cusp, quasi]
>>> from sage.sets.set import Set_object_enumerated
>>> isinstance(el.element, Set_object_enumerated)
True
>>> first = sorted(el.element,key=str)[Integer(0)]; first
cusp
>>> first.parent() == AT.base_poset()
True

>>> el2 = AT("holo")
>>> sum = el + el2
>>> sum
quasi modular
>>> sorted(sum.element,key=str)
[cusp, holo, quasi]
>>> el * el2
cuspidal
analytic_name()[source]

Return a string representation of the analytic type.

EXAMPLES:

sage: from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
sage: AT = AnalyticType()
sage: AT(["quasi", "weak"]).analytic_name()
'quasi weakly holomorphic modular'
sage: AT(["quasi", "cusp"]).analytic_name()
'quasi cuspidal'
sage: AT(["quasi"]).analytic_name()
'zero'
sage: AT([]).analytic_name()
'zero'

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
>>> AT = AnalyticType()
>>> AT(["quasi", "weak"]).analytic_name()
'quasi weakly holomorphic modular'
>>> AT(["quasi", "cusp"]).analytic_name()
'quasi cuspidal'
>>> AT(["quasi"]).analytic_name()
'zero'
>>> AT([]).analytic_name()
'zero'
analytic_space_name()[source]

Return the (analytic part of the) name of a space with the analytic type of self.

This is used for the string representation of such spaces.

EXAMPLES:

sage: from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
sage: AT = AnalyticType()
sage: AT(["quasi", "weak"]).analytic_space_name()
'QuasiWeakModular'
sage: AT(["quasi", "cusp"]).analytic_space_name()
'QuasiCusp'
sage: AT(["quasi"]).analytic_space_name()
'Zero'
sage: AT([]).analytic_space_name()
'Zero'

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
>>> AT = AnalyticType()
>>> AT(["quasi", "weak"]).analytic_space_name()
'QuasiWeakModular'
>>> AT(["quasi", "cusp"]).analytic_space_name()
'QuasiCusp'
>>> AT(["quasi"]).analytic_space_name()
'Zero'
>>> AT([]).analytic_space_name()
'Zero'
extend_by(extend_type)[source]

Return a new analytic type which contains all analytic properties specified either in self or in extend_type.

INPUT:

  • extend_type – an analytic type or something which is convertible to an analytic type

OUTPUT: the new extended analytic type

EXAMPLES:

sage: from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
sage: AT = AnalyticType()
sage: el = AT(["quasi", "cusp"])
sage: el2 = AT("holo")

sage: el.extend_by(el2)
quasi modular
sage: el.extend_by(el2) == el + el2
True

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
>>> AT = AnalyticType()
>>> el = AT(["quasi", "cusp"])
>>> el2 = AT("holo")

>>> el.extend_by(el2)
quasi modular
>>> el.extend_by(el2) == el + el2
True
latex_space_name()[source]

Return the short (analytic part of the) name of a space with the analytic type of self for usage with latex.

This is used for the latex representation of such spaces.

EXAMPLES:

sage: from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
sage: AT = AnalyticType()
sage: AT("mero").latex_space_name()
'\\tilde{M}'
sage: AT("weak").latex_space_name()
'M^!'
sage: AT(["quasi", "cusp"]).latex_space_name()
'QC'
sage: AT([]).latex_space_name()
'Z'

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
>>> AT = AnalyticType()
>>> AT("mero").latex_space_name()
'\\tilde{M}'
>>> AT("weak").latex_space_name()
'M^!'
>>> AT(["quasi", "cusp"]).latex_space_name()
'QC'
>>> AT([]).latex_space_name()
'Z'
reduce_to(reduce_type)[source]

Return a new analytic type which contains only analytic properties specified in both self and reduce_type.

INPUT:

  • reduce_type – an analytic type or something which is convertible to an analytic type

OUTPUT: the new reduced analytic type

EXAMPLES:

sage: from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
sage: AT = AnalyticType()
sage: el = AT(["quasi", "cusp"])
sage: el2 = AT("holo")

sage: el.reduce_to(el2)
cuspidal
sage: el.reduce_to(el2) == el * el2
True

>>> from sage.all import *
>>> from sage.modular.modform_hecketriangle.analytic_type import AnalyticType
>>> AT = AnalyticType()
>>> el = AT(["quasi", "cusp"])
>>> el2 = AT("holo")

>>> el.reduce_to(el2)
cuspidal
>>> el.reduce_to(el2) == el * el2
True