This module contains various functions relating to lifting elements of
to
, and other related
problems.
Return four integers defining a matrix in which is
congruent to
and
lies in the subgroup
.
This is a special case of lift_to_gamma1(), and is coded as such.
EXAMPLE:
sage: from sage.modular.local_comp.liftings import lift_gen_to_gamma1
sage: A = matrix(ZZ, 2, lift_gen_to_gamma1(9, 8)); A
[441 62]
[ 64 9]
sage: A.change_ring(Zmod(9))
[0 8]
[1 0]
sage: A.change_ring(Zmod(8))
[1 6]
[0 1]
sage: type(lift_gen_to_gamma1(9, 8)[0])
<type 'sage.rings.integer.Integer'>
Given a list of length 4 representing a 2x2 matrix over with
determinant 1 (mod
), lift it to a 2x2 matrix over
with
determinant 1.
This is a special case of lift_to_gamma1(), and is coded as such.
TESTS:
sage: from sage.modular.local_comp.liftings import lift_matrix_to_sl2z
sage: lift_matrix_to_sl2z([10, 11, 3, 11], 19)
[29, 106, 3, 11]
sage: type(_[0])
<type 'sage.rings.integer.Integer'>
sage: lift_matrix_to_sl2z([2,0,0,1], 5)
Traceback (most recent call last):
...
ValueError: Determinant is 2 mod 5, should be 1
Given four integers with
and
,
find
congruent to
, with
, such that
is exactly 1, and
is in
.
Algorithm: Uses lift_to_gamma1() to get a lifting modulo , and
then adds an appropriate multiple of the top row to the bottom row in order
to get the bottom-left entry correct modulo
.
EXAMPLE:
sage: from sage.modular.local_comp.liftings import lift_ramified
sage: lift_ramified([2,2,3,2], 3, 1, 1)
[5, 8, 3, 5]
sage: lift_ramified([8,2,12,2], 3, 2, 23)
[323, 110, -133584, -45493]
sage: type(lift_ramified([8,2,12,2], 3, 2, 23)[0])
<type 'sage.rings.integer.Integer'>
If g = [a,b,c,d] is a list of integers defining a matrix
whose determinant is
, return a list of integers giving the
entries of a matrix which is congruent to
and to
. Here
and
must be coprime.
Here and
should be coprime positive integers. Either of
and
can be
. If
, this still makes perfect sense; this is what is
called by the function lift_matrix_to_sl2z(). If
this is a
rather silly question, so we adopt the convention of always returning the
identity matrix.
The result is always a list of Sage integers (unlike lift_to_sl2z, which tends to return Python ints).
EXAMPLE:
sage: from sage.modular.local_comp.liftings import lift_to_gamma1
sage: A = matrix(ZZ, 2, lift_to_gamma1([10, 11, 3, 11], 19, 5)); A
[371 68]
[ 60 11]
sage: A.det() == 1
True
sage: A.change_ring(Zmod(19))
[10 11]
[ 3 11]
sage: A.change_ring(Zmod(5))
[1 3]
[0 1]
sage: m = list(SL2Z.random_element())
sage: n = lift_to_gamma1(m, 11, 17)
sage: assert matrix(Zmod(11), 2, n) == matrix(Zmod(11),2,m)
sage: assert matrix(Zmod(17), 2, [n[0], 0, n[2], n[3]]) == 1
sage: type(lift_to_gamma1([10,11,3,11],19,5)[0])
<type 'sage.rings.integer.Integer'>
Tests with and with
:
sage: lift_to_gamma1([1,1,0,1], 5, 1)
[1, 1, 0, 1]
sage: lift_to_gamma1([2,3,11,22], 1, 5)
[1, 0, 0, 1]
Construct a matrix over whose determinant is
, and which is
congruent to
and
to
.
This is required for the local components machinery in the “ramified” case
(when the exponent of dividing the level is odd).
EXAMPLE:
sage: from sage.modular.local_comp.liftings import lift_uniformiser_odd
sage: lift_uniformiser_odd(3, 2, 11)
[432, 377, 165, 144]
sage: type(lift_uniformiser_odd(3, 2, 11)[0])
<type 'sage.rings.integer.Integer'>