### Navigation

- index
- modules |
- next |
- previous |
- Modular Symbols »

# Manin symbols

This module defines the class ManinSymbol. A Manin Symbol of weight \(k\), level \(N\) has the form \([P(X,Y),(u:v)]\) where \(P(X,Y)\in\mathbb{Z}[X,Y]\) is homogeneous of weight \(k-2\) and \((u:v)\in\mathbb{P}^1(\mathbb{Z}/N\mathbb{Z}).\) The ManinSymbol class holds a “monomial Manin Symbol” of the simpler form \([X^iY^{k-2-i},(u:v)]\), which is stored as a triple \((i,u,v)\); the weight and level are obtained from the parent structure, which is a ManinSymbolList.

Integer matrices \([a,b;c,d]\) act on Manin Symbols on the right, sending \([P(X,Y),(u,v)]\) to \([P(aX+bY,cX+dY),(u,v)g]\). Diagonal matrices (with \(b=c=0\), such as \(I=[-1,0;0,1]\) and \(J=[-1,0;0,-1]\)) and anti-diagonal matrices (with \(a=d=0\), such as \(S=[0,-1;1,0]\)) map monomial Manin Symbols to monomial Manin Symbols, up to a scalar factor. For general matrices (such as \(T=[0,1,-1,-1]\) and \(T^2=[-1,-1;0,1]\)) the image of a monomial Manin Symbol is expressed as a formal sum of monomial Manin Symbols, with integer coefficients.

There are various different classes holding lists of Manin symbols of different types. The hierarchy is as follows:

    class ManinSymbolList(SageObject)

    class ManinSymbolList_group(ManinSymbolList)
        class ManinSymbolList_gamma0(ManinSymbolList_group)
        class ManinSymbolList_gamma1(ManinSymbolList_group)
        class ManinSymbolList_gamma_h(ManinSymbolList_group)

    class ManinSymbolList_character(ManinSymbolList)

class `sage.modular.modsym.manin_symbols.``ManinSymbol`(parent, t)

  Bases: `sage.structure.sage_object.SageObject`

  A Manin symbol \([X^i\cdot Y^{k-2-i},(u,v)]\).

  INPUT:

  - `parent` - ManinSymbolList.
  - `t` - a 3-tuple \((i,u,v)\) of integers.

  EXAMPLES:

      sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
      sage: m = ManinSymbolList_gamma0(5,2)
      sage: s = ManinSymbol(m,(2,2,3)); s
      (2,3)
      sage: s == loads(dumps(s))
      True

      ::

      sage: m = ManinSymbolList_gamma0(5,8)
      sage: s = ManinSymbol(m,(2,2,3)); s
      [X^2*Y^4,(2,3)]

  `apply`(a, b, c, d)

    Return the image of self under the matrix \([a,b;c,d]\).

    Not implemented for raw ManinSymbol objects, only for members of ManinSymbolLists.

    EXAMPLE:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,2)
        sage: m.apply(10,[1,0,0,1]) # not implemented for base class

  `endpoints`(N=None)

    Returns cusps \(alpha\), \(beta\) such that this Manin symbol, viewed as a symbol for level \(N\), is \(X^i*Y^{k-2-i} \{alpha, beta\}\).

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3)); s
        [X^2*Y^4,(2,3)]
        sage: s.endpoints()
        (1/3, 1/2)

  `i`

    Return the \(i\) field of this ManinSymbol \((i,u,v)\).

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3))
        sage: s._ManinSymbol__get_i()
        2
        sage: s.i
        2

  `level`()

    Return the level of this ManinSymbol.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3))
        sage: s.level()
        5

  `lift_to_sl2z`(N=None)

    Returns a lift of this Manin Symbol to \(SL_2(\mathbb{Z})\).

    If this Manin symbol is \((c,d)\) and \(N\) is its level, this function returns a list \([a,b, c',d']\) that defines a 2x2 matrix with determinant 1 and integer entries, such that \(c=c'\) (mod \(N\)) and \(d=d'\) (mod \(N\)).

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3))
        sage: s
        [X^2*Y^4,(2,3)]
        sage: s.lift_to_sl2z()
        [1, 1, 2, 3]

  `modular_symbol_rep`()

    Returns a representation of self as a formal sum of modular symbols.

    The result is not cached.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3))
        sage: s.modular_symbol_rep()
         144*X^6*{1/3, 1/2} - 384*X^5*Y*{1/3, 1/2} + 424*X^4*Y^2*{1/3, 1/2} - 248*X^3*Y^3*{1/3, 1/2} + 81*X^2*Y^4*{1/3, 1/2} - 14*X*Y^5*{1/3, 1/2} + Y^6*{1/3, 1/2}

  `parent`()

    Return the parent of this ManinSymbol.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3))
        sage: s.parent()
        Manin Symbol List of weight 8 for Gamma0(5)

  `tuple`()

    Return the 3-tuple \((i,u,v)\) of this ManinSymbol.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3))
        sage: s.tuple()
        (2, 2, 3)

  `u`

    Return the \(u\) field of this ManinSymbol \((i,u,v)\).

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3))
        sage: s.u # indirect doctest
        2

  `v`

    Return the \(v\) field of this ManinSymbol \((i,u,v)\).

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3))
        sage: s.v # indirect doctest
        3

  `weight`()

    Return the weight of this ManinSymbol.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: s = ManinSymbol(m,(2,2,3))
        sage: s.weight()
        8

