Hecke triangle groups¶
AUTHORS:
- Jonas Jermann (2013): initial version 
- class sage.modular.modform_hecketriangle.hecke_triangle_groups.HeckeTriangleGroup(n)[source]¶
- Bases: - FinitelyGeneratedMatrixGroup_generic,- UniqueRepresentation- Hecke triangle group \((2, n, \infty)\). - Element[source]¶
- alias of - HeckeTriangleGroupElement
 - I()[source]¶
- Return the identity element/matrix for - self.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(10).I() [1 0] [0 1] sage: HeckeTriangleGroup(10).I().parent() Hecke triangle group for n = 10 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(10)).I() [1 0] [0 1] >>> HeckeTriangleGroup(Integer(10)).I().parent() Hecke triangle group for n = 10 
 - S()[source]¶
- Return the generator of - selfcorresponding to the conformal circle inversion.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(3).S() [ 0 -1] [ 1 0] sage: HeckeTriangleGroup(10).S() [ 0 -1] [ 1 0] sage: HeckeTriangleGroup(10).S()^2 == -HeckeTriangleGroup(10).I() True sage: HeckeTriangleGroup(10).S()^4 == HeckeTriangleGroup(10).I() True sage: HeckeTriangleGroup(10).S().parent() Hecke triangle group for n = 10 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(3)).S() [ 0 -1] [ 1 0] >>> HeckeTriangleGroup(Integer(10)).S() [ 0 -1] [ 1 0] >>> HeckeTriangleGroup(Integer(10)).S()**Integer(2) == -HeckeTriangleGroup(Integer(10)).I() True >>> HeckeTriangleGroup(Integer(10)).S()**Integer(4) == HeckeTriangleGroup(Integer(10)).I() True >>> HeckeTriangleGroup(Integer(10)).S().parent() Hecke triangle group for n = 10 
 - T(m=1)[source]¶
- Return the element in - selfcorresponding to the translation by- m*self.lam().- INPUT: - m– integer (default: 1); namely the second generator of- self
 - EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(3).T() [1 1] [0 1] sage: HeckeTriangleGroup(10).T(-4) [ 1 -4*lam] [ 0 1] sage: HeckeTriangleGroup(10).T().parent() Hecke triangle group for n = 10 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(3)).T() [1 1] [0 1] >>> HeckeTriangleGroup(Integer(10)).T(-Integer(4)) [ 1 -4*lam] [ 0 1] >>> HeckeTriangleGroup(Integer(10)).T().parent() Hecke triangle group for n = 10 
 - U()[source]¶
- Return an alternative generator of - selfinstead of- T.- Ustabilizes- rhoand has order- 2*self.n().- If - n=infinitythen- Uis parabolic and has infinite order, it then fixes the cusp- [-1].- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(3).U() [ 1 -1] [ 1 0] sage: HeckeTriangleGroup(3).U()^3 == -HeckeTriangleGroup(3).I() True sage: HeckeTriangleGroup(3).U()^6 == HeckeTriangleGroup(3).I() True sage: HeckeTriangleGroup(10).U() [lam -1] [ 1 0] sage: HeckeTriangleGroup(10).U()^10 == -HeckeTriangleGroup(10).I() True sage: HeckeTriangleGroup(10).U()^20 == HeckeTriangleGroup(10).I() True sage: HeckeTriangleGroup(10).U().parent() Hecke triangle group for n = 10 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(3)).U() [ 1 -1] [ 1 0] >>> HeckeTriangleGroup(Integer(3)).U()**Integer(3) == -HeckeTriangleGroup(Integer(3)).I() True >>> HeckeTriangleGroup(Integer(3)).U()**Integer(6) == HeckeTriangleGroup(Integer(3)).I() True >>> HeckeTriangleGroup(Integer(10)).U() [lam -1] [ 1 0] >>> HeckeTriangleGroup(Integer(10)).U()**Integer(10) == -HeckeTriangleGroup(Integer(10)).I() True >>> HeckeTriangleGroup(Integer(10)).U()**Integer(20) == HeckeTriangleGroup(Integer(10)).I() True >>> HeckeTriangleGroup(Integer(10)).U().parent() Hecke triangle group for n = 10 
 - V(j)[source]¶
