For representing finite-index subgroups of \({\rm SL}_2(ℤ)\), this package introduces the new object ModularSubgroup. As stated in the introduction, a ModularSubgroup essentially consists of the two permutations \(\sigma_S\) and \(\sigma_T\) describing the coset graph with respect to the generators \(S\) and \(T\) (with the convention that \(1\) corresponds to the identity coset). So explicitly specifying these permutations is the canonical way to construct a ModularSubgroup.
Though you might not always have a coset graph of your subgroup at hand, but rather a list of generating matrices. Therefore we implement multiple constructors for ModularSubgroup: three that take as input two permutations describing the coset graph with respect to different pairs of generators of \({\rm SL}_2(ℤ)\), and one that takes a list of \({\rm SL}_2(ℤ)\) matrices as generators.
‣ ModularSubgroupViaRightAction( s, t ) | ( operation ) |
Returns: A modular subgroup.
Constructs a ModularSubgroup object corresponding to the finite-index subgroup of \({\rm SL}_2(ℤ)\) described by the permutations s and t.
This constructor tests if the given permutations actually describe the coset action of the matrices
\[ S = \left( \begin{array}{rr} 0 & -1 \\ 1 & 0 \end{array} \right) \quad T = \left( \begin{array}{rr} 1 & 1 \\ 0 & 1 \end{array} \right) \]
by checking that they act transitively and satisfy the relations
\[s^4 = (s^3 t)^3 = s^2 t s^{-2} t^{-1} = 1\]
Upon creation, the cosets are renamed in a standardized way to make the internal interaction with existing GAP methods easier. (The fact that \(1\) corresponds to the identity coset is not changed by this)
gap> G := ModularSubgroupViaRightAction( > (1,2)(3,4)(5,6)(7,8)(9,10), > (1,4)(2,5,9,10,8)(3,7,6)); <modular subgroup of index 10>
‣ ModularSubgroupViaLeftAction( s, t ) | ( operation ) |
Returns: A modular subgroup.
Analogous to ModularSubgroupViaRightAction, but with left coset actions.
‣ ModularSubgroupSTViaRightAction( s, t ) | ( operation ) |
Returns: A modular subgroup.
Synonymous for ModularSubgroupViaRightAction (2.1-1) (see above).
‣ ModularSubgroupSTViaLeftAction( s, t ) | ( operation ) |
Returns: A modular subgroup.
Synonymous for ModularSubgroupViaLeftAction (2.1-1) (see above).
‣ ModularSubgroupRTViaRightAction( r, t ) | ( operation ) |
Returns: A modular subgroup.
Constructs a ModularSubgroup object corresponding to the finite-index subgroup of \({\rm SL}_2(ℤ)\) determined by the permutations r and t which describe the action of the matrices
\[ R = \left( \begin{array}{rr} 1 & 0 \\ 1 & 1 \end{array} \right) \quad T = \left( \begin{array}{rr} 1 & 1 \\ 0 & 1 \end{array} \right) \]
on the right cosets.
A check is performed if the permutations actually describe such an action on the cosets of some subgroup.
Upon creation, the cosets are renamed in a standardized way to make the internal interaction with existing GAP methods easier. (The fact that \(1\) corresponds to the identity coset is not changed by this)
gap> G := ModularSubgroupRTViaRightAction( > (1,9,8,10,7)(2,6)(3,4,5), > (1,3)(2,4,8,10,5)(6,9,7)); <modular subgroup of index 10>
‣ ModularSubgroupRTViaLeftAction( r, t ) | ( operation ) |
Returns: A modular subgroup.
Analogous to ModularSubgroupRTViaRightAction, but with left coset actions.
‣ ModularSubgroupSJViaRightAction( s, j ) | ( operation ) |
Returns: A modular subgroup.
Constructs a ModularSubgroup object corresponding to the finite-index subgroup of \({\rm SL}_2(ℤ)\) determined by the permutations s and j which describe the action of the matrices
\[ S = \left( \begin{array}{rr} 0 & -1 \\ 1 & 0 \end{array} \right) \quad J = \left( \begin{array}{rr} 0 & 1 \\ -1 & 1 \end{array} \right) \]
on the right cosets.
A check is performed if the permutations actually describe such an action on the cosets of some subgroup.
Upon creation, the cosets are renamed in a standardized way to make the internal interaction with existing GAP methods easier. (The fact that \(1\) corresponds to the identity coset is not changed by this)
gap> G := ModularSubgroupSJViaRightAction( > (1,2)(3,6)(4,7)(5,9)(8,10), > (1,5,6)(2,3,7)(4,9,10)); <modular subgroup of index 10>
‣ ModularSubgrouSJViaLeftAction( s, j ) | ( operation ) |
Returns: A modular subgroup.
Analogous to ModularSubgroupSJViaRightAction, but with left coset actions.
‣ ModularSubgroup( gens ) | ( operation ) |
Returns: A modular subgroup.
Constructs a ModularSubgroup object corresponding to the finite-index subgroup of \({\rm SL}_2(ℤ)\) generated by the matrices in gens.
No test is performed to check if the generated subgroup actually has finite index!
This constructor implicitly computes a coset table of the subgroup. Hence it might be slow for very large index subgroups.
gap> G := ModularSubgroup([ > [[1,2], [0,1]], > [[1,0], [2,1]], > [[-1,0], [0,-1]] > ]); <modular subgroup of index 6>
‣ SRightAction( G ) | ( operation ) |
Returns: A permutation.
Returns the permutation \(\sigma_S\) describing the action of the matrix \(S\) on the right cosets of G.
‣ SLeftAction( G ) | ( operation ) |
Returns: A permutation.
Analogous to SRightAction, but with left coset actions.
‣ TRightAction( G ) | ( operation ) |
Returns: A permutation.
Returns the permutation \(\sigma_T\) describing the action of the matrix \(T\) on the right cosets of G.
‣ TLeftAction( G ) | ( operation ) |
Returns: A permutation.
Analogous to TRightAction, but with left coset actions.
‣ RRightAction( G ) | ( operation ) |
Returns: A permutation.
Returns the permutation \(\sigma_R\) describing the action of the matrix \(R\) on the right cosets of G.
‣ RLeftAction( G ) | ( operation ) |
Returns: A permutation.
Analogous to RRightAction, but with left coset actions.
‣ JRightAction( G ) | ( operation ) |
Returns: A permutation.
Returns the permutation \(\sigma_J\) describing the action of the matrix \(J\) on the right cosets of G.
‣ JLeftAction( G ) | ( operation ) |
Returns: A permutation.
Analogous to JRightAction, but with left coset actions.
‣ CosetRightActionOf( A, G ) | ( operation ) |
Returns: A permutation.
Returns the permutation \(\sigma_A\) describing the action of the matrix \(A \in {\rm SL}_2(ℤ)\) on the right cosets of G.
‣ CosetLeftActionOf( A, G ) | ( operation ) |
Returns: A permutation.
Analogous to CosetRightActionOf, but with left coset actions.
‣ Index( G ) | ( attribute ) |
Returns: A natural number.
For a given modular subgroup G this method returns its index in \({\rm SL}_2(ℤ)\). As G is internally stored as permutations \((s,t)\) this is just LargestMovedPoint([s,t]) (or \(1\) if the permutations are trivial).
gap> G := ModularSubgroup((1,2)(3,5)(4,6), (1,3)(2,4)(5,6)); <modular subgroup of index 6> gap> Index(G); 6
‣ GeneralizedLevel( G ) | ( attribute ) |
Returns: A natural number.
This method calculates the general Wohlfahrt level (i.e. the lowest common multiple of all cusp widths) of G as defined in [Woh64].
gap> G := ModularSubgroup((1,2)(3,5)(4,6), (1,3)(2,4)(5,6)); <modular subgroup of index 6> gap> GeneralizedLevel(G); 2
‣ RightCosetRepresentatives( G ) | ( attribute ) |
Returns: A list of words.
This function returns a list of representatives of the (right) cosets of G as words in \(S\) and \(T\).
gap> G := ModularSubgroup((1,2),(2,3)); <modular subgroup of index 3> gap> RightCosetRepresentatives(G); [ <identity ...>, S, S*T ]
‣ LeftCosetRepresentatives( G ) | ( attribute ) |
Returns: A list of words.
This function returns a list of representatives of the (left) cosets of G as words in \(S\) and \(T\).
‣ WordGeneratorsOfGroup( G ) | ( attribute ) |
Returns: A list of words.
Calculates a list of generators (as words in \(S\) and \(T\)) of G. This list might include redundant generators (or even duplicates).
gap> G := ModularSubgroup((1,2)(3,5)(4,6), (1,3)(2,4)(5,6)); <modular subgroup of index 6> gap> WordGeneratorsOfGroup(G); [ S^-2, T^-2, S*T^-2*S^-1 ]
‣ GeneratorsOfGroup( G ) | ( attribute ) |
Returns: A list of matrices.
Calculates a list of generator matrices of G. This list might include redundant generators (or even duplicates).
gap> G := ModularSubgroup((1,2)(3,5)(4,6), (1,3)(2,4)(5,6)); <modular subgroup of index 6> gap> GeneratorsOfGroup(G); [ [ [ -1, 0 ], [ 0, -1 ] ], [ [ 1, -2 ], [ 0, 1 ] ], [ [ 1, 0 ], [ 2, 1 ] ] ]
‣ IsCongruence( G ) | ( attribute ) |
Returns: True or false.
This method test whether a given modular subgroup G is a congruence subgroup. It is essentially an implementation of an algorithm described in [HL14].
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> IsCongruence(G); true
‣ Cusps( G ) | ( attribute ) |
Returns: A list of rational numbers and infinity.
This method computes a list of inequivalent cusp representatives with respect to G.
gap> G := ModularSubgroup( > (1,2)(3,6)(4,8)(5,9)(7,11)(10,13)(12,15)(14,17)(16,19)(18,21)(20,23)(22,24), > (1,3,7,4)(2,5)(6,9,8,12,14,10)(11,13,16,20,18,15)(17,21,22,19)(23,24) > ); <modular subgroup of index 24> gap> Cusps(G); [ infinity, 0, 1, 2, 3/2, 5/3 ]
‣ CuspWidth( c, G ) | ( operation ) |
Returns: A natural number.
This method takes as input a cusp c (a rational number or infinity) and a modular group G and calculates the width of this cusp with respect to G.
gap> G := ModularSubgroup( > (1,2,6,3)(4,11,15,12)(5,13,16,14)(7,17,9,18)(8,19,10,20)(21,24,22,23), > (1,4,5)(2,7,8)(3,9,10)(6,15,16)(11,20,21)(12,19,22)(13,23,17)(14,24,18) > ); <modular subgroup of index 24> gap> CuspWidth(-1, G); 3 gap> CuspWidth(infinity, G); 3
‣ CuspsEquivalent( p, q, G ) | ( operation ) |
Returns: True or false.
Takes two cusps p and q and a modular subgroup G and checks if they are equivalent modulo G, i.e. if there exists a matrix \(A \in G\) with \(Ap = q\).
gap> G := ModularSubgroup( > (1,2,6,3)(4,11,15,12)(5,13,16,14)(7,17,9,18)(8,19,10,20)(21,24,22,23), > (1,4,5)(2,7,8)(3,9,10)(6,15,16)(11,20,21)(12,19,22)(13,23,17)(14,24,18) > ); <modular subgroup of index 24> gap> CuspsEquivalent(infinity, 1, G); false gap> CuspsEquivalent(-1, 1/2, G); true
‣ CosetRepresentativeOfCusp( c, G ) | ( operation ) |
Returns: A word in S and T.
For a cusp c this function returns a right coset representative \(A\) of G such that \(A \infty \) and c are equivalent with respect to G.
gap> G := ModularSubgroup( > (1,2,6,3)(4,11,15,12)(5,13,16,14)(7,17,9,18)(8,19,10,20)(21,24,22,23), > (1,4,5)(2,7,8)(3,9,10)(6,15,16)(11,20,21)(12,19,22)(13,23,17)(14,24,18) > ); <modular subgroup of index 24> gap> CosetRepresentativeOfCusp(4, G); T*S
‣ IndexModN( G, N ) | ( operation ) |
Returns: A natural number.
For a modular subgroup G and a natural number N this method calculates the index of the projection \(\bar{G}\) of \(G\) in \({\rm SL}_2(ℤ/Nℤ)\).
gap> G := ModularSubgroup((1,2)(3,5)(4,6), (1,3)(2,4)(5,6)); <modular subgroup of index 6> gap> IndexModN(G, 2); 6
‣ Deficiency( G, N ) | ( operation ) |
Returns: A natural number.
For a modular subgroup G and a natural number N this method calculates the so-called deficiency of G from being a congruence subgroup of level N.
The deficiency of a finite-index subgroup \(\Gamma\) of \({\rm SL}_2(ℤ)\) was introduced in [Wei15]. It is defined as the index \([\Gamma(N) \colon \Gamma(N) \cap \Gamma]\) where \(\Gamma(N)\) is the principal congruence subgroup of level \(N\).
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> Deficiency(G, 2); 2 gap> Deficiency(G, 4); 1
‣ Deficiency( G ) | ( attribute ) |
Returns: A natural number.
Shorthand for Deficiency(G, GeneralizedLevel(G)).
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> Deficiency(G); 1 gap> Deficiency(G, GeneralizedLevel(G)); 1
‣ Projectivization( G ) | ( operation ) |
Returns: A projective modular subgroup.
For a given modular subgroup G this function calculates its image \(\bar{\textit{G}}\) under the projection \(\pi \colon {\rm SL}_2(ℤ) \rightarrow {\rm PSL}_2(ℤ)\).
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> Projectivization(G); <projective modular subgroup of index 6>
‣ ConjugateGroup( G, A ) | ( operation ) |
Returns: A ModularSubgroup.
Conjugates the group G by the \({\rm SL}_2(ℤ)\) matrix A and returns the group \(A^{-1}*G*A\).
‣ NormalCore( G ) | ( attribute ) |
Returns: A modular subgroup.
Calculates the normal core of G in \({\rm SL}_2(ℤ)\), i.e. the maximal subgroup of G that is normal in \({\rm SL}_2(ℤ)\).
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> NormalCore(G); <modular subgroup of index 48>
‣ QuotientByNormalCore( G ) | ( attribute ) |
Returns: A finite group.
Calculates the quotient of \({\rm SL}_2(ℤ)\) by the normal core of G.
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> QuotientByNormalCore(G); <permutation group with 2 generators>
‣ AssociatedCharacterTable( G ) | ( attribute ) |
Returns: A character table.
Returns the character table of \({\rm SL}_2(ℤ)/N\) where \(N\) is the normal core of G.
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> AssociatedCharacterTable(G); CharacterTable( <permutation group of size 48 with 2 generators> )
‣ IsElementOf( A, G ) | ( operation ) |
Returns: True or false.
This function checks if a given matrix A is an element of the modular subgroup G.
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> IsElementOf([[-1,0],[0,-1]], G); false gap> IsElementOf([[1,4],[0,1]], G); true
‣ IsWordElementOf( s, G ) | ( operation ) |
Returns: True or false.
This function checks if a given string s represents an element of the modular subgroup G, written in the generators S and T.
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> IsWordElementOf("S^4 * T^2", G); true
‣ IsWordElementOf( w, G ) | ( operation ) |
Returns: True or false.
This function checks if a given word w in the generators S and T represents an element of the modular subgroup G.
gap> G := ModularSubgroup([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); <modular subgroup of index 12> gap> F := FreeGroup("S", "T"); <free group on the generators [ S, T ]> gap> S := F.1; S gap> T := F.2; T gap> SL2Z := F / ParseRelators([S, T], "S^4, (S^3*T)^3, S^2*T*S^-2*T^-1"); <fp group on the generators [ S, T ]> gap> S := GeneratorsOfGroup(SL2Z)[1]; S gap> T := GeneratorsOfGroup(SL2Z)[2]; T gap> IsWordElementOf(S^4 * T^2, G); true
‣ Genus( G ) | ( attribute ) |
Returns: A non-negative integer.
Computes the genus of the quotient \(G \setminus ℍ\) via an algorithm described in [Sch04].
gap> G := ModularSubgroup((1,2),(2,3)); <modular subgroup of index 3> gap> Genus(G); 0
The following functions are mostly helper functions used internally and are only documented for sake of completeness.
‣ DefinesCosetActionST( s, t ) | ( operation ) |
Returns: True or false.
Checks if two given permutations s and t describe the action of the generator matrices \(S\) and \(T\) on the cosets of some subgroup. This is the case if they satisfy the relations
\[s^4 = (s^3 t)^3 = s^2 t s^{-2} t^{-1} = 1\]
and act transitively.
gap> s := (1,2)(3,4)(5,6)(7,8)(9,10);; gap> t := (1,4)(2,5,9,10,8)(3,7,6);; gap> DefinesCosetActionST(s,t); true
‣ DefinesCosetActionRT( r, t ) | ( operation ) |
Returns: True or false.
Checks if two given permutations r and t describe the action of the generator matrices \(R\) and \(T\) on the cosets of some subgroup. This is the case if they satisfy the relations
\[(r t^{-1} r)^4 = ((r t^{-1} r)^3 t)^3 = (r t^{-1} r)^2 t (r t^{-1} r)^{-2} t^{-1} = 1\]
and act transitively.
gap> r := (1,9,8,10,7)(2,6)(3,4,5);; gap> t := (1,3)(2,4,8,10,5)(6,9,7);; gap> DefinesCosetActionRT(r,t); true
‣ DefinesCosetActionSJ( s, j ) | ( operation ) |
Returns: True or false.
Checks if two given permutations s and j describe the action of the generator matrices \(S\) and \(J\) on the cosets of some subgroup. This is the case if they satisfy the relations
\[s^4 = (s^3 j^{-1} s^{-1})^3 = s^2 j^{-1} s^{-2} j = 1\]
and act transitively.
gap> s := (1,2)(3,4)(5,6)(7,8)(9,10);; gap> j := (1,5,6)(2,3,7)(4,9,10);; gap> DefinesCosetActionSJ(s,j); true
‣ RightCosetActionFromGenerators( gens ) | ( operation ) |
Returns: A tuple of permutations.
Takes a list of generator matrices and calculates the right coset graph (as two permutations \(\sigma_S\) and \(\sigma_T\)) of the generated subgroup of \({\rm SL}_2(ℤ)\).
gap> RightCosetActionFromGenerators([ > [[1,2],[0,1]], > [[1,0],[2,1]] > ]); [ (1,2,5,3)(4,8,10,9)(6,11,7,12), (1,4)(2,6)(3,7)(5,10)(8,12,9,11) ]
‣ LeftCosetActionFromGenerators( gens ) | ( operation ) |
Returns: A tuple of permutations.
Analogous to RightCosetActionFromGenerators, but with left coset actions.
‣ STDecomposition( A ) | ( operation ) |
Returns: A word in \(S\) and \(T\).
Takes a matrix \(\textit{A} \in {\rm SL}_2(ℤ)\) and decomposes it into a word in the generator matrices \(S\) and \(T\).
gap> M := [ [ 4, 3 ], [ -3, -2 ] ];; gap> STDecomposition(M); S^2*T^-1*S^-1*T^2*S^-1*T^-1*S^-1
‣ RTDecomposition( A ) | ( operation ) |
Returns: A word in \(R\) and \(T\).
Takes a matrix \(\textit{A} \in {\rm SL}_2(ℤ)\) and decomposes it into a word in the generator matrices \(R\) and \(T\).
gap> M := [ [ 4, 3 ], [ -3, -2 ] ];; gap> RTDecomposition(M); (R*T^-1*R)^2*T^-1*R^-1*(T*R^-1*T)^2*R^-1*T^-1*R^-1*T*R^-1
‣ SJDecomposition( A ) | ( operation ) |
Returns: A word in \(S\) and \(J\).
Takes a matrix \(\textit{A} \in {\rm SL}_2(ℤ)\) and decomposes it into a word in the generator matrices \(S\) and \(J\).
gap> M := [ [ 4, 3 ], [ -3, -2 ] ];; gap> SJDecomposition(M); S^3*J*(S^-1*J^-1)^2*S^-1*J*S^-1
‣ STDecompositionAsList( A ) | ( operation ) |
Returns: A list representing a word in \(S\) and \(T\).
Takes a matrix \(\textit{A} \in {\rm SL}_2(ℤ)\) and decomposes it into a word in the generator matrices \(S\) and \(T\). The word is represented as a list in the format [[generator, exponent], ... ]
gap> M := [ [ 4, 3 ], [ -3, -2 ] ];; gap> STDecompositionAsList(M); [ [ "S", 2 ], [ "T", -1 ], [ "S", -1 ], [ "T", 2 ], [ "S", -1 ], [ "T", -1 ], [ "S", -1 ], [ "T", 0 ] ]
generated by GAPDoc2HTML