class `sage.modular.modsym.manin_symbols.``ManinSymbolList`(weight, list)

  Bases: `sage.structure.sage_object.SageObject`

  Base class for lists of all Manin symbols for a given weight, group or character.

  `apply`(j, X)

    Apply the matrix \(X=[a,b;c,d]\) to the \(j\)-th Manin symbol.

    Implemented in derived classes.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
        sage: m = ManinSymbolList(6,P1List(11))
        sage: m.apply(10, [1,2,0,1])
        Traceback (most recent call last):
        ...
        NotImplementedError: Only implemented in derived classes

  `apply_I`(j)

    Apply the matrix \(I=[-1,0;0,1]\) to the \(j\)-th Manin symbol.

    Implemented in derived classes.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
        sage: m = ManinSymbolList(6,P1List(11))
        sage: m.apply_I(10)
        Traceback (most recent call last):
        ...
        NotImplementedError: Only implemented in derived classes

  `apply_S`(j)

    Apply the matrix \(S=[0,-1;1,0]\) to the \(j\)-th Manin symbol.

    Implemented in derived classes.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
        sage: m = ManinSymbolList(6,P1List(11))
        sage: m.apply_S(10)
        Traceback (most recent call last):
        ...
        NotImplementedError: Only implemented in derived classes

  `apply_T`(j)

    Apply the matrix \(T=[0,1;-1,-1]\) to the \(j\)-th Manin symbol.

    Implemented in derived classes.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
        sage: m = ManinSymbolList(6,P1List(11))
        sage: m.apply_T(10)
        Traceback (most recent call last):
        ...
        NotImplementedError: Only implemented in derived classes

  `apply_TT`(j)

    Apply the matrix \(TT=T^2=[-1,-1;0,1]\) to the \(j\)-th Manin symbol.

    Implemented in derived classes.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
        sage: m = ManinSymbolList(6,P1List(11))
        sage: m.apply_TT(10)
        Traceback (most recent call last):
        ...
        NotImplementedError: Only implemented in derived classes

  `index`(x)

    Return the index of `x` in the list of Manin symbols, where `x` is a 3-tuple of ints. If `x` is not in the list, then return -1.

    INPUT:

    - `x` - 3-tuple of integers, \((i,u,v)\) defining a valid Manin symbol, which need not be normalized.

    OUTPUT:

    (`int`) the index of the normalized Manin symbol equivalent to \((i,u,v)\).

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
        sage: m = ManinSymbolList(6,P1List(11))
        sage: m.index(m[2])
        2
        sage: all([i == m.index(m[i]) for i in xrange(len(m))])
        True

  `manin_symbol`(i)

    Returns the i’th ManinSymbol in this ManinSymbolList.

    INPUT:

    - `i` - integer, a valid index of a symbol in this list.

    OUTPUT:

    `ManinSymbol` - the \(i\)‘th Manin symbol in the list.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
        sage: m = ManinSymbolList(6,P1List(11))
        sage: m.manin_symbol(3) # not implemented for base class

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(6, 4)
        sage: s = m.manin_symbol(3); s
        [Y^2,(1,2)]
        sage: type(s)
        <class 'sage.modular.modsym.manin_symbols.ManinSymbol'>

  `manin_symbol_list`()

    Returns all the ManinSymbols in this ManinSymbolList as a list

    Cached for subsequent calls.

    OUTPUT:

    a list of `ManinSymbol` objects, which is a copy of the complete list of Manin symbols.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
        sage: m = ManinSymbolList(6,P1List(11))
        sage: m.manin_symbol_list() # not implemented for the base class

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(6, 4)
        sage: m.manin_symbol_list()
        [[Y^2,(0,1)],
        [Y^2,(1,0)],
        [Y^2,(1,1)],
        ...
        [X^2,(3,1)],
        [X^2,(3,2)]]

  `normalize`(x)

    Returns a normalized ManinSymbol from x.

    To be implemented in derived classes.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList
        sage: m = ManinSymbolList(6,P1List(11))
        sage: m.normalize((0,6,7)) # not implemented in base class

  `weight`()

    Returns the weight of the ManinSymbols in this ManinSymbolList.

    OUTPUT:

    `integer` - the weight of the Manin symbols in the list.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(6, 4)
        sage: m.weight()
        4

