def apply(self, 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_symbol_list import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,4)
sage: m[6]
[X*Y,(0,1)]
sage: m.apply(4, [1,0,0,1])
[(4, 1)]
sage: m.apply(1, [-1,0,0,1])
[(1, -1)]
"""
a, b, c, d = m[0], m[1], m[2], m[3]
i, u, v = self._symbol_list[j]
P = apply_to_monomial(i, self._weight - 2, a, b, c, d)
m, s = self.index((0, u * a + v * c, u * b + v * d))
if m == -1 or s == 0:
return []
r = len(self.__P1)
return [(m + r * k, s * P[k]) for k in range(self._weight - 2 + 1)
if P[k] != 0]
def apply(self, 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_symbol_list import ManinSymbolList_character
sage: m = ManinSymbolList_character(eps,4)
sage: m[6]
[X*Y,(0,1)]
sage: m.apply(4, [1,0,0,1])
[(4, 1)]
sage: m.apply(1, [-1,0,0,1])
[(1, -1)]
"""
a, b, c, d = m[0], m[1], m[2], m[3]
i, u, v = self._symbol_list[j]
P = apply_to_monomial(i, self._weight-2, a, b, c, d)
m, s = self.index((0, u*a+v*c, u*b+v*d))
if m == -1 or s == 0:
return []
r = len(self.__P1)
return [(m + r*k, s*P[k]) for k in range(self._weight-2+1)
if P[k] != 0]
def apply(self, j, m):
r"""
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_symbol_list 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)]
"""
a, b, c, d = m[0], m[1], m[2], m[3]
i, u, v = self._symbol_list[j]
P = apply_to_monomial(i, self._weight - 2, a, b, c, d)
m = self.index((0, u * a + v * c, u * b + v * d))
if m == -1:
return []
r = len(self.__syms)
return [(m + r * k, P[k]) for k in range(self._weight - 2 + 1)
if P[k] != 0]
def apply(self, j, m):
r"""
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_symbol_list 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)]
"""
a, b, c, d = m[0], m[1], m[2], m[3]
i, u, v = self._symbol_list[j]
P = apply_to_monomial(i, self._weight-2, a, b, c, d)
m = self.index((0, u*a+v*c, u*b+v*d))
if m == -1:
return []
r = len(self.__syms)
return [(m + r*k, P[k]) for k in range(self._weight-2+1)
if P[k] != 0]
