Elements of arithmetic subgroups - Arithmetic Subgroups of $\SL_2(\ZZ)$

Skip to content
Back to top
View this page
Edit this page

# Elements of arithmetic subgroups

class sage.modular.arithgroup.arithgroup_element.ArithmeticSubgroupElement

  Bases: `MultiplicativeGroupElement`

  An element of the group \(\SL_2(\ZZ)\), i.e. a 2x2 integer matrix of determinant 1.

  a()

    Return the upper left entry of `self`.

    EXAMPLES:

    Sage

        sage: Gamma0(13)([7,1,13,2]).a()
        7

    Python

        >>> from sage.all import *
        >>> Gamma0(Integer(13))([Integer(7),Integer(1),Integer(13),Integer(2)]).a()
        7

  acton(z)

    Return the result of the action of `self` on z as a fractional linear transformation.

    EXAMPLES:

    Sage

        sage: G = Gamma0(15)
        sage: g = G([1, 2, 15, 31])

    Python

        >>> from sage.all import *
        >>> G = Gamma0(Integer(15))
        >>> g = G([Integer(1), Integer(2), Integer(15), Integer(31)])

    An example of g acting on a symbolic variable:

    Sage

        sage: z = var('z')                                                          # needs sage.symbolic
        sage: g.acton(z)                                                            # needs sage.symbolic
        (z + 2)/(15*z + 31)

    [Python]

        >>> from sage.all import *
        >>> z = var('z')                                                          # needs sage.symbolic
        >>> g.acton(z)                                                            # needs sage.symbolic
        (z + 2)/(15*z + 31)

    An example involving the Gaussian numbers:

    Sage

        sage: # needs sage.rings.number_field
        sage: x = polygen(ZZ, 'x')
        sage: K.<i> = NumberField(x^2 + 1)
        sage: g.acton(i)
        1/1186*i + 77/1186

    Python

        >>> from sage.all import *
        >>> # needs sage.rings.number_field
        >>> x = polygen(ZZ, 'x')
        >>> K = NumberField(x**Integer(2) + Integer(1), names=('i',)); (i,) = K._first_ngens(1)
        >>> g.acton(i)
        1/1186*i + 77/1186

    An example with complex numbers:

    Sage

        sage: C.<i> = ComplexField()
        sage: g.acton(i)
        0.0649241146711636 + 0.000843170320404721*I

    [Python]

        >>> from sage.all import *
        >>> C = ComplexField(names=('i',)); (i,) = C._first_ngens(1)
        >>> g.acton(i)
        0.0649241146711636 + 0.000843170320404721*I

    An example with the cusp infinity:

    Sage

        sage: g.acton(infinity)
        1/15

    Python

        >>> from sage.all import *
        >>> g.acton(infinity)
        1/15

    An example which maps a finite cusp to infinity:

    Sage

        sage: g.acton(-31/15)
        +Infinity

    [Python]

        >>> from sage.all import *
        >>> g.acton(-Integer(31)/Integer(15))
        +Infinity

    Note that when acting on instances of cusps the return value is still a rational number or infinity (Note the presence of ‘+’, which does not show up for cusp instances):

    Sage

        sage: g.acton(Cusp(-31/15))
        +Infinity

    Python

        >>> from sage.all import *
        >>> g.acton(Cusp(-Integer(31)/Integer(15)))
        +Infinity

  b()

    Return the upper right entry of `self`.

    EXAMPLES:

    Sage

        sage: Gamma0(13)([7,1,13,2]).b()
        1

    Python

        >>> from sage.all import *
        >>> Gamma0(Integer(13))([Integer(7),Integer(1),Integer(13),Integer(2)]).b()
        1

  c()

    Return the lower left entry of `self`.

    EXAMPLES:

    Sage

        sage: Gamma0(13)([7,1,13,2]).c()
        13

    Python

        >>> from sage.all import *
        >>> Gamma0(Integer(13))([Integer(7),Integer(1),Integer(13),Integer(2)]).c()
        13

  d()

    Return the lower right entry of `self`.

    EXAMPLES:

    Sage

        sage: Gamma0(13)([7,1,13,2]).d()
        2

    Python

        >>> from sage.all import *
        >>> Gamma0(Integer(13))([Integer(7),Integer(1),Integer(13),Integer(2)]).d()
        2

  det()

    Return the determinant of `self`, which is always 1.

    EXAMPLES:

    Sage

        sage: Gamma1(11)([12,11,-11,-10]).det()
        1

    Python

        >>> from sage.all import *
        >>> Gamma1(Integer(11))([Integer(12),Integer(11),-Integer(11),-Integer(10)]).det()
        1

  determinant()

    Return the determinant of `self`, which is always 1.

    EXAMPLES:

    Sage

        sage: Gamma0(691)([1,0,691,1]).determinant()
        1

    Python

        >>> from sage.all import *
        >>> Gamma0(Integer(691))([Integer(1),Integer(0),Integer(691),Integer(1)]).determinant()
        1

  matrix()

    Return the matrix corresponding to `self`.

    EXAMPLES:

    Sage

        sage: x = Gamma1(3)([4,5,3,4]) ; x
        [4 5]
        [3 4]
        sage: x.matrix()
        [4 5]
        [3 4]
        sage: type(x.matrix())
        <class 'sage.matrix.matrix_integer_dense.Matrix_integer_dense'>

    Python

        >>> from sage.all import *
        >>> x = Gamma1(Integer(3))([Integer(4),Integer(5),Integer(3),Integer(4)]) ; x
        [4 5]
        [3 4]
        >>> x.matrix()
        [4 5]
        [3 4]
        >>> type(x.matrix())
        <class 'sage.matrix.matrix_integer_dense.Matrix_integer_dense'>

  multiplicative_order()

    Return the multiplicative order of this element.

    EXAMPLES:

    Sage

        sage: SL2Z.one().multiplicative_order()
        1
        sage: SL2Z([-1,0,0,-1]).multiplicative_order()
        2
        sage: s,t = SL2Z.gens()
        sage: ((t^3*s*t^2) * s * ~(t^3*s*t^2)).multiplicative_order()
        4
        sage: (t^3 * s * t * t^-3).multiplicative_order()
        6
        sage: (t^3 * s * t * s * t^-2).multiplicative_order()
        3
        sage: SL2Z([2,1,1,1]).multiplicative_order()
        +Infinity
        sage: SL2Z([-2,1,1,-1]).multiplicative_order()
        +Infinity

    Python

        >>> from sage.all import *
        >>> SL2Z.one().multiplicative_order()
        1
        >>> SL2Z([-Integer(1),Integer(0),Integer(0),-Integer(1)]).multiplicative_order()
        2
        >>> s,t = SL2Z.gens()
        >>> ((t**Integer(3)*s*t**Integer(2)) * s * ~(t**Integer(3)*s*t**Integer(2))).multiplicative_order()
        4
        >>> (t**Integer(3) * s * t * t**-Integer(3)).multiplicative_order()
        6
        >>> (t**Integer(3) * s * t * s * t**-Integer(2)).multiplicative_order()
        3
        >>> SL2Z([Integer(2),Integer(1),Integer(1),Integer(1)]).multiplicative_order()
        +Infinity
        >>> SL2Z([-Integer(2),Integer(1),Integer(1),-Integer(1)]).multiplicative_order()
        +Infinity