### Navigation

- index
- modules |
- previous |
- Modular Forms »

# Graded Rings of Modular Forms

This module contains functions to find generators for the graded ring of modular forms of given level.

AUTHORS:

- William Stein (2007-08-24): first version

class `sage.modular.modform.find_generators.``ModularFormsRing`(group, base_ring=Rational Field)

  Bases: `sage.structure.sage_object.SageObject`

  The ring of modular forms (of weights 0 or at least 2) for a congruence subgroup of \({\rm SL}_2(\ZZ)\), with coefficients in a specified base ring.

  INPUT:

  - `group` – a congruence subgroup of \({\rm SL}_2(\ZZ)\), or a positive integer \(N\) (interpreted as \(\Gamma_0(N)\))
  - `base_ring` (ring, default: \(\QQ\)) – a base ring, which should be \(\QQ\), \(\ZZ\), or the integers mod \(p\) for some prime \(p\).

  EXAMPLES:

      sage: ModularFormsRing(Gamma1(13))
      Ring of modular forms for Congruence Subgroup Gamma1(13) with coefficients in Rational Field
      sage: m = ModularFormsRing(4); m
      Ring of modular forms for Congruence Subgroup Gamma0(4) with coefficients in Rational Field
      sage: m.modular_forms_of_weight(2)
      Modular Forms space of dimension 2 for Congruence Subgroup Gamma0(4) of weight 2 over Rational Field
      sage: m.modular_forms_of_weight(10)
      Modular Forms space of dimension 6 for Congruence Subgroup Gamma0(4) of weight 10 over Rational Field
      sage: m == loads(dumps(m))
      True
      sage: m.generators()
      [(2, 1 + 24*q^2 + 24*q^4 + 96*q^6 + 24*q^8 + O(q^10)),
      (2, q + 4*q^3 + 6*q^5 + 8*q^7 + 13*q^9 + O(q^10))]
      sage: m.q_expansion_basis(2,10)
      [1 + 24*q^2 + 24*q^4 + 96*q^6 + 24*q^8 + O(q^10),
       q + 4*q^3 + 6*q^5 + 8*q^7 + 13*q^9 + O(q^10)]
      sage: m.q_expansion_basis(3,10)
      []
      sage: m.q_expansion_basis(10,10)
      [1 + 10560*q^6 + 3960*q^8 + O(q^10),
       q - 8056*q^7 - 30855*q^9 + O(q^10),
       q^2 - 796*q^6 - 8192*q^8 + O(q^10),
       q^3 + 66*q^7 + 832*q^9 + O(q^10),
       q^4 + 40*q^6 + 528*q^8 + O(q^10),
       q^5 + 20*q^7 + 190*q^9 + O(q^10)]

  TESTS:

  Check that trac ticket #15037 is fixed:

      sage: ModularFormsRing(3.4)
      Traceback (most recent call last):
      ...
      ValueError: Group (=3.40000000000000) should be a congruence subgroup
      sage: ModularFormsRing(Gamma0(2), base_ring=PolynomialRing(ZZ,x))
      Traceback (most recent call last):
      ...
      ValueError: Base ring (=Univariate Polynomial Ring in x over Integer Ring) should be QQ, ZZ or a finite prime field

  `base_ring`()

    Return the coefficient ring of this modular forms ring.

    EXAMPLE:

        sage: ModularFormsRing(Gamma1(13)).base_ring()
        Rational Field
        sage: ModularFormsRing(Gamma1(13), base_ring = ZZ).base_ring()
        Integer Ring

  `cuspidal_ideal_generators`(maxweight=8, prec=None)

    Calculate generators for the ideal of cuspidal forms in this ring, as a module over the whole ring.

    EXAMPLE:

        sage: ModularFormsRing(Gamma0(3)).cuspidal_ideal_generators(maxweight=12)
        [(6, q - 6*q^2 + 9*q^3 + 4*q^4 + O(q^5), q - 6*q^2 + 9*q^3 + 4*q^4 + 6*q^5 + O(q^6))]
        sage: [k for k,f,F in ModularFormsRing(13, base_ring=ZZ).cuspidal_ideal_generators(maxweight=14)]
        [4, 4, 4, 6, 6, 12]

  `cuspidal_submodule_q_expansion_basis`(weight, prec=None)

    Calculate a basis of \(q\)-expansions for the space of cusp forms of weight `weight` for this group.

    INPUT:

    - `weight` (integer) – the weight
    - `prec` (integer or None) – precision of \(q\)-expansions to return

    ALGORITHM: Uses the method `cuspidal_ideal_generators()` to calculate generators of the ideal of cusp forms inside this ring. Then multiply these up to weight `weight` using the generators of the whole modular form space returned by `q_expansion_basis()`.

    EXAMPLES:

        sage: R = ModularFormsRing(Gamma0(3))
        sage: R.cuspidal_submodule_q_expansion_basis(20)
        [q - 8532*q^6 - 88442*q^7 + O(q^8), q^2 + 207*q^6 + 24516*q^7 + O(q^8), q^3 + 456*q^6 + O(q^8), q^4 - 135*q^6 - 926*q^7 + O(q^8), q^5 + 18*q^6 + 135*q^7 + O(q^8)]

    We compute a basis of a space of very large weight, quickly (using this module) and slowly (using modular symbols), and verify that the answers are the same.

        sage: A = R.cuspidal_submodule_q_expansion_basis(80, prec=30)  # long time (1s on sage.math, 2013)
        sage: B = R.modular_forms_of_weight(80).cuspidal_submodule().q_expansion_basis(prec=30)  # long time (19s on sage.math, 2013)
        sage: A == B # long time
        True

  `gen_forms`(maxweight=8, start_gens=[], start_weight=2)

    This function calculates a list of modular forms generating this ring (as an algebra over the appropriate base ring). It differs from `generators()` only in that it returns Sage modular form objects, rather than bare \(q\)-expansions; and if the base ring is a finite field, the modular forms returned will be forms in characteristic 0 with integral \(q\)-expansions whose reductions modulo \(p\) generate the ring of modular forms mod \(p\).

    INPUT:

    - `maxweight` (integer, default: 8) – calculate forms generating all forms up to this weight.
    - `start_gens` (list, default: `[]`) – a list of modular forms. If this list is nonempty, we find a minimal generating set containing these forms.
    - `start_weight` (integer, default: 2) – calculate the graded subalgebra of forms of weight at least `start_weight`.

    Note

    If called with the default values of `start_gens` (an empty list) and `start_weight` (2), the values will be cached for re-use on subsequent calls to this function. (This cache is shared with `generators()`). If called with non-default values for these parameters, caching will be disabled.

    EXAMPLE:

        sage: A = ModularFormsRing(Gamma0(11), Zmod(5)).gen_forms(); A
        [1 + 12*q^2 + 12*q^3 + 12*q^4 + 12*q^5 + O(q^6), q - 2*q^2 - q^3 + 2*q^4 + q^5 + O(q^6), q - 9*q^4 - 10*q^5 + O(q^6)]
        sage: A[0].parent()
        Modular Forms space of dimension 2 for Congruence Subgroup Gamma0(11) of weight 2 over Rational Field

  `generators`(maxweight=8, prec=10, start_gens=[], start_weight=2)

    If \(R\) is the base ring of self, then this function calculates a set of modular forms which generate the \(R\)-algebra of all modular forms of weight up to `maxweight` with coefficients in \(R\).

    INPUT:

    - `maxweight` (integer, default: 8) – check up to this weight for generators

    - `prec` (integer, default: 10) – return \(q\)-expansions to this precision

    - `start_gens` (list, default: `[]`) – list of pairs \((k, f)\), or triples \((k, f, F)\), where:

      - \(k\) is an integer,
      - \(f\) is the \(q\)-expansion of a modular form of weight \(k\), as a power series over the base ring of self,
      - \(F\) (if provided) is a modular form object corresponding to F.

      If this list is nonempty, we find a minimal generating set containing these forms. If \(F\) is not supplied, then \(f\) needs to have sufficiently large precision (an error will be raised if this is not the case); otherwise, more terms will be calculated from the modular form object \(F\).

    - `start_weight` (integer, default: 2) – calculate the graded subalgebra of forms of weight at least `start_weight`.

    OUTPUT:

    a list of pairs (k, f), where f is the q-expansion to precision `prec` of a modular form of weight k.

    See also

    `gen_forms()`, which does exactly the same thing, but returns Sage modular form objects rather than bare power series, and keeps track of a lifting to characteristic 0 when the base ring is a finite field.

    Note

    If called with the default values of `start_gens` (an empty list) and `start_weight` (2), the values will be cached for re-use on subsequent calls to this function. (This cache is shared with `gen_forms()`). If called with non-default values for these parameters, caching will be disabled.

    EXAMPLES:

        sage: ModularFormsRing(SL2Z).generators()
        [(4, 1 + 240*q + 2160*q^2 + 6720*q^3 + 17520*q^4 + 30240*q^5 + 60480*q^6 + 82560*q^7 + 140400*q^8 + 181680*q^9 + O(q^10)), (6, 1 - 504*q - 16632*q^2 - 122976*q^3 - 532728*q^4 - 1575504*q^5 - 4058208*q^6 - 8471232*q^7 - 17047800*q^8 - 29883672*q^9 + O(q^10))]
        sage: s = ModularFormsRing(SL2Z).generators(maxweight=5, prec=3); s
        [(4, 1 + 240*q + 2160*q^2 + O(q^3))]
        sage: s[0][1].parent()
        Power Series Ring in q over Rational Field

        sage: ModularFormsRing(1).generators(prec=4)
        [(4, 1 + 240*q + 2160*q^2 + 6720*q^3 + O(q^4)), (6, 1 - 504*q - 16632*q^2 - 122976*q^3 + O(q^4))]
        sage: ModularFormsRing(2).generators(prec=12)
        [(2, 1 + 24*q + 24*q^2 + 96*q^3 + 24*q^4 + 144*q^5 + 96*q^6 + 192*q^7 + 24*q^8 + 312*q^9 + 144*q^10 + 288*q^11 + O(q^12)), (4, 1 + 240*q^2 + 2160*q^4 + 6720*q^6 + 17520*q^8 + 30240*q^10 + O(q^12))]
        sage: ModularFormsRing(4).generators(maxweight=2, prec=20)
        [(2, 1 + 24*q^2 + 24*q^4 + 96*q^6 + 24*q^8 + 144*q^10 + 96*q^12 + 192*q^14 + 24*q^16 + 312*q^18 + O(q^20)), (2, q + 4*q^3 + 6*q^5 + 8*q^7 + 13*q^9 + 12*q^11 + 14*q^13 + 24*q^15 + 18*q^17 + 20*q^19 + O(q^20))]

    Here we see that for `\Gamma_0(11)` taking a basis of forms in weights 2 and 4 is enough to generate everything up to weight 12 (and probably everything else).:

        sage: v = ModularFormsRing(11).generators(maxweight=12)
        sage: len(v)
        3
        sage: [k for k, _ in v]
        [2, 2, 4]
        sage: dimension_modular_forms(11,2)
        2
        sage: dimension_modular_forms(11,4)
        4

    For congruence subgroups not containing -1, we miss out some forms since we can’t calculate weight 1 forms at present, but we can still find generators for the ring of forms of weight \(\ge 2\):

        sage: ModularFormsRing(Gamma1(4)).generators(prec=10, maxweight=10)
        [(2, 1 + 24*q^2 + 24*q^4 + 96*q^6 + 24*q^8 + O(q^10)),
        (2, q + 4*q^3 + 6*q^5 + 8*q^7 + 13*q^9 + O(q^10)),
        (3, 1 + 12*q^2 + 64*q^3 + 60*q^4 + 160*q^6 + 384*q^7 + 252*q^8 + O(q^10)),
        (3, q + 4*q^2 + 8*q^3 + 16*q^4 + 26*q^5 + 32*q^6 + 48*q^7 + 64*q^8 + 73*q^9 + O(q^10))]

    Using different base rings will change the generators:

        sage: ModularFormsRing(Gamma0(13)).generators(maxweight=12, prec=4)
        [(2, 1 + 2*q + 6*q^2 + 8*q^3 + O(q^4)), (4, 1 + O(q^4)), (4, q + O(q^4)), (4, q^2 + O(q^4)), (4, q^3 + O(q^4)), (6, 1 + O(q^4)), (6, q + O(q^4))]
        sage: ModularFormsRing(Gamma0(13),base_ring=ZZ).generators(maxweight=12, prec=4)
        [(2, 1 + 2*q + 6*q^2 + 8*q^3 + O(q^4)), (4, O(q^4)), (4, q^3 + O(q^4)), (4, q^2 + O(q^4)), (4, q + O(q^4)), (6, O(q^4)), (6, O(q^4)), (12, O(q^4))]

        sage: [k for k,f in ModularFormsRing(1, QQ).generators(maxweight=12)]
        [4, 6]
        sage: [k for k,f in ModularFormsRing(1, ZZ).generators(maxweight=12)]
        [4, 6, 12]
        sage: [k for k,f in ModularFormsRing(1, Zmod(5)).generators(maxweight=12)]
        [4, 6]
        sage: [k for k,f in ModularFormsRing(1, Zmod(2)).generators(maxweight=12)]
        [4, 6, 12]

    An example where `start_gens` are specified:

        sage: M = ModularForms(11, 2); f = (M.0 + M.1).qexp(8)
        sage: ModularFormsRing(11).generators(start_gens = [(2, f)])
        Traceback (most recent call last):
        ...
        ValueError: Requested precision cannot be higher than precision of approximate starting generators!
        sage: f = (M.0 + M.1).qexp(10); f
        1 + 17/5*q + 26/5*q^2 + 43/5*q^3 + 94/5*q^4 + 77/5*q^5 + 154/5*q^6 + 86/5*q^7 + 36*q^8 + 146/5*q^9 + O(q^10)
        sage: ModularFormsRing(11).generators(start_gens = [(2, f)])
        [(2, 1 + 17/5*q + 26/5*q^2 + 43/5*q^3 + 94/5*q^4 + 77/5*q^5 + 154/5*q^6 + 86/5*q^7 + 36*q^8 + 146/5*q^9 + O(q^10)), (2, 1 + 12*q^2 + 12*q^3 + 12*q^4 + 12*q^5 + 24*q^6 + 24*q^7 + 36*q^8 + 36*q^9 + O(q^10)), (4, 1 + O(q^10))]

  `group`()

    Return the congruence subgroup for which this is the ring of modular forms.

    EXAMPLE:

        sage: R = ModularFormsRing(Gamma1(13))
        sage: R.group() is Gamma1(13)
        True

  `modular_forms_of_weight`(weight)

    Return the space of modular forms on this group of the given weight.

    EXAMPLES:

        sage: R = ModularFormsRing(13)
        sage: R.modular_forms_of_weight(10)
        Modular Forms space of dimension 11 for Congruence Subgroup Gamma0(13) of weight 10 over Rational Field
        sage: ModularFormsRing(Gamma1(13)).modular_forms_of_weight(3)
        Modular Forms space of dimension 20 for Congruence Subgroup Gamma1(13) of weight 3 over Rational Field

  `q_expansion_basis`(weight, prec=None, use_random=True)

    Calculate a basis of q-expansions for the space of modular forms of the given weight for this group, calculated using the ring generators given by `find_generators`.

    INPUT:

    - `weight` (integer) – the weight
    - `prec` (integer or `None`, default: `None`) – power series precision. If `None`, the precision defaults to the Sturm bound for the requested level and weight.
    - `use_random` (boolean, default: True) – whether or not to use a randomized algorithm when building up the space of forms at the given weight from known generators of small weight.

    EXAMPLES:

        sage: m = ModularFormsRing(Gamma0(4))
        sage: m.q_expansion_basis(2,10)
        [1 + 24*q^2 + 24*q^4 + 96*q^6 + 24*q^8 + O(q^10),
        q + 4*q^3 + 6*q^5 + 8*q^7 + 13*q^9 + O(q^10)]
        sage: m.q_expansion_basis(3,10)
        []

        sage: X = ModularFormsRing(SL2Z)
        sage: X.q_expansion_basis(12, 10)
        [1 + 196560*q^2 + 16773120*q^3 + 398034000*q^4 + 4629381120*q^5 + 34417656000*q^6 + 187489935360*q^7 + 814879774800*q^8 + 2975551488000*q^9 + O(q^10),
        q - 24*q^2 + 252*q^3 - 1472*q^4 + 4830*q^5 - 6048*q^6 - 16744*q^7 + 84480*q^8 - 113643*q^9 + O(q^10)]

    We calculate a basis of a massive modular forms space, in two ways. Using this module is about twice as fast as Sage’s generic code.

        sage: A = ModularFormsRing(11).q_expansion_basis(30, prec=40) # long time (5s)
        sage: B = ModularForms(Gamma0(11), 30).q_echelon_basis(prec=40) # long time (9s)
        sage: A == B # long time
        True

    Check that absurdly small values of `prec` don’t mess things up:

        sage: ModularFormsRing(11).q_expansion_basis(10, prec=5)
        [1 + O(q^5), q + O(q^5), q^2 + O(q^5), q^3 + O(q^5), q^4 + O(q^5), O(q^5), O(q^5), O(q^5), O(q^5), O(q^5)]

`sage.modular.modform.find_generators.``basis_for_modform_space`(*args)

  This function, which existed in earlier versions of Sage, has now been replaced by the `q_expansion_basis()` method of ModularFormsRing objects.

  EXAMPLE:

      sage: from sage.modular.modform.find_generators import basis_for_modform_space
      sage: basis_for_modform_space()
      Traceback (most recent call last):
      ...
      NotImplementedError: basis_for_modform_space has been removed -- use ModularFormsRing.q_expansion_basis()

`sage.modular.modform.find_generators.``find_generators`(*args)

  This function, which existed in earlier versions of Sage, has now been replaced by the `generators()` method of ModularFormsRing objects.

  EXAMPLE:

      sage: from sage.modular.modform.find_generators import find_generators
      sage: find_generators()
      Traceback (most recent call last):
      ...
      NotImplementedError: find_generators has been removed -- use ModularFormsRing.generators()

### Navigation

- index
- modules |
- previous |
- Modular Forms »