- Return the j’th generator for the usual representatives of conjugacy classes of - self. It is given by- V=U^(j-1)*T.- INPUT: - j–integer; to get the usual representatives- jshould range from- 1to- self.n()-1
 - OUTPUT: the corresponding matrix/element - The matrix is parabolic if - jis congruent to \(\pm 1\) modulo- self.n(). It is elliptic if- jis congruent to 0 modulo- self.n(). It is hyperbolic otherwise.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(3) sage: G.V(0) == -G.S() True sage: G.V(1) == G.T() True sage: G.V(2) [1 0] [1 1] sage: G.V(3) == G.S() True sage: G = HeckeTriangleGroup(5) sage: G.element_repr_method("default") sage: G.V(1) [ 1 lam] [ 0 1] sage: G.V(2) [lam lam] [ 1 lam] sage: G.V(3) [lam 1] [lam lam] sage: G.V(4) [ 1 0] [lam 1] sage: G.V(5) == G.S() True - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(Integer(3)) >>> G.V(Integer(0)) == -G.S() True >>> G.V(Integer(1)) == G.T() True >>> G.V(Integer(2)) [1 0] [1 1] >>> G.V(Integer(3)) == G.S() True >>> G = HeckeTriangleGroup(Integer(5)) >>> G.element_repr_method("default") >>> G.V(Integer(1)) [ 1 lam] [ 0 1] >>> G.V(Integer(2)) [lam lam] [ 1 lam] >>> G.V(Integer(3)) [lam 1] [lam lam] >>> G.V(Integer(4)) [ 1 0] [lam 1] >>> G.V(Integer(5)) == G.S() True 
 - alpha()[source]¶
- Return the parameter - alphaof- self.- This is the first parameter of the hypergeometric series used in the calculation of the Hauptmodul of - self.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(3).alpha() 1/12 sage: HeckeTriangleGroup(4).alpha() 1/8 sage: HeckeTriangleGroup(5).alpha() 3/20 sage: HeckeTriangleGroup(6).alpha() 1/6 sage: HeckeTriangleGroup(10).alpha() 1/5 sage: HeckeTriangleGroup(infinity).alpha() 1/4 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(3)).alpha() 1/12 >>> HeckeTriangleGroup(Integer(4)).alpha() 1/8 >>> HeckeTriangleGroup(Integer(5)).alpha() 3/20 >>> HeckeTriangleGroup(Integer(6)).alpha() 1/6 >>> HeckeTriangleGroup(Integer(10)).alpha() 1/5 >>> HeckeTriangleGroup(infinity).alpha() 1/4 
 - base_field()[source]¶
- Return the base field of - self.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(n=infinity).base_field() Rational Field sage: HeckeTriangleGroup(n=7).base_field() Number Field in lam with defining polynomial x^3 - x^2 - 2*x + 1 with lam = 1.801937735804839? - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(n=infinity).base_field() Rational Field >>> HeckeTriangleGroup(n=Integer(7)).base_field() Number Field in lam with defining polynomial x^3 - x^2 - 2*x + 1 with lam = 1.801937735804839? 
 - base_ring()[source]¶
- Return the base ring of - self.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(n=infinity).base_ring() Integer Ring sage: HeckeTriangleGroup(n=7).base_ring() Maximal Order generated by lam in Number Field in lam with defining polynomial x^3 - x^2 - 2*x + 1 with lam = 1.801937735804839? - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(n=infinity).base_ring() Integer Ring >>> HeckeTriangleGroup(n=Integer(7)).base_ring() Maximal Order generated by lam in Number Field in lam with defining polynomial x^3 - x^2 - 2*x + 1 with lam = 1.801937735804839? 
 - beta()[source]¶
- Return the parameter - betaof- self.- This is the second parameter of the hypergeometric series used in the calculation of the Hauptmodul of - self.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(3).beta() 5/12 sage: HeckeTriangleGroup(4).beta() 3/8 sage: HeckeTriangleGroup(5).beta() 7/20 sage: HeckeTriangleGroup(6).beta() 1/3 sage: HeckeTriangleGroup(10).beta() 3/10 sage: HeckeTriangleGroup(infinity).beta() 1/4 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(3)).beta() 5/12 >>> HeckeTriangleGroup(Integer(4)).beta() 3/8 >>> HeckeTriangleGroup(Integer(5)).beta() 7/20 >>> HeckeTriangleGroup(Integer(6)).beta() 1/3 >>> HeckeTriangleGroup(Integer(10)).beta() 3/10 >>> HeckeTriangleGroup(infinity).beta() 1/4 
 - class_number(D, primitive=True)[source]¶
