Constructor for spaces of modular forms for Hecke triangle groups based on a type - Modular Forms

Skip to content
Back to top
View this page
Edit this page

# Constructor for spaces of modular forms for Hecke triangle groups based on a type

AUTHORS:

- Jonas Jermann (2013): initial version

sage.modular.modform_hecketriangle.constructor.FormsRing(analytic_type, group=3, base_ring=Integer Ring, red_hom=False)

  Return the FormsRing with the given `analytic_type`, `group` `base_ring` and variable `red_hom`.

  INPUT:

  - `analytic_type` – an element of `AnalyticType()` describing the analytic type of the space

  - `group` – the index of the (Hecke triangle) group of the space (default: 3`)

  - `base_ring` – the base ring of the space (default: `ZZ`)

  - `red_hom` – the (boolean) variable `red_hom` of the space (default: `False`)

  For the variables `group`, `base_ring`, `red_hom` the same arguments as for the class `FormsRing_abstract` can be used. The variables will then be put in canonical form.

  OUTPUT: the FormsRing with the given properties

  EXAMPLES:

  Sage

      sage: from sage.modular.modform_hecketriangle.constructor import FormsRing
      sage: FormsRing("cusp", group=5, base_ring=CC)
      CuspFormsRing(n=5) over Complex Field with 53 bits of precision

      sage: FormsRing("holo")
      ModularFormsRing(n=3) over Integer Ring

      sage: FormsRing("weak", group=6, base_ring=ZZ, red_hom=True)
      WeakModularFormsRing(n=6) over Integer Ring

      sage: FormsRing("mero", group=7, base_ring=ZZ)
      MeromorphicModularFormsRing(n=7) over Integer Ring

      sage: FormsRing(["quasi", "cusp"], group=5, base_ring=CC)
      QuasiCuspFormsRing(n=5) over Complex Field with 53 bits of precision

      sage: FormsRing(["quasi", "holo"])
      QuasiModularFormsRing(n=3) over Integer Ring

      sage: FormsRing(["quasi", "weak"], group=6, base_ring=ZZ, red_hom=True)
      QuasiWeakModularFormsRing(n=6) over Integer Ring

      sage: FormsRing(["quasi", "mero"], group=7, base_ring=ZZ, red_hom=True)
      QuasiMeromorphicModularFormsRing(n=7) over Integer Ring

      sage: FormsRing(["quasi", "cusp"], group=infinity)
      QuasiCuspFormsRing(n=+Infinity) over Integer Ring

  Python

      >>> from sage.all import *
      >>> from sage.modular.modform_hecketriangle.constructor import FormsRing
      >>> FormsRing("cusp", group=Integer(5), base_ring=CC)
      CuspFormsRing(n=5) over Complex Field with 53 bits of precision

      >>> FormsRing("holo")
      ModularFormsRing(n=3) over Integer Ring

      >>> FormsRing("weak", group=Integer(6), base_ring=ZZ, red_hom=True)
      WeakModularFormsRing(n=6) over Integer Ring

      >>> FormsRing("mero", group=Integer(7), base_ring=ZZ)
      MeromorphicModularFormsRing(n=7) over Integer Ring

      >>> FormsRing(["quasi", "cusp"], group=Integer(5), base_ring=CC)
      QuasiCuspFormsRing(n=5) over Complex Field with 53 bits of precision

      >>> FormsRing(["quasi", "holo"])
      QuasiModularFormsRing(n=3) over Integer Ring

      >>> FormsRing(["quasi", "weak"], group=Integer(6), base_ring=ZZ, red_hom=True)
      QuasiWeakModularFormsRing(n=6) over Integer Ring

      >>> FormsRing(["quasi", "mero"], group=Integer(7), base_ring=ZZ, red_hom=True)
      QuasiMeromorphicModularFormsRing(n=7) over Integer Ring

      >>> FormsRing(["quasi", "cusp"], group=infinity)
      QuasiCuspFormsRing(n=+Infinity) over Integer Ring

sage.modular.modform_hecketriangle.constructor.FormsSpace(analytic_type, group=3, base_ring=Integer Ring, k=0, ep=None)

  Return the FormsSpace with the given `analytic_type`, `group` `base_ring` and degree (`k`, `ep`).

  INPUT:

  - `analytic_type` – an element of `AnalyticType()` describing the analytic type of the space

  - `group` – the index of the (Hecke triangle) group of the space (default: \(3\))

  - `base_ring` – the base ring of the space (default: `ZZ`)

  - `k` – the weight of the space, a rational number (default: `0`)

  - `ep` – the multiplier of the space, \(1\), \(-1\) or `None` (in which case `ep` should be determined from `k`). Default: `None`.

  For the variables `group`, `base_ring`, `k`, `ep` the same arguments as for the class `FormsSpace_abstract` can be used. The variables will then be put in canonical form. In particular the multiplier `ep` is calculated as usual from `k` if `ep == None`.

  OUTPUT: the FormsSpace with the given properties

  EXAMPLES:

  Sage

      sage: from sage.modular.modform_hecketriangle.constructor import FormsSpace
      sage: FormsSpace([])
      ZeroForms(n=3, k=0, ep=1) over Integer Ring
      sage: FormsSpace(["quasi"]) # not implemented

      sage: FormsSpace("cusp", group=5, base_ring=CC, k=12, ep=1)
      CuspForms(n=5, k=12, ep=1) over Complex Field with 53 bits of precision

      sage: FormsSpace("holo")
      ModularForms(n=3, k=0, ep=1) over Integer Ring

      sage: FormsSpace("weak", group=6, base_ring=ZZ, k=0, ep=-1)
      WeakModularForms(n=6, k=0, ep=-1) over Integer Ring

      sage: FormsSpace("mero", group=7, base_ring=ZZ, k=2, ep=-1)
      MeromorphicModularForms(n=7, k=2, ep=-1) over Integer Ring

      sage: FormsSpace(["quasi", "cusp"], group=5, base_ring=CC, k=12, ep=1)
      QuasiCuspForms(n=5, k=12, ep=1) over Complex Field with 53 bits of precision

      sage: FormsSpace(["quasi", "holo"])
      QuasiModularForms(n=3, k=0, ep=1) over Integer Ring

      sage: FormsSpace(["quasi", "weak"], group=6, base_ring=ZZ, k=0, ep=-1)
      QuasiWeakModularForms(n=6, k=0, ep=-1) over Integer Ring

      sage: FormsSpace(["quasi", "mero"], group=7, base_ring=ZZ, k=2, ep=-1)
      QuasiMeromorphicModularForms(n=7, k=2, ep=-1) over Integer Ring

      sage: FormsSpace(["quasi", "cusp"], group=infinity, base_ring=ZZ, k=2, ep=-1)
      QuasiCuspForms(n=+Infinity, k=2, ep=-1) over Integer Ring

  Python

      >>> from sage.all import *
      >>> from sage.modular.modform_hecketriangle.constructor import FormsSpace
      >>> FormsSpace([])
      ZeroForms(n=3, k=0, ep=1) over Integer Ring
      >>> FormsSpace(["quasi"]) # not implemented

      >>> FormsSpace("cusp", group=Integer(5), base_ring=CC, k=Integer(12), ep=Integer(1))
      CuspForms(n=5, k=12, ep=1) over Complex Field with 53 bits of precision

      >>> FormsSpace("holo")
      ModularForms(n=3, k=0, ep=1) over Integer Ring

      >>> FormsSpace("weak", group=Integer(6), base_ring=ZZ, k=Integer(0), ep=-Integer(1))
      WeakModularForms(n=6, k=0, ep=-1) over Integer Ring

      >>> FormsSpace("mero", group=Integer(7), base_ring=ZZ, k=Integer(2), ep=-Integer(1))
      MeromorphicModularForms(n=7, k=2, ep=-1) over Integer Ring

      >>> FormsSpace(["quasi", "cusp"], group=Integer(5), base_ring=CC, k=Integer(12), ep=Integer(1))
      QuasiCuspForms(n=5, k=12, ep=1) over Complex Field with 53 bits of precision

      >>> FormsSpace(["quasi", "holo"])
      QuasiModularForms(n=3, k=0, ep=1) over Integer Ring

      >>> FormsSpace(["quasi", "weak"], group=Integer(6), base_ring=ZZ, k=Integer(0), ep=-Integer(1))
      QuasiWeakModularForms(n=6, k=0, ep=-1) over Integer Ring

      >>> FormsSpace(["quasi", "mero"], group=Integer(7), base_ring=ZZ, k=Integer(2), ep=-Integer(1))
      QuasiMeromorphicModularForms(n=7, k=2, ep=-1) over Integer Ring

      >>> FormsSpace(["quasi", "cusp"], group=infinity, base_ring=ZZ, k=Integer(2), ep=-Integer(1))
      QuasiCuspForms(n=+Infinity, k=2, ep=-1) over Integer Ring

sage.modular.modform_hecketriangle.constructor.rational_type(f, n=3, base_ring=Integer Ring)

  Return the basic analytic properties that can be determined directly from the specified rational function `f` which is interpreted as a representation of an element of a FormsRing for the Hecke Triangle group with parameter `n` and the specified `base_ring`.

  In particular the following degree of the generators is assumed:

  \(deg(1) := (0, 1)\) \(deg(x) := (4/(n-2), 1)\) \(deg(y) := (2n/(n-2), -1)\) \(deg(z) := (2, -1)\)

  The meaning of homogeneous elements changes accordingly.

  INPUT:

  - `f` – a rational function in `x,y,z,d` over `base_ring`

  - `n` – integer greater or equal to \(3\) corresponding to the `HeckeTriangleGroup` with that parameter (default: \(3\))

  - `base_ring` – the base ring of the corresponding forms ring, resp. polynomial ring (default: `ZZ`)

  OUTPUT:

  A tuple `(elem, homo, k, ep, analytic_type)` describing the basic analytic properties of \(f\) (with the interpretation indicated above).

  - `elem` – `True` if \(f\) has a homogeneous denominator

  - `homo` – `True` if \(f\) also has a homogeneous numerator

  - `k` – `None` if \(f\) is not homogeneous, otherwise the weight of \(f\) (which is the first component of its degree)

  - `ep` – `None` if \(f\) is not homogeneous, otherwise the multiplier of \(f\) (which is the second component of its degree)

  - `analytic_type` – the `AnalyticType` of \(f\)

  For the zero function the degree \((0, 1)\) is chosen.

  This function is (heavily) used to determine the type of elements and to check if the element really is contained in its parent.

  EXAMPLES:

  Sage

      sage: from sage.modular.modform_hecketriangle.constructor import rational_type

      sage: rational_type(0, n=4)
      (True, True, 0, 1, zero)
      sage: rational_type(1, n=12)
      (True, True, 0, 1, modular)

      sage: # needs sage.symbolic
      sage: (x,y,z,d) = var("x,y,z,d")
      sage: rational_type(x^3 - y^2)
      (True, True, 12, 1, cuspidal)
      sage: rational_type(x * z, n=7)
      (True, True, 14/5, -1, quasi modular)
      sage: rational_type(1/(x^3 - y^2) + z/d)
      (True, False, None, None, quasi weakly holomorphic modular)
      sage: rational_type(x^3/(x^3 - y^2))
      (True, True, 0, 1, weakly holomorphic modular)
      sage: rational_type(1/(x + z))
      (False, False, None, None, None)
      sage: rational_type(1/x + 1/z)
      (True, False, None, None, quasi meromorphic modular)
      sage: rational_type(d/x, n=10)
      (True, True, -1/2, 1, meromorphic modular)
      sage: rational_type(1.1 * z * (x^8-y^2), n=8, base_ring=CC)
      (True, True, 22/3, -1, quasi cuspidal)
      sage: rational_type(x-y^2, n=infinity)
      (True, True, 4, 1, modular)
      sage: rational_type(x*(x-y^2), n=infinity)
      (True, True, 8, 1, cuspidal)
      sage: rational_type(1/x, n=infinity)
      (True, True, -4, 1, weakly holomorphic modular)

  Python

      >>> from sage.all import *
      >>> from sage.modular.modform_hecketriangle.constructor import rational_type

      >>> rational_type(Integer(0), n=Integer(4))
      (True, True, 0, 1, zero)
      >>> rational_type(Integer(1), n=Integer(12))
      (True, True, 0, 1, modular)

      >>> # needs sage.symbolic
      >>> (x,y,z,d) = var("x,y,z,d")
      >>> rational_type(x**Integer(3) - y**Integer(2))
      (True, True, 12, 1, cuspidal)
      >>> rational_type(x * z, n=Integer(7))
      (True, True, 14/5, -1, quasi modular)
      >>> rational_type(Integer(1)/(x**Integer(3) - y**Integer(2)) + z/d)
      (True, False, None, None, quasi weakly holomorphic modular)
      >>> rational_type(x**Integer(3)/(x**Integer(3) - y**Integer(2)))
      (True, True, 0, 1, weakly holomorphic modular)
      >>> rational_type(Integer(1)/(x + z))
      (False, False, None, None, None)
      >>> rational_type(Integer(1)/x + Integer(1)/z)
      (True, False, None, None, quasi meromorphic modular)
      >>> rational_type(d/x, n=Integer(10))
      (True, True, -1/2, 1, meromorphic modular)
      >>> rational_type(RealNumber('1.1') * z * (x**Integer(8)-y**Integer(2)), n=Integer(8), base_ring=CC)
      (True, True, 22/3, -1, quasi cuspidal)
      >>> rational_type(x-y**Integer(2), n=infinity)
      (True, True, 4, 1, modular)
      >>> rational_type(x*(x-y**Integer(2)), n=infinity)
      (True, True, 8, 1, cuspidal)
      >>> rational_type(Integer(1)/x, n=infinity)
      (True, True, -4, 1, weakly holomorphic modular)