class `sage.modular.modsym.manin_symbols.``ManinSymbolList_character`(character, weight)

  Bases: `sage.modular.modsym.manin_symbols.ManinSymbolList`

  List of Manin Symbols with character.

  INPUT:

  - `character` - (DirichletCharacter) the Dirichlet character.
  - `weight` - (integer) the weight.

  EXAMPLE:

      sage: eps = DirichletGroup(4).gen(0)
      sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
      sage: m = ManinSymbolList_character(eps,2); m
      Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
      sage: m.manin_symbol_list()
      [(0,1), (1,0), (1,1), (1,2), (1,3), (2,1)]
      sage: m == loads(dumps(m))
      True

  `apply`(j, m)

    Apply the integer matrix \(m=[a,b;c,d]\) to the \(j\)-th Manin symbol.

    INPUT:

    - `j` (integer): the index of the symbol to act on.
    - `m` (list of ints): \([a,b,c,d]\) where \(m = [a, b; c, d]\) is the matrix to be applied.

    OUTPUT:

    A list of pairs \((j, c_i)\), where each \(c_i\) is an integer, \(j\) is an integer (the \(j\)-th Manin symbol), and the sum \(c_i*x_i\) is the image of self under the right action of the matrix \([a,b;c,d]\). Here the right action of \(g=[a,b;c,d]\) on a Manin symbol \([P(X,Y),(u,v)]\) is by definition \([P(aX+bY,cX+dY),(u,v)*g]\).

    EXAMPLES:

        sage: eps = DirichletGroup(4).gen(0)
        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
        sage: m = ManinSymbolList_character(eps,4)
        sage: m[6]
        (1, 0, 1)
        sage: m.apply(4, [1,0,0,1])
        [(4, 1)]
        sage: m.apply(1, [-1,0,0,1])
        [(1, -1)]

  `apply_I`(j)

    Apply the matrix \(I=[-1,0,0,1]\) to the \(j\)-th Manin symbol.

    INPUT:

    - `j` - (integer) a symbol index

    OUTPUT:

    `(k, s)` where \(k\) is the index of the symbol obtained by acting on the \(j\)‘th symbol with \(I\), and \(s\) is the parity of of the \(j\)‘th symbol.

    EXAMPLE:

        sage: eps = DirichletGroup(4).gen(0)
        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
        sage: m = ManinSymbolList_character(eps,2); m
        Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
        sage: m.apply_I(4)
        (2, -1)
        sage: [m.apply_I(i) for i in xrange(len(m))]
        [(0, 1), (1, -1), (4, -1), (3, -1), (2, -1), (5, 1)]

  `apply_S`(j)

    Apply the matrix \(S=[0,1;-1,0]\) to the \(j\)-th Manin symbol.

    INPUT:

    - `j` - (integer) a symbol index.

    OUTPUT:

    `(k, s)` where \(k\) is the index of the symbol obtained by acting on the \(j\)‘th symbol with \(S\), and \(s\) is the parity of the \(j\)‘th symbol.

    EXAMPLE:

        sage: eps = DirichletGroup(4).gen(0)
        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
        sage: m = ManinSymbolList_character(eps,2); m
        Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
        sage: m.apply_S(4)
        (2, -1)
        sage: [m.apply_S(i) for i in xrange(len(m))]
        [(1, 1), (0, -1), (4, 1), (5, -1), (2, -1), (3, 1)]

  `apply_T`(j)

    Apply the matrix \(T=[0,1,-1,-1]\) to the j-th Manin symbol.

    INPUT:

    - `j` - (integer) a symbol index.

    OUTPUT:

    A list of pairs \((j, c_i)\), where each \(c_i\) is an integer, \(j\) is an integer (the \(j\)-th Manin symbol), and the sum \(c_i*x_i\) is the image of self under the right action of the matrix \(T\).

    EXAMPLE:

        sage: eps = DirichletGroup(4).gen(0)
        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
        sage: m = ManinSymbolList_character(eps,2); m
        Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
        sage: m.apply_T(4)
        [(1, -1)]
        sage: [m.apply_T(i) for i in xrange(len(m))]
        [[(4, 1)], [(0, -1)], [(3, 1)], [(5, 1)], [(1, -1)], [(2, 1)]]

  `apply_TT`(j)

    Apply the matrix \(TT=[-1,-1,0,1]\) to the \(j\)-th Manin symbol.

    INPUT:

    - `j` - (integer) a symbol index

    OUTPUT:

    A list of pairs \((j, c_i)\), where each \(c_i\) is an integer, \(j\) is an integer (the \(j\)-th Manin symbol), and the sum \(c_i*x_i\) is the image of self under the right action of the matrix \(T^2\).

    EXAMPLE:

        sage: eps = DirichletGroup(4).gen(0)
        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
        sage: m = ManinSymbolList_character(eps,2); m
        Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
        sage: m.apply_TT(4)
        [(0, 1)]
        sage: [m.apply_TT(i) for i in xrange(len(m))]
        [[(1, -1)], [(4, -1)], [(5, 1)], [(2, 1)], [(0, 1)], [(3, 1)]]

  `character`()

    Return the character of this ManinSymbolList_character object.

    OUTPUT:

    The Dirichlet character of this Manin symbol list.

    EXAMPLE:

        sage: eps = DirichletGroup(4).gen(0)
        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
        sage: m = ManinSymbolList_character(eps,2); m
        Manin Symbol List of weight 2 for Gamma1(4) with character [-1]
        sage: m.character()
        Dirichlet character modulo 4 of conductor 4 mapping 3 |--> -1

  `index`(x)

    Returns the index in the list of standard Manin symbols of a symbol that is equivalent, modulo a scalar \(s\), to `x`. Returns the index and the scalar.

    If `x` is not in the list, return (-1, 0).

    INPUT:

    - `x` - 3-tuple of integers \((i,u,v)\), defining an element of this list of Manin symbols, which need not be normalized.

    OUTPUT:

    `(i, s)` where i (`int`) is the index of the Manin symbol equivalent to \((i,u,v)\) (or -1) and `s` is the scalar (an element of the base field) or the int 0.

    EXAMPLE:

        sage: eps = DirichletGroup(4).gen(0)
        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
        sage: m = ManinSymbolList_character(eps,4); m
        Manin Symbol List of weight 4 for Gamma1(4) with character [-1]
        sage: [m.index(s.tuple()) for s in m.manin_symbol_list()]
        [(0, 1),
        (1, 1),
        (2, 1),
        (3, 1),
        ...
        (16, 1),
        (17, 1)]

  `level`()

    Return the level of this ManinSymbolList.

    OUTPUT:

    `integer` - the level of the symbols in this list.

    EXAMPLES:

        sage: eps = DirichletGroup(4).gen(0)
        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
        sage: ManinSymbolList_character(eps,4).level()
        4

  `normalize`(x)

    Returns the normalization of the Manin Symbol `x` with respect to this list, together with the normalizing scalar.

    INPUT:

    - `x` - 3-tuple of integers `(i,u,v)`, defining an element of this list of Manin symbols, which need not be normalized.

    OUTPUT:

    `((i,u,v),s)`, where `(i,u,v)` is the normalized Manin symbol equivalent to `x`, and `s` is the normalizing scalar.

    EXAMPLE:

        sage: eps = DirichletGroup(4).gen(0)
        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_character
        sage: m = ManinSymbolList_character(eps,4); m
        Manin Symbol List of weight 4 for Gamma1(4) with character [-1]
        sage: [m.normalize(s.tuple()) for s in m.manin_symbol_list()]
        [((0, 0, 1), 1),
        ((0, 1, 0), 1),
        ((0, 1, 1), 1),
        ...
        ((2, 1, 3), 1),
        ((2, 2, 1), 1)]