- Return the class number of - selffor the discriminant- D.- This is the number of conjugacy classes of (primitive) elements of discriminant - D.- Note: Due to the 1-1 correspondence with hyperbolic fixed points resp. hyperbolic binary quadratic forms this also gives the class number in those cases. - INPUT: - D– an element of the base ring corresponding to a valid discriminant
- primitive– if- True(default) then only primitive elements are considered
 - EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=4) sage: G.class_number(4) 1 sage: G.class_number(4, primitive=False) 1 sage: G.class_number(14) 2 sage: G.class_number(32) 2 sage: G.class_number(32, primitive=False) 3 sage: G.class_number(68) 4 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(n=Integer(4)) >>> G.class_number(Integer(4)) 1 >>> G.class_number(Integer(4), primitive=False) 1 >>> G.class_number(Integer(14)) 2 >>> G.class_number(Integer(32)) 2 >>> G.class_number(Integer(32), primitive=False) 3 >>> G.class_number(Integer(68)) 4 
 - class_representatives(D, primitive=True)[source]¶
- Return a representative for each conjugacy class for the discriminant - D(ignoring the sign).- If - primitive=Trueonly one representative for each fixed point is returned (ignoring sign).- INPUT: - D– an element of the base ring corresponding to a valid discriminant
- primitive– if- True(default) then only primitive representatives are considered
 - EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=4) sage: G.element_repr_method("conj") sage: R = G.class_representatives(4) sage: R [[V(2)]] sage: [v.continued_fraction()[1] for v in R] [(2,)] sage: R = G.class_representatives(0) sage: R [[V(3)]] sage: [v.continued_fraction()[1] for v in R] [(1, 2)] sage: R = G.class_representatives(-4) sage: R [[S]] sage: R = G.class_representatives(-4, primitive=False) sage: R [[S], [U^2]] sage: R = G.class_representatives(G.lam()^2 - 4) sage: R [[U]] sage: R = G.class_representatives(G.lam()^2 - 4, primitive=False) sage: R [[U], [U^(-1)]] sage: R = G.class_representatives(14) sage: sorted(R) [[V(2)*V(3)], [V(1)*V(2)]] sage: sorted(v.continued_fraction()[1] for v in R) [(1, 2, 2), (3,)] sage: R = G.class_representatives(32) sage: sorted(R) [[V(3)^2*V(1)], [V(1)^2*V(3)]] sage: [v.continued_fraction()[1] for v in sorted(R)] [(1, 2, 1, 3), (1, 4)] sage: R = G.class_representatives(32, primitive=False) sage: sorted(R) [[V(3)^2*V(1)], [V(1)^2*V(3)], [V(2)^2]] sage: G.element_repr_method("default") - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(n=Integer(4)) >>> G.element_repr_method("conj") >>> R = G.class_representatives(Integer(4)) >>> R [[V(2)]] >>> [v.continued_fraction()[Integer(1)] for v in R] [(2,)] >>> R = G.class_representatives(Integer(0)) >>> R [[V(3)]] >>> [v.continued_fraction()[Integer(1)] for v in R] [(1, 2)] >>> R = G.class_representatives(-Integer(4)) >>> R [[S]] >>> R = G.class_representatives(-Integer(4), primitive=False) >>> R [[S], [U^2]] >>> R = G.class_representatives(G.lam()**Integer(2) - Integer(4)) >>> R [[U]] >>> R = G.class_representatives(G.lam()**Integer(2) - Integer(4), primitive=False) >>> R [[U], [U^(-1)]] >>> R = G.class_representatives(Integer(14)) >>> sorted(R) [[V(2)*V(3)], [V(1)*V(2)]] >>> sorted(v.continued_fraction()[Integer(1)] for v in R) [(1, 2, 2), (3,)] >>> R = G.class_representatives(Integer(32)) >>> sorted(R) [[V(3)^2*V(1)], [V(1)^2*V(3)]] >>> [v.continued_fraction()[Integer(1)] for v in sorted(R)] [(1, 2, 1, 3), (1, 4)] >>> R = G.class_representatives(Integer(32), primitive=False) >>> sorted(R) [[V(3)^2*V(1)], [V(1)^2*V(3)], [V(2)^2]] >>> G.element_repr_method("default") 
 - dvalue()[source]¶
