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)[source]

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

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

from sage.modular.modform_hecketriangle.constructor import FormsRing
FormsRing("cusp", group=5, base_ring=CC)
FormsRing("holo")
FormsRing("weak", group=6, base_ring=ZZ, red_hom=True)
FormsRing("mero", group=7, base_ring=ZZ)
FormsRing(["quasi", "cusp"], group=5, base_ring=CC)
FormsRing(["quasi", "holo"])
FormsRing(["quasi", "weak"], group=6, base_ring=ZZ, red_hom=True)
FormsRing(["quasi", "mero"], group=7, base_ring=ZZ, red_hom=True)
FormsRing(["quasi", "cusp"], group=infinity)
sage.modular.modform_hecketriangle.constructor.FormsSpace(analytic_type, group=3, base_ring=Integer Ring, k=0, ep=None)[source]

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

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

from sage.modular.modform_hecketriangle.constructor import FormsSpace
FormsSpace([])
FormsSpace(["quasi"]) # not implemented
FormsSpace("cusp", group=5, base_ring=CC, k=12, ep=1)
FormsSpace("holo")
FormsSpace("weak", group=6, base_ring=ZZ, k=0, ep=-1)
FormsSpace("mero", group=7, base_ring=ZZ, k=2, ep=-1)
FormsSpace(["quasi", "cusp"], group=5, base_ring=CC, k=12, ep=1)
FormsSpace(["quasi", "holo"])
FormsSpace(["quasi", "weak"], group=6, base_ring=ZZ, k=0, ep=-1)
FormsSpace(["quasi", "mero"], group=7, base_ring=ZZ, k=2, ep=-1)
FormsSpace(["quasi", "cusp"], group=infinity, base_ring=ZZ, k=2, ep=-1)
sage.modular.modform_hecketriangle.constructor.rational_type(f, n=3, base_ring=Integer Ring)[source]

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: 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)

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

from sage.modular.modform_hecketriangle.constructor import rational_type
rational_type(0, n=4)
rational_type(1, n=12)
# needs sage.symbolic
(x,y,z,d) = var("x,y,z,d")
rational_type(x^3 - y^2)
rational_type(x * z, n=7)
rational_type(1/(x^3 - y^2) + z/d)
rational_type(x^3/(x^3 - y^2))
rational_type(1/(x + z))
rational_type(1/x + 1/z)
rational_type(d/x, n=10)
rational_type(1.1 * z * (x^8-y^2), n=8, base_ring=CC)
rational_type(x-y^2, n=infinity)
rational_type(x*(x-y^2), n=infinity)
rational_type(1/x, n=infinity)