class `sage.modular.modsym.manin_symbols.``ManinSymbolList_gamma0`(level, weight)

  Bases: `sage.modular.modsym.manin_symbols.ManinSymbolList_group`

  Class for Manin Symbols for \(\Gamma_0(N)\).

  INPUT:

  - `level` - (integer): the level.
  - `weight` - (integer): the weight.

  EXAMPLE:

      sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
      sage: m = ManinSymbolList_gamma0(5,2); m
      Manin Symbol List of weight 2 for Gamma0(5)
      sage: m.manin_symbol_list()
      [(0,1), (1,0), (1,1), (1,2), (1,3), (1,4)]
      sage: m = ManinSymbolList_gamma0(6,4); m
      Manin Symbol List of weight 4 for Gamma0(6)
      sage: len(m)
      36

class `sage.modular.modsym.manin_symbols.``ManinSymbolList_gamma1`(level, weight)

  Bases: `sage.modular.modsym.manin_symbols.ManinSymbolList_group`

  Class for Manin Symbols for \(\Gamma_1(N)\).

  INPUT:

  - `level` - (integer): the level.
  - `weight` - (integer): the weight.

  EXAMPLE:

      sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma1
      sage: m = ManinSymbolList_gamma1(5,2); m
      Manin Symbol List of weight 2 for Gamma1(5)
      sage: m.manin_symbol_list()
      [(0,1),
      (0,2),
      (0,3),
      ...
      (4,3),
      (4,4)]
      sage: m = ManinSymbolList_gamma1(6,4); m
      Manin Symbol List of weight 4 for Gamma1(6)
      sage: len(m)
      72
      sage: m == loads(dumps(m))
      True