- Return a symbolic expression (or an exact value in case n=3, 4, 6) for the transfinite diameter (or capacity) of - self.- This is the first nontrivial Fourier coefficient of the Hauptmodul for the Hecke triangle group in case it is normalized to - J_inv(i)=1.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(3).dvalue() 1/1728 sage: HeckeTriangleGroup(4).dvalue() 1/256 sage: HeckeTriangleGroup(5).dvalue() e^(2*euler_gamma - 4*pi/(sqrt(5) + 1) + psi(17/20) + psi(13/20)) sage: HeckeTriangleGroup(6).dvalue() 1/108 sage: HeckeTriangleGroup(10).dvalue() e^(2*euler_gamma - 4*pi/sqrt(2*sqrt(5) + 10) + psi(4/5) + psi(7/10)) sage: HeckeTriangleGroup(infinity).dvalue() 1/64 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(3)).dvalue() 1/1728 >>> HeckeTriangleGroup(Integer(4)).dvalue() 1/256 >>> HeckeTriangleGroup(Integer(5)).dvalue() e^(2*euler_gamma - 4*pi/(sqrt(5) + 1) + psi(17/20) + psi(13/20)) >>> HeckeTriangleGroup(Integer(6)).dvalue() 1/108 >>> HeckeTriangleGroup(Integer(10)).dvalue() e^(2*euler_gamma - 4*pi/sqrt(2*sqrt(5) + 10) + psi(4/5) + psi(7/10)) >>> HeckeTriangleGroup(infinity).dvalue() 1/64 
 - element_repr_method(method=None)[source]¶
- Either return or set the representation method for elements of - self.- INPUT: - method– if- method=None(default) the current default representation method is returned. Otherwise the default method is set to- method. If- methodis not available a- ValueErroris raised. Possible methods are:- default: use the usual representation method for matrix group elements
- basic: the representation is given as a word in- Sand powers of- T
- conj: the conjugacy representative of the element is represented as a word in powers of the basic blocks, together with an unspecified conjugation matrix
- block: same as- conjbut the conjugation matrix is specified as well
 
 - EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(5) sage: G.element_repr_method() 'default' sage: G.element_repr_method("basic") sage: G.element_repr_method() 'basic' - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(Integer(5)) >>> G.element_repr_method() 'default' >>> G.element_repr_method("basic") >>> G.element_repr_method() 'basic' 
 - get_FD(z)[source]¶
- Return a tuple (A,w) which determines how to map - zto the usual (strict) fundamental domain of- self.- INPUT: - z– a complex number or an element of AlgebraicField()
 - OUTPUT: - A tuple - (A, w).- A– a matrix in- selfsuch that- A.acton(w)==z(if- zis exact at least)
- w– a complex number or an element of AlgebraicField() (depending on the type- z) which lies inside the (strict) fundamental domain of- self(- self.in_FD(w)==True) and which is equivalent to- z(by the above property)
 - EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(8) sage: z = AlgebraicField()(1+i/2) sage: (A, w) = G.get_FD(z) sage: A [-lam 1] [ -1 0] sage: A.acton(w) == z True sage: from sage.modular.modform_hecketriangle.space import ModularForms sage: z = (134.12 + 0.22*i).n() sage: (A, w) = G.get_FD(z) sage: A [-73*lam^3 + 74*lam 73*lam^2 - 1] [ -lam^2 + 1 lam] sage: w 0.769070776942... + 0.779859114103...*I sage: z 134.120000000... + 0.220000000000...*I sage: A.acton(w) 134.1200000... + 0.2200000000...*I - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(Integer(8)) >>> z = AlgebraicField()(Integer(1)+i/Integer(2)) >>> (A, w) = G.get_FD(z) >>> A [-lam 1] [ -1 0] >>> A.acton(w) == z True >>> from sage.modular.modform_hecketriangle.space import ModularForms >>> z = (RealNumber('134.12') + RealNumber('0.22')*i).n() >>> (A, w) = G.get_FD(z) >>> A [-73*lam^3 + 74*lam 73*lam^2 - 1] [ -lam^2 + 1 lam] >>> w 0.769070776942... + 0.779859114103...*I >>> z 134.120000000... + 0.220000000000...*I >>> A.acton(w) 134.1200000... + 0.2200000000...*I 
 - in_FD(z)[source]¶
