### Navigation

- index
- modules |
- next |
- previous |
- Modular Forms for Hecke Triangle Groups »

# Hecke triangle group elements

AUTHORS:

- Jonas Jermann (2014): initial version

class `sage.modular.modform_hecketriangle.hecke_triangle_group_element.``HeckeTriangleGroupElement`(parent, M, check=False, **kwargs)

  Bases: `sage.groups.matrix_gps.group_element.MatrixGroupElement_generic`

  Elements of HeckeTriangleGroup.

  `a`()

    Return the upper left entry of `self`.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: U = HeckeTriangleGroup(n=7).U()
        sage: U.a()
        lam
        sage: U.a().parent()
        Maximal Order in Number Field in lam with defining polynomial x^3 - x^2 - 2*x + 1

  `acton`(z)

    Return the image of `z` under the action of `self` by linear fractional transformations or by conjugation in case `z` is an element of the parent of `self`.

    There is a 1-1 correspondence between hyperbolic fixed points and the corresponding primitive element in the stabilizer. The action in the two cases above is compatible with this correspondence.

    INPUT:

    - `z` – Either an element of `self` or any

        element to which a linear fractional transformation can be applied in the usual way.

        In particular `infinity` is a possible argument and a possible return value.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(5)
        sage: G.S().acton(1 + i/2)
        2/5*I - 4/5
        sage: G.S().acton(1 + i/2).parent()
        Symbolic Ring
        sage: G.S().acton(i + exp(-2))
        -1/(e^(-2) + I)
        sage: G.S().acton(i + exp(-2)).parent()
        Symbolic Ring

        sage: G.T().acton(infinity) == infinity
        True
        sage: G.U().acton(infinity)
        lam
        sage: G.V(2).acton(-G.lam()) == infinity
        True

        sage: G.V(2).acton(G.U()) == G.V(2)*G.U()*G.V(2).inverse()
        True
        sage: G.V(2).inverse().acton(G.U())
        [  0  -1]
        [  1 lam]

  `b`()

    Return the upper right entry of `self`.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: U = HeckeTriangleGroup(n=7).U()
        sage: U.b()
        -1
        sage: U.b().parent()
        Maximal Order in Number Field in lam with defining polynomial x^3 - x^2 - 2*x + 1

  `c`()

    Return the lower left entry of `self`.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: U = HeckeTriangleGroup(n=7).U()
        sage: U.c()
        1

  `d`()

    Return the lower right of `self`.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: U = HeckeTriangleGroup(n=7).U()
        sage: U.d()
        0

  `decompose_basic`()

    Decompose `self` into a product of the generators `S` and `T` of its parent,

    The function returns a tuple `L` consisting of either `parent.S()` or non-trivial integer powers of `parent.T()`. Additionally `L` starts with +- the identity. It satisfies the property: `prod(L) == self`.

    If this decomposition is not possible an `ValueError` is raised. In particular this function can be used to check the membership in `parent` of an arbitrary matrix over the base ring.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=17)
        sage: L = (-G.V(2)).decompose_basic()
        sage: L
        (
        [  1 lam]  [ 0 -1]  [  1 lam]  [-1  0]
        [  0   1], [ 1  0], [  0   1], [ 0 -1]
        )
        sage: prod(L) == -G.V(2)
        True
        sage: L = G.U().decompose_basic()
        sage: L
        (
        [  1 lam]  [ 0 -1]  [1 0]
        [  0   1], [ 1  0], [0 1]
        )
        sage: prod(L) == G.U()
        True

  `discriminant`()

    Return the discriminant of `self` which corresponds to the discriminant of the corresponding quadratic form of `self`.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=7)
        sage: G.V(3).discriminant()
        4*lam^2 + 4*lam - 4
        sage: AA(G.V(3).discriminant())
        16.19566935808922?

  `fixed_points`(embedded=False, order='default')

    Return a pair of (mutually conjugate) fixed points of `self` in a possible quadratic extension of the base field.

    INPUT:

    - `embedded` – If `True` the fixed points are embedded into

        `AlgebraicRealField` resp. `AlgebraicField`. Default: `False`.

    - `order` – If `order="none"` the fixed points are choosen

        and ordered according to a fixed formula.

        If `order="sign"` the fixed points are always ordered according to the sign in front of the square root.

        If `order="default"` (default) then in case the fixed points are hyperbolic they are ordered according to the sign of the trace of `self` instead, such that the attracting fixed point comes first.

        If `order="trace"` the fixed points are always ordered according to the sign of the trace of `self`. If the trace is zero they are ordered by the sign in front of the square root. In particular the fixed_points in this case remain the same for `-self`.

    OUTPUT:

    If `embedded=True` an element of either `AlgebraicRealField` or `AlgebraicField` is returned. Otherwise an element of a relative field extension over the base field of (the parent of) `self` is returned.

    Warning: Relative field extensions don’t support default embeddings. So the correct embedding (which is the positive resp. imaginary positive one) has to be choosen.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=infinity)
        sage: (-G.T(-4)).fixed_points()
        [+Infinity, +Infinity]
        sage: (-G.S()).fixed_points()
        [1/2*e, -1/2*e]
        sage: p = (-G.S()).fixed_points(embedded=True)[0]
        sage: p
        1*I
        sage: (-G.S()).acton(p) == p
        True
        sage: (-G.V(2)).fixed_points()
        [1/2*e, -1/2*e]
        sage: (-G.V(2)).fixed_points() == G.V(2).fixed_points()
        True
        sage: p = (-G.V(2)).fixed_points(embedded=True)[1]
        sage: p
        -1.732050807568878?
        sage: (-G.V(2)).acton(p) == p
        True

        sage: G = HeckeTriangleGroup(n=7)
        sage: (-G.S()).fixed_points()
        [1/2*e, -1/2*e]
        sage: p = (-G.S()).fixed_points(embedded=True)[1]
        sage: p
        -1*I
        sage: (-G.S()).acton(p) == p
        True
        sage: (G.U()^4).fixed_points()
        [(1/2*lam^2 - 1/2*lam - 1/2)*e + 1/2*lam, (-1/2*lam^2 + 1/2*lam + 1/2)*e + 1/2*lam]
        sage: pts = (G.U()^4).fixed_points(order="trace")
        sage: (G.U()^4).fixed_points() == [pts[1], pts[0]]
        True
        sage: (G.U()^4).fixed_points(order="trace") == (-G.U()^4).fixed_points(order="trace")
        True
        sage: (G.U()^4).fixed_points() == (G.U()^4).fixed_points(order="none")
        True
        sage: (-G.U()^4).fixed_points() == (G.U()^4).fixed_points()
        True
        sage: (-G.U()^4).fixed_points(order="none") == pts
        True
        sage: p = (G.U()^4).fixed_points(embedded=True)[1]
        sage: p
        0.9009688679024191? - 0.4338837391175581?*I
        sage: (G.U()^4).acton(p) == p
        True
        sage: (-G.V(5)).fixed_points()
        [(1/2*lam^2 - 1/2*lam - 1/2)*e, (-1/2*lam^2 + 1/2*lam + 1/2)*e]
        sage: (-G.V(5)).fixed_points() == G.V(5).fixed_points()
        True
        sage: p = (-G.V(5)).fixed_points(embedded=True)[0]
        sage: p
        0.6671145837954892?
        sage: (-G.V(5)).acton(p) == p
        True

  `is_elliptic`()

    Return whether `self` is an elliptic matrix.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=7)
        sage: [ G.V(k).is_elliptic() for k in range(1,8) ]
        [False, False, False, False, False, False, True]
        sage: G.U().is_elliptic()
        True

  `is_hyperbolic`()

    Return whether `self` is a hyperbolic matrix.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=7)
        sage: [ G.V(k).is_hyperbolic() for k in range(1,8) ]
        [False, True, True, True, True, False, False]
        sage: G.U().is_hyperbolic()
        False

  `is_identity`()

    Return whether `self` is the identity or minus the identity.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=7)
        sage: [ G.V(k).is_identity() for k in range(1,8) ]
        [False, False, False, False, False, False, False]
        sage: G.U().is_identity()
        False

  `is_parabolic`(exclude_one=False)

    Return whether `self` is a parabolic matrix.

    If `exclude_one` is set, then +- the identity element is not considered parabolic.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=7)
        sage: [ G.V(k).is_parabolic() for k in range(1,8) ]
        [True, False, False, False, False, True, False]
        sage: G.U().is_parabolic()
        False
        sage: G.V(6).is_parabolic(exclude_one=True)
        True
        sage: G.V(7).is_parabolic(exclude_one=True)
        False

  `is_reflection`()

    Return whether `self` is the usual reflection on the unit circle.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: (-HeckeTriangleGroup(n=7).S()).is_reflection()
        True
        sage: HeckeTriangleGroup(n=7).U().is_reflection()
        False

  `is_translation`(exclude_one=False)

    Return whether `self` is a translation. If `exclude_one = True`, then the identity map is not considered as a translation.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: (-HeckeTriangleGroup(n=7).T(-4)).is_translation()
        True
        sage: (-HeckeTriangleGroup(n=7).I()).is_translation()
        True
        sage: (-HeckeTriangleGroup(n=7).I()).is_translation(exclude_one=True)
        False

  `root_extension_embedding`(K=Algebraic Field)

    Return the correct embedding from the root extension field to `K` (default: `AlgebraicField()`).

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=infinity)

        sage: fp = (-G.S()).fixed_points()[0]
        sage: alg_fp = (-G.S()).root_extension_embedding()(fp)
        sage: alg_fp
        1*I
        sage: alg_fp == (-G.S()).fixed_points(embedded=True)[0]
        True

        sage: fp = (-G.V(2)).fixed_points()[1]
        sage: alg_fp = (-G.V(2)).root_extension_embedding(AA)(fp)
        sage: alg_fp
        -1.732050807568...?
        sage: alg_fp == (-G.V(2)).fixed_points(embedded=True)[1]
        True

        sage: fp = (-G.V(2)).fixed_points()[0]
        sage: alg_fp = (-G.V(2)).root_extension_embedding(AA)(fp)
        sage: alg_fp
        1.732050807568...?
        sage: alg_fp == (-G.V(2)).fixed_points(embedded=True)[0]
        True

        sage: G = HeckeTriangleGroup(n=7)

        sage: fp = (-G.S()).fixed_points()[1]
        sage: alg_fp = (-G.S()).root_extension_embedding()(fp)
        sage: alg_fp
        0.?... - 1.000000000000...?*I
        sage: alg_fp == (-G.S()).fixed_points(embedded=True)[1]
        True

        sage: fp = (-G.U()^4).fixed_points()[0]
        sage: alg_fp = (-G.U()^4).root_extension_embedding()(fp)
        sage: alg_fp
        0.9009688679024...? + 0.4338837391175...?*I
        sage: alg_fp == (-G.U()^4).fixed_points(embedded=True)[0]
        True

        sage: (-G.U()^4).root_extension_embedding(CC)(fp)
        0.900968867902... + 0.433883739117...*I
        sage: (-G.U()^4).root_extension_embedding(CC)(fp).parent()
        Complex Field with 53 bits of precision

        sage: fp = (-G.V(5)).fixed_points()[1]
        sage: alg_fp = (-G.V(5)).root_extension_embedding(AA)(fp)
        sage: alg_fp
        -0.6671145837954...?
        sage: alg_fp == (-G.V(5)).fixed_points(embedded=True)[1]
        True

  `root_extension_field`()

    Return the extension field of the base field of (the parent of) `self` in which the corresponding fixed points of `self` lie.

    The variable name of the corresponding generator is `e`. It corresponds to `e=sqrt(D)`, where `D` is the discriminant of `self`. If the extension degree is `1` then the base field is returned.

    The correct embedding is the positive resp. positive imaginary one. Unfortunately no default embedding can be specified for relative number fields yet.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=infinity)
        sage: G.V(3).root_extension_field()
        Number Field in e with defining polynomial x^2 - 32
        sage: G.T().root_extension_field() == G.base_field()
        True
        sage: (G.S()).root_extension_field()
        Number Field in e with defining polynomial x^2 + 4

        sage: G = HeckeTriangleGroup(n=7)
        sage: G.V(3).root_extension_field()
        Number Field in e with defining polynomial x^2 - 4*lam^2 - 4*lam + 4 over its base field
        sage: G.V(1).root_extension_field() == G.base_field()
        True
        sage: G.U().root_extension_field()
        Number Field in e with defining polynomial x^2 - lam^2 + 4 over its base field

  `trace`()

    Return the trace of `self`, which is the sum of the diagonal entries.

    EXAMPLES:

        sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup
        sage: G = HeckeTriangleGroup(n=7)
        sage: G.U().trace()
        lam
        sage: G.S().trace()
        0

### Navigation

- index
- modules |
- next |
- previous |
- Modular Forms for Hecke Triangle Groups »