### Navigation

- index
- modules |
- next |
- previous |
- Modular Forms for Hecke Triangle Groups »

# Analytic types of modular forms.

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

AUTHORS:

- Jonas Jermann (2013): initial version

class `sage.modular.modform_hecketriangle.analytic_type.``AnalyticType`

  Bases: `sage.combinat.posets.lattices.FiniteLatticePoset`

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

  The `analytic type` of forms spaces or rings describes all possible occuring 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.

  EXAMPLES:

  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.

      sage: from sage.modular.modform_hecketriangle.space import QuasiModularForms
      sage: x,y,z,d = var("x,y,z,d")
      sage: el = QuasiModularForms(n=3, k=6, ep=-1)(y-z^3)
      sage: el.analytic_type()
      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”) sage: el2 = WeakModularFormsRing(n=3)(x/(x^3-y^2)-y/(x^3-y^2)) sage: el2.analytic_type() weakly holomorphic modular

  `Element`

    alias of `AnalyticTypeElement`

  `base_poset`()

    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

  `lattice_poset`()

    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

class `sage.modular.modform_hecketriangle.analytic_type.``AnalyticTypeElement`(poset, element, vertex)

  Bases: `sage.combinat.posets.elements.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: el.element
      {cusp, quasi}
      sage: from sage.sets.set import Set_object_enumerated
      sage: isinstance(el.element, Set_object_enumerated)
      True
      sage: el.element[0]
      cusp
      sage: el.element[0].parent() == AT.base_poset()
      True

      sage: el2 = AT("holo")
      sage: sum = el + el2
      sage: sum
      quasi modular
      sage: sum.element
      {holo, cusp, quasi}
      sage: el * el2
      cuspidal

  `analytic_name`()

    Return a string representation of the analytic type.

    > 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’

  `analytic_space_name`()

    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’
  `extend_by`(extend_type)

    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

        convertable 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

  `latex_space_name`()

    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'

  `reduce_to`(reduce_type)

    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

        convertable 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

### Navigation

- index
- modules |
- next |
- previous |
- Modular Forms for Hecke Triangle Groups »