- Return - Trueif- zlies in the (strict) fundamental domain of- self.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(5).in_FD(CC(1.5/2 + 0.9*i)) True sage: HeckeTriangleGroup(4).in_FD(CC(1.5/2 + 0.9*i)) False - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(5)).in_FD(CC(RealNumber('1.5')/Integer(2) + RealNumber('0.9')*i)) True >>> HeckeTriangleGroup(Integer(4)).in_FD(CC(RealNumber('1.5')/Integer(2) + RealNumber('0.9')*i)) False 
 - is_arithmetic()[source]¶
- Return - Trueif- selfis an arithmetic subgroup.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(3).is_arithmetic() True sage: HeckeTriangleGroup(4).is_arithmetic() True sage: HeckeTriangleGroup(5).is_arithmetic() False sage: HeckeTriangleGroup(6).is_arithmetic() True sage: HeckeTriangleGroup(10).is_arithmetic() False sage: HeckeTriangleGroup(infinity).is_arithmetic() True - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(3)).is_arithmetic() True >>> HeckeTriangleGroup(Integer(4)).is_arithmetic() True >>> HeckeTriangleGroup(Integer(5)).is_arithmetic() False >>> HeckeTriangleGroup(Integer(6)).is_arithmetic() True >>> HeckeTriangleGroup(Integer(10)).is_arithmetic() False >>> HeckeTriangleGroup(infinity).is_arithmetic() True 
 - is_discriminant(D, primitive=True)[source]¶
- Return whether - Dis a discriminant of an element of- self.- Note: Checking that something isn’t a discriminant takes much longer than checking for valid discriminants. - INPUT: - D– an element of the base ring
- primitive– if- True(default) then only primitive elements are considered
 - OUTPUT: - Trueif- Dis a primitive discriminant (a discriminant of a primitive element) and- Falseotherwise. If- primitive=Falsethen also non-primitive elements are considered.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=4) sage: G.is_discriminant(68) True sage: G.is_discriminant(196, primitive=False) # long time True sage: G.is_discriminant(2) False - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(n=Integer(4)) >>> G.is_discriminant(Integer(68)) True >>> G.is_discriminant(Integer(196), primitive=False) # long time True >>> G.is_discriminant(Integer(2)) False 
 - lam()[source]¶
- Return the parameter - lambdaof- self, where- lambdais twice the real part of- rho, lying between- 1(when- n=3) and- 2(when- n=infinity).- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(3).lam() 1 sage: HeckeTriangleGroup(4).lam() lam sage: HeckeTriangleGroup(4).lam()^2 2 sage: HeckeTriangleGroup(6).lam()^2 3 sage: AA(HeckeTriangleGroup(10).lam()) 1.9021130325903...? sage: HeckeTriangleGroup(infinity).lam() 2 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(3)).lam() 1 >>> HeckeTriangleGroup(Integer(4)).lam() lam >>> HeckeTriangleGroup(Integer(4)).lam()**Integer(2) 2 >>> HeckeTriangleGroup(Integer(6)).lam()**Integer(2) 3 >>> AA(HeckeTriangleGroup(Integer(10)).lam()) 1.9021130325903...? >>> HeckeTriangleGroup(infinity).lam() 2 
 - lam_minpoly()[source]¶
- Return the minimal polynomial of the corresponding lambda parameter of - self.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(10).lam_minpoly() x^4 - 5*x^2 + 5 sage: HeckeTriangleGroup(17).lam_minpoly() x^8 - x^7 - 7*x^6 + 6*x^5 + 15*x^4 - 10*x^3 - 10*x^2 + 4*x + 1 sage: HeckeTriangleGroup(infinity).lam_minpoly() x - 2 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(10)).lam_minpoly() x^4 - 5*x^2 + 5 >>> HeckeTriangleGroup(Integer(17)).lam_minpoly() x^8 - x^7 - 7*x^6 + 6*x^5 + 15*x^4 - 10*x^3 - 10*x^2 + 4*x + 1 >>> HeckeTriangleGroup(infinity).lam_minpoly() x - 2 
 - list_discriminants(D, primitive=True, hyperbolic=True, incomplete=False)[source]¶
