Coverage for local/lib/python2.7/site-packages/sage/modular/modform_hecketriangle/constructor.py : 93%
Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
|
r""" Constructor for spaces of modular forms for Hecke triangle groups based on a type
AUTHORS:
- Jonas Jermann (2013): initial version
"""
#***************************************************************************** # Copyright (C) 2013-2014 Jonas Jermann <jjermann2@gmail.com> # # Distributed under the terms of the GNU General Public License (GPL) # as published by the Free Software Foundation; either version 2 of # the License, or (at your option) any later version. # http://www.gnu.org/licenses/ #*****************************************************************************
r""" 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`` -- An 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 choosen.
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: (x,y,z,d) = var("x,y,z,d")
sage: rational_type(0, n=4) (True, True, 0, 1, zero)
sage: rational_type(1, n=12) (True, True, 0, 1, modular)
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) """
# Determine whether f is zero # elem, homo, k, ep, analytic_type
else:
# Determine whether the denominator of f is homogeneous else: # elem, homo, k, ep, analytic_type
# Determine whether f is homogeneous else: # TODO: decompose f (resp. its degrees) into homogeneous parts else:
# Note that we intentionally leave out the d-factor! else:
# Determine whether f is modular
# Determine whether f is holomorphic # Determine whether f is cuspidal in the sense that finf divides it... # Bug in singular: finf_pol.dividess(1.0) fails over RR else: # -> Because of a bug with singular in some cases # a simple "denom /= finf_pol" is strangely not enough for non-exact rings # and dividing would/may result with an element of the quotient ring of the polynomial ring # a simple "denom /= x" is strangely not enough for non-exact rings # and dividing would/may result with an element of the quotient ring of the polynomial ring except TypeError: pass
# Determine whether f is weakly holomorphic in the sense that at most powers of finf occur in denom
r""" 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 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 """
else: else: else: else: raise ValueError("There should be only non-quasi ZeroForms. That could be changed but then this exception should be removed.") from .space import ZeroForm return ZeroForm(group=group, base_ring=base_ring, k=k, ep=ep) else: else: else: else: else: raise NotImplementedError("Analytic type not implemented.")
r""" 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 """
raise ValueError("Analytic type Zero is not valid for forms rings.") else: else: else: else: raise ValueError("Analytic type Zero is not valid for forms rings.") else: else: else: else: else: raise NotImplementedError("Analytic type not implemented.") |