class `sage.modular.modsym.manin_symbols.``ManinSymbolList_gamma_h`(group, weight)

  Bases: `sage.modular.modsym.manin_symbols.ManinSymbolList_group`

  Class for Manin Symbols for \(\Gamma_H(N)\).

  INPUT:

  - `group` - (integer): the congruence subgroup.
  - `weight` - (integer): the weight.

  EXAMPLE:

      sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma_h
      sage: G = GammaH(117, [4])
      sage: m = ManinSymbolList_gamma_h(G,2); m
      Manin Symbol List of weight 2 for Congruence Subgroup Gamma_H(117) with H generated by [4]
      sage: m.manin_symbol_list()[100:110]
      [(1,88),
      (1,89),
      (1,90),
      (1,91),
      (1,92),
      (1,93),
      (1,94),
      (1,95),
      (1,96),
      (1,97)]
      sage: len(m.manin_symbol_list())
      2016
      sage: m == loads(dumps(m))
      True

  `group`()

    Return the group associated to self.

    EXAMPLES:

        sage: ModularSymbols(GammaH(12, [5]), 2).manin_symbols().group()
        Congruence Subgroup Gamma_H(12) with H generated by [5]

class `sage.modular.modsym.manin_symbols.``ManinSymbolList_group`(level, weight, syms)

  Bases: `sage.modular.modsym.manin_symbols.ManinSymbolList`

  Base class for Manin symbol lists for a given group.

  INPUT:

  - `level` - integer level
  - `weight` - integer weight
  - `syms` - something with a normalize and list method, e.g., P1List.

  EXAMPLES:

      sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_group
      sage: ManinSymbolList_group(11, 2, P1List(11))
      <class 'sage.modular.modsym.manin_symbols.ManinSymbolList_group'>

  `apply`(j, m)

    Apply the matrix \(m=[a,b;c,d]\) to the \(j\)-th Manin symbol.

    INPUT:

    - `j` - (int) a symbol index
    - `m = [a, b, c, d]` a list of 4 integers, which defines a 2x2 matrix.

    OUTPUT:

    a list of pairs \((j_i, \alpha_i)\), where each \(\alpha_i\) is a nonzero integer, \(j_i\) is an integer (index of the \(j_i\)-th Manin symbol), and \(\sum_i \alpha_i\*x_{j_i}\) is the image of the j-th Manin symbol under the right action of the matrix [a,b;c,d]. Here the right action of g=[a,b;c,d] on a Manin symbol \([P(X,Y),(u,v)]\) is \([P(aX+bY,cX+dY),(u,v)\*g]\).

    EXAMPLE:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: m.apply(40,[2,3,1,1])
        [(0, 729), (6, 2916), (12, 4860), (18, 4320), (24, 2160), (30, 576), (36, 64)]

  `apply_I`(j)

    Apply the matrix \(I=[-1,0,0,1]\) to the \(j\)-th Manin symbol.

    INPUT:

    - `j` - (int) a symbol index

    OUTPUT:

    `(k, s)` where k is the index of the symbol obtained by acting on the \(j\)‘th symbol with \(I\), and \(s\) is the parity of of the \(j\)‘th symbol (a Python `int`, either 1 or -1)

    EXAMPLE:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: m.apply_I(4)
        (3, 1)
        sage: [m.apply_I(i) for i in xrange(10)]
        [(0, 1),
        (1, 1),
        (5, 1),
        (4, 1),
        (3, 1),
        (2, 1),
        (6, -1),
        (7, -1),
        (11, -1),
        (10, -1)]

  `apply_S`(j)

    Apply the matrix \(S=[0,-1,1,0]\) to the \(j\)-th Manin symbol.

    INPUT:

    - `j` - (int) a symbol index

    OUTPUT:

    `(k, s)` where k is the index of the symbol obtained by acting on the \(j\)‘th symbol with \(S\), and \(s\) is the parity of of the \(j\)‘th symbol (a Python `int`, either 1 or -1).

    EXAMPLE:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: m.apply_S(4)
        (40, 1)
        sage: [m.apply_S(i) for i in xrange(len(m))]
        [(37, 1),
        (36, 1),
        (41, 1),
        (39, 1),
        (40, 1),
        (38, 1),
        (31, -1),
        (30, -1),
        (35, -1),
        (33, -1),
        (34, -1),
        (32, -1),
        ...
        (4, 1),
        (2, 1)]

  `apply_T`(j)

    Apply the matrix \(T=[0,1,-1,-1]\) to the \(j\)-th Manin symbol.

    INPUT:

    - `j` - (int) a symbol index

    OUTPUT: see documentation for apply()

    EXAMPLE:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: m.apply_T(4)
        [(3, 1), (9, -6), (15, 15), (21, -20), (27, 15), (33, -6), (39, 1)]
        sage: [m.apply_T(i) for i in xrange(10)]
        [[(5, 1), (11, -6), (17, 15), (23, -20), (29, 15), (35, -6), (41, 1)],
        [(0, 1), (6, -6), (12, 15), (18, -20), (24, 15), (30, -6), (36, 1)],
        [(4, 1), (10, -6), (16, 15), (22, -20), (28, 15), (34, -6), (40, 1)],
        [(2, 1), (8, -6), (14, 15), (20, -20), (26, 15), (32, -6), (38, 1)],
        [(3, 1), (9, -6), (15, 15), (21, -20), (27, 15), (33, -6), (39, 1)],
        [(1, 1), (7, -6), (13, 15), (19, -20), (25, 15), (31, -6), (37, 1)],
        [(5, 1), (11, -5), (17, 10), (23, -10), (29, 5), (35, -1)],
        [(0, 1), (6, -5), (12, 10), (18, -10), (24, 5), (30, -1)],
        [(4, 1), (10, -5), (16, 10), (22, -10), (28, 5), (34, -1)],
        [(2, 1), (8, -5), (14, 10), (20, -10), (26, 5), (32, -1)]]

  `apply_TT`(j)

    Apply the matrix \(TT=[-1,-1,0,1]\) to the \(j\)-th Manin symbol.

    INPUT:

    - `j` - (int) a symbol index

    OUTPUT: see documentation for apply()

    EXAMPLE:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: m.apply_TT(4)
        [(38, 1)]
        sage: [m.apply_TT(i) for i in xrange(10)]
        [[(37, 1)],
        [(41, 1)],
        [(39, 1)],
        [(40, 1)],
        [(38, 1)],
        [(36, 1)],
        [(31, -1), (37, 1)],
        [(35, -1), (41, 1)],
        [(33, -1), (39, 1)],
        [(34, -1), (40, 1)]]

  `level`()

    Return the level of this ManinSymbolList.

    EXAMPLES:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: ManinSymbolList_gamma0(5,2).level()
        5

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma1
        sage: ManinSymbolList_gamma1(51,2).level()
        51

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma_h
        sage: ManinSymbolList_gamma_h(GammaH(117, [4]),2).level()
        117

  `normalize`(x)

    Returns the normalization of the ModSym `x` with respect to this list.

    INPUT:

    - `x` - (3-tuple of ints) a tuple defining a ManinSymbol.

    OUTPUT:

    `(i,u,v)` - (3-tuple of ints) another tuple defining the associated normalized ManinSymbol.

    EXAMPLE:

        sage: from sage.modular.modsym.manin_symbols import ManinSymbolList_gamma0
        sage: m = ManinSymbolList_gamma0(5,8)
        sage: [m.normalize(s.tuple()) for s in m.manin_symbol_list()][:10]
        [(0, 0, 1),
        (0, 1, 0),
        (0, 1, 1),
        (0, 1, 2),
        (0, 1, 3),
        (0, 1, 4),
        (1, 0, 1),
        (1, 1, 0),
        (1, 1, 1),
        (1, 1, 2)]

`sage.modular.modsym.manin_symbols.``is_ManinSymbol`(x)

  Returns True if `x` is a ManinSymbol.

  EXAMPLES:

      sage: from sage.modular.modsym.manin_symbols import ManinSymbol, ManinSymbolList_gamma0, is_ManinSymbol
      sage: m = ManinSymbolList_gamma0(6, 4)
      sage: is_ManinSymbol(m[3])
      False
      sage: s = ManinSymbol(m,m[3])
      sage: s
      [Y^2,(1,2)]
      sage: is_ManinSymbol(s)
      True

### Navigation

- index
- modules |
- next |
- previous |
- Modular Symbols »