- Return a list of all discriminants up to some upper bound - D.- INPUT: - D– an element/discriminant of the base ring or more generally an upper bound for the discriminant
- primitive– if- True(default) then only primitive discriminants are listed
- hyperbolic– if- True(default) then only positive discriminants are listed
- incomplete– if- True(default:- False) then all (also higher) discriminants which were gathered so far are listed (however there might be missing discriminants in between).
 - OUTPUT: list of discriminants less than or equal to - D- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=4) sage: G.list_discriminants(D=68) [4, 12, 14, 28, 32, 46, 60, 68] sage: G.list_discriminants(D=0, hyperbolic=False, primitive=False) [-4, -2, 0] sage: G = HeckeTriangleGroup(n=5) sage: G.list_discriminants(D=20) [4*lam, 7*lam + 6, 9*lam + 5] sage: G.list_discriminants(D=0, hyperbolic=False, primitive=False) [-4, -lam - 2, lam - 3, 0] - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(n=Integer(4)) >>> G.list_discriminants(D=Integer(68)) [4, 12, 14, 28, 32, 46, 60, 68] >>> G.list_discriminants(D=Integer(0), hyperbolic=False, primitive=False) [-4, -2, 0] >>> G = HeckeTriangleGroup(n=Integer(5)) >>> G.list_discriminants(D=Integer(20)) [4*lam, 7*lam + 6, 9*lam + 5] >>> G.list_discriminants(D=Integer(0), hyperbolic=False, primitive=False) [-4, -lam - 2, lam - 3, 0] 
 - n()[source]¶
- Return the parameter - nof- self, where- pi/nis the angle at- rhoof the corresponding basic hyperbolic triangle with vertices- i,- rhoand- infinity.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(10).n() 10 sage: HeckeTriangleGroup(infinity).n() +Infinity - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(10)).n() 10 >>> HeckeTriangleGroup(infinity).n() +Infinity 
 - one()[source]¶
- Return the identity element/matrix for - self.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(10) sage: G(1) == G.one() True sage: G(1) [1 0] [0 1] sage: G(1).parent() Hecke triangle group for n = 10 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(Integer(10)) >>> G(Integer(1)) == G.one() True >>> G(Integer(1)) [1 0] [0 1] >>> G(Integer(1)).parent() Hecke triangle group for n = 10 
 - rational_period_functions(k, D)[source]¶
- Return a list of basic rational period functions of weight - kfor discriminant- D.- The list is expected to be a generating set for all rational period functions of the given weight and discriminant (unknown). - The method assumes that - D > 0.- Also see the element method - rational_period_functionfor more information.- k– even integer, the desired weight of the rational period functions
- D– an element of the base ring corresponding to a valid discriminant
 - EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=4) sage: sorted(G.rational_period_functions(k=4, D=12)) [(z^4 - 1)/z^4] sage: sorted(G.rational_period_functions(k=-2, D=12)) [-z^2 + 1, 4*lam*z^2 - 4*lam] sage: sorted(G.rational_period_functions(k=2, D=14)) [(24*z^6 - 120*z^4 + 120*z^2 - 24)/(9*z^8 - 80*z^6 + 146*z^4 - 80*z^2 + 9), (24*z^6 - 120*z^4 + 120*z^2 - 24)/(9*z^8 - 80*z^6 + 146*z^4 - 80*z^2 + 9), 1/z, (z^2 - 1)/z^2] sage: sorted(G.rational_period_functions(k=-4, D=14)) [-16*z^4 + 16, -z^4 + 1, 16*z^4 - 16] - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(n=Integer(4)) >>> sorted(G.rational_period_functions(k=Integer(4), D=Integer(12))) [(z^4 - 1)/z^4] >>> sorted(G.rational_period_functions(k=-Integer(2), D=Integer(12))) [-z^2 + 1, 4*lam*z^2 - 4*lam] >>> sorted(G.rational_period_functions(k=Integer(2), D=Integer(14))) [(24*z^6 - 120*z^4 + 120*z^2 - 24)/(9*z^8 - 80*z^6 + 146*z^4 - 80*z^2 + 9), (24*z^6 - 120*z^4 + 120*z^2 - 24)/(9*z^8 - 80*z^6 + 146*z^4 - 80*z^2 + 9), 1/z, (z^2 - 1)/z^2] >>> sorted(G.rational_period_functions(k=-Integer(4), D=Integer(14))) [-16*z^4 + 16, -z^4 + 1, 16*z^4 - 16] 
 - reduced_elements(D)[source]¶
- Return all reduced (primitive) elements of discriminant - D.- Also see the element method - is_reduced()for more information.- D– an element of the base ring corresponding to a valid discriminant
 - EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=4) sage: R = G.reduced_elements(D=12) sage: R [ [ 5 -lam] [ 5 -3*lam] [3*lam -1], [ lam -1] ] sage: [v.continued_fraction() for v in R] [((), (1, 3)), ((), (3, 1))] sage: R = G.reduced_elements(D=14) sage: sorted(R) [ [3*lam -1] [4*lam -3] [ 5*lam -7] [ 5*lam -3] [ 1 0], [ 3 -lam], [ 3 -2*lam], [ 7 -2*lam] ] sage: sorted(v.continued_fraction() for v in R) [((), (1, 2, 2)), ((), (2, 1, 2)), ((), (2, 2, 1)), ((), (3,))] - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(n=Integer(4)) >>> R = G.reduced_elements(D=Integer(12)) >>> R [ [ 5 -lam] [ 5 -3*lam] [3*lam -1], [ lam -1] ] >>> [v.continued_fraction() for v in R] [((), (1, 3)), ((), (3, 1))] >>> R = G.reduced_elements(D=Integer(14)) >>> sorted(R) [ [3*lam -1] [4*lam -3] [ 5*lam -7] [ 5*lam -3] [ 1 0], [ 3 -lam], [ 3 -2*lam], [ 7 -2*lam] ] >>> sorted(v.continued_fraction() for v in R) [((), (1, 2, 2)), ((), (2, 1, 2)), ((), (2, 2, 1)), ((), (3,))] 
 - rho()[source]¶
- Return the vertex - rhoof the basic hyperbolic triangle which describes- self.- rhohas absolute value 1 and angle- pi/n.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: HeckeTriangleGroup(3).rho() == QQbar(1/2 + sqrt(3)/2*i) True sage: HeckeTriangleGroup(4).rho() == QQbar(sqrt(2)/2*(1 + i)) True sage: HeckeTriangleGroup(6).rho() == QQbar(sqrt(3)/2 + 1/2*i) True sage: HeckeTriangleGroup(10).rho() 0.95105651629515...? + 0.30901699437494...?*I sage: HeckeTriangleGroup(infinity).rho() 1 - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> HeckeTriangleGroup(Integer(3)).rho() == QQbar(Integer(1)/Integer(2) + sqrt(Integer(3))/Integer(2)*i) True >>> HeckeTriangleGroup(Integer(4)).rho() == QQbar(sqrt(Integer(2))/Integer(2)*(Integer(1) + i)) True >>> HeckeTriangleGroup(Integer(6)).rho() == QQbar(sqrt(Integer(3))/Integer(2) + Integer(1)/Integer(2)*i) True >>> HeckeTriangleGroup(Integer(10)).rho() 0.95105651629515...? + 0.30901699437494...?*I >>> HeckeTriangleGroup(infinity).rho() 1 
 - root_extension_embedding(D, K=None)[source]¶
- Return the correct embedding from the root extension field of the given discriminant - Dto the field- K.- Also see the method - root_extension_embedding(K)of- HeckeTriangleGroupElementfor more examples.- INPUT: - D– an element of the base ring of- selfcorresponding to a discriminant
- K– a field to which we want the (correct) embedding; if- K=None(default) then- AlgebraicField()is used for positive- Dand- AlgebraicRealField()otherwise
 - OUTPUT: - The corresponding embedding if it was found. Otherwise a - ValueErroris raised.- EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=infinity) sage: G.root_extension_embedding(32) Ring morphism: From: Number Field in e with defining polynomial x^2 - 32 To: Algebraic Real Field Defn: e |--> 5.656854249492...? sage: G.root_extension_embedding(-4) Ring morphism: From: Number Field in e with defining polynomial x^2 + 4 To: Algebraic Field Defn: e |--> 2*I sage: G.root_extension_embedding(4) Coercion map: From: Rational Field To: Algebraic Real Field sage: G = HeckeTriangleGroup(n=7) sage: lam = G.lam() sage: D = 4*lam^2 + 4*lam - 4 sage: G.root_extension_embedding(D, CC) Relative number field morphism: From: Number Field in e with defining polynomial x^2 - 4*lam^2 - 4*lam + 4 over its base field To: Complex Field with 53 bits of precision Defn: e |--> 4.02438434522... lam |--> 1.80193773580... sage: D = lam^2 - 4 sage: G.root_extension_embedding(D) Relative number field morphism: From: Number Field in e with defining polynomial x^2 - lam^2 + 4 over its base field To: Algebraic Field Defn: e |--> 0.?... + 0.867767478235...?*I lam |--> 1.801937735804...? - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(n=infinity) >>> G.root_extension_embedding(Integer(32)) Ring morphism: From: Number Field in e with defining polynomial x^2 - 32 To: Algebraic Real Field Defn: e |--> 5.656854249492...? >>> G.root_extension_embedding(-Integer(4)) Ring morphism: From: Number Field in e with defining polynomial x^2 + 4 To: Algebraic Field Defn: e |--> 2*I >>> G.root_extension_embedding(Integer(4)) Coercion map: From: Rational Field To: Algebraic Real Field >>> G = HeckeTriangleGroup(n=Integer(7)) >>> lam = G.lam() >>> D = Integer(4)*lam**Integer(2) + Integer(4)*lam - Integer(4) >>> G.root_extension_embedding(D, CC) Relative number field morphism: From: Number Field in e with defining polynomial x^2 - 4*lam^2 - 4*lam + 4 over its base field To: Complex Field with 53 bits of precision Defn: e |--> 4.02438434522... lam |--> 1.80193773580... >>> D = lam**Integer(2) - Integer(4) >>> G.root_extension_embedding(D) Relative number field morphism: From: Number Field in e with defining polynomial x^2 - lam^2 + 4 over its base field To: Algebraic Field Defn: e |--> 0.?... + 0.867767478235...?*I lam |--> 1.801937735804...? 
 - root_extension_field(D)[source]¶
- Return the quadratic extension field of the base field by the square root of the given discriminant - D.- INPUT: - D– an element of the base ring of- selfcorresponding to a discriminant
 - OUTPUT: - A relative (at most quadratic) extension to the base field of - selfin the variable- ewhich corresponds to- sqrt(D). If the extension degree is- 1then 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.root_extension_field(32) Number Field in e with defining polynomial x^2 - 32 sage: G.root_extension_field(-4) Number Field in e with defining polynomial x^2 + 4 sage: G.root_extension_field(4) == G.base_field() True sage: G = HeckeTriangleGroup(n=7) sage: lam = G.lam() sage: D = 4*lam^2 + 4*lam - 4 sage: G.root_extension_field(D) Number Field in e with defining polynomial x^2 - 4*lam^2 - 4*lam + 4 over its base field sage: G.root_extension_field(4) == G.base_field() True sage: D = lam^2 - 4 sage: G.root_extension_field(D) Number Field in e with defining polynomial x^2 - lam^2 + 4 over its base field - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(n=infinity) >>> G.root_extension_field(Integer(32)) Number Field in e with defining polynomial x^2 - 32 >>> G.root_extension_field(-Integer(4)) Number Field in e with defining polynomial x^2 + 4 >>> G.root_extension_field(Integer(4)) == G.base_field() True >>> G = HeckeTriangleGroup(n=Integer(7)) >>> lam = G.lam() >>> D = Integer(4)*lam**Integer(2) + Integer(4)*lam - Integer(4) >>> G.root_extension_field(D) Number Field in e with defining polynomial x^2 - 4*lam^2 - 4*lam + 4 over its base field >>> G.root_extension_field(Integer(4)) == G.base_field() True >>> D = lam**Integer(2) - Integer(4) >>> G.root_extension_field(D) Number Field in e with defining polynomial x^2 - lam^2 + 4 over its base field 
 - simple_elements(D)[source]¶
- Return all simple elements of discriminant - D.- Also see the element method - is_simple()for more information.- D– an element of the base ring corresponding to a valid discriminant
 - EXAMPLES: - sage: from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup sage: G = HeckeTriangleGroup(n=4) sage: sorted(G.simple_elements(D=12)) [ [ 1 lam] [ 3 lam] [lam 3], [lam 1] ] sage: sorted(G.simple_elements(D=14)) [ [ lam 1] [ lam 3] [2*lam 1] [2*lam 3] [ 3 2*lam], [ 1 2*lam], [ 3 lam], [ 1 lam] ] - >>> from sage.all import * >>> from sage.modular.modform_hecketriangle.hecke_triangle_groups import HeckeTriangleGroup >>> G = HeckeTriangleGroup(n=Integer(4)) >>> sorted(G.simple_elements(D=Integer(12))) [ [ 1 lam] [ 3 lam] [lam 3], [lam 1] ] >>> sorted(G.simple_elements(D=Integer(14))) [ [ lam 1] [ lam 3] [2*lam 1] [2*lam 3] [ 3 2*lam], [ 1 2*lam], [ 3 lam], [ 1 lam] ]