congruence-1.2.3/PackageInfo.g 0000664 0003717 0003717 00000011365 13503171577 017415 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W PackageInfo.g The Congruence package Ann Dooms
#W Eric Jespers
#W Alexander Konovalov
#W Helena Verrill
##
##
#############################################################################
SetPackageInfo( rec(
PackageName := "Congruence",
Subtitle := "Congruence subgroups of SL(2,Integers)",
Version := "1.2.3",
Date := "19/05/2019", # dd/mm/yyyy format
License := "GPL-2.0-or-later",
## <#GAPDoc Label="PKGVERSIONDATA">
##
##
##
## <#/GAPDoc>
SourceRepository := rec(
Type := "git",
URL := Concatenation( "https://github.com/gap-packages/", LowercaseString(~.PackageName) ),
),
IssueTrackerURL := Concatenation( ~.SourceRepository.URL, "/issues" ),
PackageWWWHome := Concatenation( "https://gap-packages.github.io/", LowercaseString(~.PackageName) ),
README_URL := Concatenation( ~.PackageWWWHome, "/README.md" ),
PackageInfoURL := Concatenation( ~.PackageWWWHome, "/PackageInfo.g" ),
ArchiveURL := Concatenation( ~.SourceRepository.URL,
"/releases/download/v", ~.Version,
"/", LowercaseString(~.PackageName), "-", ~.Version ),
ArchiveFormats := ".tar.gz",
Persons := [
rec(
LastName := "Dooms",
FirstNames := "Ann",
IsAuthor := true,
IsMaintainer := true,
Email := "andooms@vub.ac.be",
WWWHome := "http://homepages.vub.ac.be/~andooms",
PostalAddress := Concatenation( [
"Department of Mathematics\n",
"Vrije Universiteit Brussel\n",
"Pleinlaan 2, Brussels, B-1050 Belgium" ] ),
Place := "Brussels",
Institution := "Vrije Universiteit Brussel"
),
rec(
LastName := "Jespers",
FirstNames := "Eric",
IsAuthor := true,
IsMaintainer := false,
Email := "efjesper@vub.ac.be",
WWWHome := "http://homepages.vub.ac.be/~efjesper",
PostalAddress := Concatenation( [
"Department of Mathematics\n",
"Vrije Universiteit Brussel\n",
"Pleinlaan 2, Brussels, B-1050 Belgium" ] ),
Place := "Brussels",
Institution := "Vrije Universiteit Brussel"
),
rec(
LastName := "Konovalov",
FirstNames := "Alexander",
IsAuthor := true,
IsMaintainer := true,
Email := "alexander.konovalov@st-andrews.ac.uk",
WWWHome := "https://alexk.host.cs.st-andrews.ac.uk",
PostalAddress := Concatenation( [
"School of Computer Science\n",
"University of St Andrews\n",
"Jack Cole Building, North Haugh,\n",
"St Andrews, Fife, KY16 9SX, Scotland" ] ),
Place := "St Andrews",
Institution := "University of St Andrews"
),
rec(
LastName := "Verrill",
FirstNames := "Helena",
IsAuthor := true,
IsMaintainer := true,
Email := "verrill@math.lsu.edu",
WWWHome := "http://www.math.lsu.edu/~verrill",
PostalAddress := Concatenation( [
"Department of Mathematics\n",
"Louisiana State University\n",
"Baton Rouge, Louisiana, 70803-4918\n",
"USA" ] ),
Place := "Baton Rouge",
Institution := "Louisiana State University"
)
],
Status := "accepted",
CommunicatedBy := "Graham Ellis (Galway)",
AcceptDate := "09/2014",
AbstractHTML := "The Congruence package provides functions to construct several types of canonical congruence subgroups in SL_2(Z), and also intersections of a finite number of such subgroups. Furthermore, it implements the algorithm for generating Farey symbols for congruence subgroups and using them to produce a system of independent generators for these subgroups",
PackageDoc := rec(
BookName := "Congruence",
ArchiveURLSubset := ["doc"],
HTMLStart := "doc/chap0.html",
PDFFile := "doc/manual.pdf",
SixFile := "doc/manual.six",
LongTitle := "Congruence subgroups of SL(2,Integers)",
Autoload := true
),
Dependencies := rec(
GAP := ">=4.8",
NeededOtherPackages := [ ["GAPDoc", ">= 1.5.1"] ],
SuggestedOtherPackages := [],
ExternalConditions := []
),
AvailabilityTest := ReturnTrue,
TestFile := "tst/testall.g",
Keywords := ["congruence subgroup", "Farey symbol"]
));
congruence-1.2.3/README.md 0000664 0003717 0003717 00000002054 13503171577 016350 0 ustar gap-jenkins gap-jenkins [](https://travis-ci.org/gap-packages/congruence)
[](https://codecov.io/gh/gap-packages/congruence)
# GAP package Congruence
The GAP package Congruence provides functions to construct several types of
canonical congruence subgroups in SL_2(Z), and also intersections of a
finite number of such subgroups.
Furthermore, it implements the algorithm for generating Farey symbols for
congruence subgroups and using them to produce a system of independent
generators for these subgroups.
Congruence does not use external binaries and, therefore, works without
restrictions on the type of the operating system. It is redistributed with
GAP, but is not loaded by default. Therefore, to use Congruence, first you
need to load it using the following command:
gap> LoadPackage("congruence");
Ann Dooms, Eric Jespers, Alexander Konovalov, Helena Verrill
congruence-1.2.3/COPYING 0000664 0003717 0003717 00000043110 13503171577 016122 0 ustar gap-jenkins gap-jenkins GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
congruence-1.2.3/makedoc.g 0000664 0003717 0003717 00000007456 13503171577 016657 0 ustar gap-jenkins gap-jenkins ###########################################################################
##
#W makedoc.g The Congruence package Alexander Konovalov
##
###########################################################################
ExtractMyManualExamples:=function( pkgname, main, files )
local path, tst, i, s, basename, name, output, ch, a, location, pos, comment;
path:=Directory(
Concatenation(PackageInfo(pkgname)[1].InstallationPath, "/doc") );
Print("Extracting manual examples for ", pkgname, " package ...\n" );
tst:=ExtractExamples( path, main, files, "Chapter" );
Print(Length(tst), " chapters detected\n");
for i in [ 1 .. Length(tst) ] do
Print( "Chapter ", i, " : \c" );
if Length( tst[i] ) > 0 then
s := String(i);
if Length(s)=1 then
# works for <100 chapters
s:=Concatenation("0",s);
fi;
basename:=Concatenation( LowercaseString(pkgname), s, ".tst" );
name := Filename(
Directory(
Concatenation( PackageInfo(pkgname)[1].InstallationPath,
"/tst" ) ), basename );
output := OutputTextFile( name, false ); # to empty the file first
SetPrintFormattingStatus( output, false ); # to avoid line breaks
ch := tst[i];
AppendTo(output, "# ", pkgname, ", chapter ",i,"\n");
AppendTo(output, "#\n",
"# DO NOT EDIT THIS FILE - EDIT EXAMPLES IN THE SOURCE INSTEAD!\n",
"#\n",
"# This file has been autogenerated with GAP. It contains examples\n",
"# extracted from the documentation. Each example is preceded by the\n",
"# comment which points to the location of its source.\n",
"#\n");
AppendTo(output, "gap> START_TEST( \"", basename, "\");\n\n");
for a in ch do
location := a[2][1];
pos := PositionSublist(location,LowercaseString(pkgname));
if pos <> fail then
comment := location{[ pos+Length(pkgname)+1 .. Length(location) ]};
else
pos := PositionSublist(location,".//");
comment := location{[ pos+3 .. Length(location) ]};
fi;
AppendTo(output, "# ", comment, ":", a[2][2], "-", a[2][3], a[1]);
od;
AppendTo(output, "gap> STOP_TEST(\"", basename, "\", 1 );\n");
Print("extracted ", Length(ch), " examples \n");
else
Print("no examples \n" );
fi;
od;
end;
###########################################################################
CONGRUENCEMANUALFILES:=[
"../PackageInfo.g"
];
MakeGAPDocDoc( "doc", # path to the directory containing the main file
"manual", # the name of the main file (without extension)
# list of (probably source code) files relative
# to path which contain pieces of documentation
# which must be included in the document
CONGRUENCEMANUALFILES,
"Congruence",# the name of the book used by GAP's online help
"../../..",# optional: relative path to the main GAP root
# directory to produce HTML files with relative
# paths to external books.
"MathJax" # optional: use "MathJax", "Tth" and/or "MathML"
# to produce additional variants of HTML files
);;
# Copy the *.css and *.js files from the styles directory of the GAPDoc
# package into the directory containing the package manual.
CopyHTMLStyleFiles( "doc" );
# Create the manual.lab file which is needed if the main manuals or another
# package is referring to your package
GAPDocManualLab( "Congruence" );;
ExtractMyManualExamples( "congruence", "manual.xml", CONGRUENCEMANUALFILES );
QUIT;
###########################################################################
##
#E
##
congruence-1.2.3/init.g 0000664 0003717 0003717 00000001474 13503171577 016211 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W init.g The Congruence package Ann Dooms
#W Eric Jespers
#W Alexander Konovalov
#W Helena Verrill
##
##
#############################################################################
# read Congruence declarations
ReadPackage( "congruence", "lib/cong.gd" );
ReadPackage( "congruence", "lib/farey.gd" );
# read the other part of code
ReadPackage( "congruence", "lib/cong.g" );
ReadPackage( "congruence", "lib/buildman.g" );
ReadPackage( "congruence", "lib/factor.g" );
# set the default InfoLevel
SetInfoLevel( InfoCongruence, 1 );
congruence-1.2.3/read.g 0000664 0003717 0003717 00000001236 13503171577 016155 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W read.g The Congruence package Ann Dooms
#W Eric Jespers
#W Alexander Konovalov
#W Helena Verrill
##
##
#############################################################################
# read the implementation part of the Congruence package
ReadPackage( "congruence", "lib/cong.gi" );
ReadPackage( "congruence", "lib/farey.gi" );
ReadPackage( "congruence", "lib/random.gi" );
congruence-1.2.3/lib/farey.gd 0000664 0003717 0003717 00000004477 13503171577 017274 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W farey.gd The Congruence package Ann Dooms
#W Eric Jespers
#W Alexander Konovalov
##
##
#############################################################################
#############################################################################
##
## IsFareySymbol( )
##
DeclareCategory( "IsFareySymbol", IsObject );
#############################################################################
##
## FareySymbolByData( , )
##
## This constructor creates Farey symbol with the given generalized Farey
## sequence and list of labels. It also checks conditions from the definition
## of Farey symbol and returns an error if they are not satisfied
##
DeclareOperation( "FareySymbolByData", [ IsList, IsList ] );
#############################################################################
##
## GeneralizedFareySequence( )
## LabelsOfFareySymbol( )
##
## The data used to create the Farey symbol are stored as its attributes
##
DeclareAttribute( "GeneralizedFareySequence", IsFareySymbol );
DeclareAttribute( "LabelsOfFareySymbol", IsFareySymbol );
#############################################################################
##
## FareySymbol( )
##
## For a subgroup of a finite index G, this attribute stores the
## corresponding Farey symbol. The algorithm for its computation must work
## with any matrix group for which the membership test is available
##
DeclareAttribute( "FareySymbol", IsMatrixGroup );
#############################################################################
#
# GeneratorsByFareySymbol( fs )
#
DeclareGlobalFunction( "GeneratorsByFareySymbol" );
#############################################################################
#
# IndexInPSL2ZByFareySymbol( fs )
#
# By the proposition 7.2 [Kulkarni], for the Farey symbol with underlying
# generalized Farey sequence { infinity, x0, x1, ..., xn, infinity }, the
# index in PSL_2(Z) is given by the formula d = 3*n + e3, where e3 is the
# number of odd intervals.
#
DeclareGlobalFunction( "IndexInPSL2ZByFareySymbol" );
#############################################################################
##
#E
##
congruence-1.2.3/lib/cong.gi 0000664 0003717 0003717 00000074775 13503171577 017131 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W cong.gi The Congruence package Ann Dooms
#W Eric Jespers
#W Alexander Konovalov
##
##
#############################################################################
#############################################################################
##
## Constructors of congruence subgroups
InstallMethod( PrincipalCongruenceSubgroup, "for positive integer",
[ IsPosInt ],
function(n)
local type, G;
type := NewType( FamilyObj([[[1,0],[0,1]]]),
IsGroup and
IsAttributeStoringRep and
IsFinitelyGeneratedGroup and
IsMatrixGroup and
IsCongruenceSubgroup);
G := rec();
ObjectifyWithAttributes( G, type,
DimensionOfMatrixGroup, 2,
OneImmutable, [[1,0],[0,1]],
IsIntegerMatrixGroup, true,
IsFinite, false,
LevelOfCongruenceSubgroup, n,
IsPrincipalCongruenceSubgroup, true,
IsIntersectionOfCongruenceSubgroups, false,
IsCongruenceSubgroupGamma0, false, IsCongruenceSubgroupGammaUpper0, false,
IsCongruenceSubgroupGamma1, false, IsCongruenceSubgroupGammaUpper1, false,
IsCongruenceSubgroupGammaMN, false );
return G;
end);
InstallMethod( CongruenceSubgroupGamma0, "for positive integer",
[ IsPosInt ],
function(n)
local type, G;
type := NewType( FamilyObj([[[1,0],[0,1]]]),
IsGroup and
IsAttributeStoringRep and
IsFinitelyGeneratedGroup and
IsMatrixGroup and
IsCongruenceSubgroup);
G := rec();
ObjectifyWithAttributes( G, type,
DimensionOfMatrixGroup, 2,
OneImmutable, [[1,0],[0,1]],
IsIntegerMatrixGroup, true,
IsFinite, false,
LevelOfCongruenceSubgroup, n,
IsPrincipalCongruenceSubgroup, false,
IsIntersectionOfCongruenceSubgroups, false,
IsCongruenceSubgroupGamma0, true, IsCongruenceSubgroupGammaUpper0, false,
IsCongruenceSubgroupGamma1, false, IsCongruenceSubgroupGammaUpper1, false,
IsCongruenceSubgroupGammaMN, false );
return G;
end);
InstallMethod( CongruenceSubgroupGammaUpper0, "for positive integer",
[ IsPosInt ],
function(n)
local type, G;
type := NewType( FamilyObj([[[1,0],[0,1]]]),
IsGroup and
IsAttributeStoringRep and
IsFinitelyGeneratedGroup and
IsMatrixGroup and
IsCongruenceSubgroup);
G := rec();
ObjectifyWithAttributes( G, type,
DimensionOfMatrixGroup, 2,
OneImmutable, [[1,0],[0,1]],
IsIntegerMatrixGroup, true,
IsFinite, false,
LevelOfCongruenceSubgroup, n,
IsPrincipalCongruenceSubgroup, false,
IsIntersectionOfCongruenceSubgroups, false,
IsCongruenceSubgroupGamma0, false, IsCongruenceSubgroupGammaUpper0, true,
IsCongruenceSubgroupGamma1, false, IsCongruenceSubgroupGammaUpper1, false,
IsCongruenceSubgroupGammaMN, false );
return G;
end);
InstallMethod( CongruenceSubgroupGamma1, "for positive integer",
[ IsPosInt ],
function(n)
local type, G;
type := NewType( FamilyObj([[[1,0],[0,1]]]),
IsGroup and
IsAttributeStoringRep and
IsFinitelyGeneratedGroup and
IsMatrixGroup and
IsCongruenceSubgroup);
G := rec();
ObjectifyWithAttributes( G, type,
DimensionOfMatrixGroup, 2,
OneImmutable, [[1,0],[0,1]],
IsIntegerMatrixGroup, true,
IsFinite, false,
LevelOfCongruenceSubgroup, n,
IsPrincipalCongruenceSubgroup, false,
IsIntersectionOfCongruenceSubgroups, false,
IsCongruenceSubgroupGamma0, false, IsCongruenceSubgroupGammaUpper0, false,
IsCongruenceSubgroupGamma1, true, IsCongruenceSubgroupGammaUpper1, false,
IsCongruenceSubgroupGammaMN, false );
return G;
end);
InstallMethod( CongruenceSubgroupGammaUpper1, "for positive integer",
[ IsPosInt ],
function(n)
local type, G;
type := NewType( FamilyObj([[[1,0],[0,1]]]),
IsGroup and
IsAttributeStoringRep and
IsFinitelyGeneratedGroup and
IsMatrixGroup and
IsCongruenceSubgroup);
G := rec();
ObjectifyWithAttributes( G, type,
DimensionOfMatrixGroup, 2,
OneImmutable, [[1,0],[0,1]],
IsIntegerMatrixGroup, true,
IsFinite, false,
LevelOfCongruenceSubgroup, n,
IsPrincipalCongruenceSubgroup, false,
IsIntersectionOfCongruenceSubgroups, false,
IsCongruenceSubgroupGamma0, false, IsCongruenceSubgroupGammaUpper0, false,
IsCongruenceSubgroupGamma1, false, IsCongruenceSubgroupGammaUpper1, true,
IsCongruenceSubgroupGammaMN, false );
return G;
end);
InstallMethod( CongruenceSubgroupGammaMN, "for two positive integers",
[ IsPosInt, IsPosInt ],
function(m,n)
local type, G;
type := NewType( FamilyObj([[[1,0],[0,1]]]),
IsGroup and
IsAttributeStoringRep and
IsFinitelyGeneratedGroup and
IsMatrixGroup and
IsCongruenceSubgroup);
G := rec();
ObjectifyWithAttributes( G, type,
DimensionOfMatrixGroup, 2,
OneImmutable, [[1,0],[0,1]],
IsIntegerMatrixGroup, true,
IsFinite, false,
LevelOfCongruenceSubgroup, m*n,
LevelOfCongruenceSubgroupGammaMN, [m,n],
IsPrincipalCongruenceSubgroup, false,
IsIntersectionOfCongruenceSubgroups, false,
IsCongruenceSubgroupGamma0, false, IsCongruenceSubgroupGammaUpper0, false,
IsCongruenceSubgroupGamma1, false, IsCongruenceSubgroupGammaUpper1, false,
IsCongruenceSubgroupGammaMN, true );
return G;
end);
InstallGlobalFunction( IntersectionOfCongruenceSubgroups,
function( arg )
local type, G, H, K, T, arglist, n, i, pos;
type := NewType( FamilyObj([[[1,0],[0,1]]]),
IsGroup and
IsAttributeStoringRep and
IsFinitelyGeneratedGroup and
IsMatrixGroup and
IsCongruenceSubgroup);
if not ForAll( arg, IsCongruenceSubgroup ) then
Error("Usage : IntersectionOfCongruenceSubgroups( G1, G2, ... GN ) \n");
fi;
# First we create a list arglist to eliminate evident repetitions of subgroups.
# Then we eliminate evident inclusions of one subgroup into another:
# - since intersection is associative, if we can intersect the group T which
# is to be added with another subgroup K already contained in alglist, and
# the result is one of the canonical congruence subgroups, we replace K by
# the result of intersection of K and T
# - we do not add a subgroup T to the list of defining subgroups, if alglist
# already contains another subgroup K such that K is in T.
# - if we add to alglist a subgroup T and alglist already contains one or more
# subgroups K such that T is in K, we add T and remove all these K.
arglist := [];
for H in arg do
if IsIntersectionOfCongruenceSubgroups(H) then
for T in DefiningCongruenceSubgroups( H ) do
pos:=PositionProperty( arglist, K ->
CanReduceIntersectionOfCongruenceSubgroups( K, T ) );
if pos<>fail then
arglist[pos]:=Intersection( arglist[pos], T );
else
if ForAll( arglist, K -> not CanEasilyCompareCongruenceSubgroups( K, T ) ) and
ForAll( arglist, K -> not IsSubgroup( T, K ) ) then
for i in [ 1 .. Length(arglist) ] do
if IsSubgroup( arglist[i], T ) then
Unbind( arglist[i] );
fi;
od;
arglist := Compacted( arglist );
Add( arglist, T );
fi;
fi;
od;
else
pos:=PositionProperty( arglist, K ->
CanReduceIntersectionOfCongruenceSubgroups( K, H ) );
if pos<>fail then
arglist[pos]:=Intersection( arglist[pos], H );
else
if ForAll( arglist, K -> not CanEasilyCompareCongruenceSubgroups( K, H ) ) and
ForAll( arglist, K -> not IsSubgroup( H, K ) ) then
for i in [ 1 .. Length(arglist) ] do
if IsSubgroup( arglist[i], H ) then
Unbind( arglist[i] );
fi;
od;
arglist := Compacted( arglist );
Add( arglist, H );
fi;
fi;
fi;
od;
# if the list of defining subgroups was reduced
# to a single subgroup, we return this subgroup
if Length( arglist ) = 1 then
return arglist[1];
fi;
# otherwise we sort the list of defining subgroups:
# types of subgroups are sorted in the following way:
# - IsCongruenceSubgroupGamma0
# - IsCongruenceSubgroupGammaUpper0
# - IsCongruenceSubgroupGamma1
# - IsCongruenceSubgroupGammaUpper1
# - IsPrincipalCongruenceSubgroup
# and subgroups of the same type are sorted by ascending level
Sort( arglist,
function(X,Y)
local f, t;
f:=[IsCongruenceSubgroupGamma0,IsCongruenceSubgroupGammaUpper0,IsCongruenceSubgroupGamma1,IsCongruenceSubgroupGammaUpper1,IsPrincipalCongruenceSubgroup];
return PositionProperty(f, t -> t(X)) < PositionProperty(f, t -> t(Y)) or
( PositionProperty(f, t -> t(X)) = PositionProperty(f, t -> t(Y)) and
LevelOfCongruenceSubgroup(X) < LevelOfCongruenceSubgroup(Y) );
end );
n := Lcm( List( arglist, H -> LevelOfCongruenceSubgroup(H) ) );
G := rec();
ObjectifyWithAttributes( G, type,
DimensionOfMatrixGroup, 2,
OneImmutable, [[1,0],[0,1]],
IsIntegerMatrixGroup, true,
IsFinite, false,
LevelOfCongruenceSubgroup, n,
IsPrincipalCongruenceSubgroup, false,
IsIntersectionOfCongruenceSubgroups, true,
IsCongruenceSubgroupGamma0, false, IsCongruenceSubgroupGammaUpper0, false,
IsCongruenceSubgroupGamma1, false, IsCongruenceSubgroupGammaUpper1, false,
DefiningCongruenceSubgroups, arglist );
return G;
end);
InstallMethod( DefiningCongruenceSubgroups, "for congruence subgroups",
[ IsCongruenceSubgroup ],
function(G)
if not IsIntersectionOfCongruenceSubgroups(G) then
return [G];
fi;
end);
#############################################################################
##
## Methods for PrintObj and ViewObj for congruence subgroups
InstallMethod( ViewObj,
"for principal congruence subgroup",
[ IsPrincipalCongruenceSubgroup ],
0,
function( G )
Print( "" );
end );
InstallMethod( PrintObj,
"for principal congruence subgroup",
[ IsPrincipalCongruenceSubgroup ],
0,
function( G )
Print( "PrincipalCongruenceSubgroup(",
LevelOfCongruenceSubgroup(G), ")" );
end );
InstallMethod( ViewObj,
"for CongruenceSubgroupGamma0 congruence subgroup",
[ IsCongruenceSubgroupGamma0 ],
0,
function( G )
Print( "" );
end );
InstallMethod( PrintObj,
"for CongruenceSubgroupGamma0 congruence subgroup",
[ IsCongruenceSubgroupGamma0 ],
0,
function( G )
Print( "CongruenceSubgroupGamma0(",
LevelOfCongruenceSubgroup(G), ")" );
end );
InstallMethod( ViewObj,
"for CongruenceSubgroupGammaUpper0 congruence subgroup",
[ IsCongruenceSubgroupGammaUpper0 ],
0,
function( G )
Print( "" );
end );
InstallMethod( PrintObj,
"for CongruenceSubgroupGammaUpper0 congruence subgroup",
[ IsCongruenceSubgroupGammaUpper0 ],
0,
function( G )
Print( "CongruenceSubgroupGammaUpper0(",
LevelOfCongruenceSubgroup(G), ")" );
end );
InstallMethod( ViewObj,
"for CongruenceSubgroupGamma1 congruence subgroup",
[ IsCongruenceSubgroupGamma1 ],
0,
function( G )
Print( "" );
end );
InstallMethod( PrintObj,
"for CongruenceSubgroupGamma1 congruence subgroup",
[ IsCongruenceSubgroupGamma1 ],
0,
function( G )
Print( "CongruenceSubgroupGamma1(",
LevelOfCongruenceSubgroup(G), ")" );
end );
InstallMethod( ViewObj,
"for CongruenceSubgroupGammaUpper1 congruence subgroup",
[ IsCongruenceSubgroupGammaUpper1 ],
0,
function( G )
Print( "" );
end );
InstallMethod( PrintObj,
"for CongruenceSubgroupGammaUpper1 congruence subgroup",
[ IsCongruenceSubgroupGammaUpper1 ],
0,
function( G )
Print( "CongruenceSubgroupGammaUpper1(",
LevelOfCongruenceSubgroup(G), ")" );
end );
InstallMethod( ViewObj,
"for CongruenceSubgroupGammaMN congruence subgroup",
[ IsCongruenceSubgroupGammaMN ],
0,
function( G )
Print( "" );
end );
InstallMethod( PrintObj,
"for CongruenceSubgroupGammaMN congruence subgroup",
[ IsCongruenceSubgroupGammaMN ],
0,
function( G )
Print( "CongruenceSubgroupGammaMN(",
LevelOfCongruenceSubgroupGammaMN(G)[1], ",",
LevelOfCongruenceSubgroupGammaMN(G)[2], ")" );
end );
InstallMethod( ViewObj,
"for intersection of congruence subgroups",
[ IsIntersectionOfCongruenceSubgroups ],
0,
function( G )
Print( "" );
end );
InstallMethod( PrintObj,
"for intersection of congruence subgroups",
[ IsIntersectionOfCongruenceSubgroups ],
0,
function( G )
local i, k;
k := Length(DefiningCongruenceSubgroups(G));
Print( "IntersectionOfCongruenceSubgroups( \n" );
for i in [ 1 .. k-1 ] do
Print( " ", DefiningCongruenceSubgroups(G)[i], ", \n" );
od;
Print( " ", DefiningCongruenceSubgroups(G)[k], " )" );
end );
#############################################################################
##
## Membership tests for congruence subgroups
InstallMethod( \in,
"for a 2x2 matrix and a principal congruence subgroup",
[ IsMatrix, IsPrincipalCongruenceSubgroup],
0,
function( m, G )
local n;
if not DimensionsMat( m ) = [2,2] then
return false;
elif DeterminantMat(m)<>1 then
return false;
else
n := LevelOfCongruenceSubgroup(G);
return IsInt( (m[1][1]-1)/n ) and
IsInt(m[1][2]/n) and
IsInt(m[2][1]/n) and
IsInt( (m[2][2]-1)/n );
fi;
end);
InstallMethod( \in,
"for a 2x2 matrix and a congruence subgroup CongruenceSubgroupGamma0",
[ IsMatrix, IsCongruenceSubgroupGamma0 ],
0,
function( m, G )
local n;
if not DimensionsMat( m ) = [2,2] then
return false;
elif DeterminantMat(m)<>1 then
return false;
else
n := LevelOfCongruenceSubgroup(G);
return IsInt(m[2][1]/n);
fi;
end);
InstallMethod( \in,
"for a 2x2 matrix and a congruence subgroup CongruenceSubgroupGammaUpper0",
[ IsMatrix, IsCongruenceSubgroupGammaUpper0 ],
0,
function( m, G )
local n;
if not DimensionsMat( m ) = [2,2] then
return false;
elif DeterminantMat(m)<>1 then
return false;
else
n := LevelOfCongruenceSubgroup(G);
return IsInt(m[1][2]/n);
fi;
end);
InstallMethod( \in,
"for a 2x2 matrix and a congruence subgroup CongruenceSubgroupGamma1",
[ IsMatrix, IsCongruenceSubgroupGamma1 ],
0,
function( m, G )
local n;
if not DimensionsMat( m ) = [2,2] then
return false;
elif DeterminantMat(m)<>1 then
return false;
else
n := LevelOfCongruenceSubgroup(G);
return IsInt( (m[1][1]-1)/n ) and
IsInt( m[2][1]/n ) and
IsInt( (m[2][2]-1)/n );
fi;
end);
InstallMethod( \in,
"for a 2x2 matrix and a congruence subgroup CongruenceSubgroupGammaUpper1",
[ IsMatrix, IsCongruenceSubgroupGammaUpper1 ],
0,
function( m, G )
local n;
if not DimensionsMat( m ) = [2,2] then
return false;
elif DeterminantMat(m)<>1 then
return false;
else
n := LevelOfCongruenceSubgroup(G);
return IsInt( (m[1][1]-1)/n ) and
IsInt( m[1][2]/n ) and
IsInt( (m[2][2]-1)/n );
fi;
end);
InstallMethod( \in,
"for a 2x2 matrix and a congruence subgroup CongruenceSubgroupGammaMN",
[ IsMatrix, IsCongruenceSubgroupGammaMN ],
0,
function( mat, G )
local m, n;
if not DimensionsMat( mat ) = [2,2] then
return false;
elif DeterminantMat(mat)<>1 then
return false;
else
m := LevelOfCongruenceSubgroupGammaMN(G)[1];
n := LevelOfCongruenceSubgroupGammaMN(G)[2];
return IsInt( (mat[1][1]-1)/m ) and
IsInt(mat[1][2]/m) and
IsInt(mat[2][1]/n) and
IsInt( (mat[2][2]-1)/n );
fi;
end);
InstallMethod( \in,
"for an intersection of congruence subgroups",
[ IsMatrix, IsIntersectionOfCongruenceSubgroups ],
0,
function( m, G )
local H;
if not DimensionsMat( m ) = [2,2] then
return false;
elif DeterminantMat(m)<>1 then
return false;
else
return ForAll( DefiningCongruenceSubgroups(G), H -> m in H );
fi;
end);
#############################################################################
##
## Installing special methods for congruence subgroups
## for some general methods installed in GAP for matrix groups
InstallMethod( DimensionOfMatrixGroup,
"for congruence subgroup",
[ IsCongruenceSubgroup ],
0,
G -> 2 );
InstallMethod( \=,
"for a pair of congruence subgroups",
[ IsCongruenceSubgroup, IsCongruenceSubgroup ],
0,
function( G, H )
if CanEasilyCompareCongruenceSubgroups( G, H ) then
return true;
else
TryNextMethod();
fi;
end);
#############################################################################
##
## IsSubset
##
#############################################################################
InstallMethod( IsSubset,
"for a natural SL_2(Z) and a congruence subgroup",
[ IsNaturalSL, IsCongruenceSubgroup ],
0,
function( G, H )
return MultiplicativeNeutralElement(G)=[ [ 1, 0 ], [ 0, 1 ] ];
end);
InstallMethod( IsSubset,
"for a congruence subgroup and a principal congruence subgroup",
[ IsCongruenceSubgroup, IsPrincipalCongruenceSubgroup ],
0,
function( G, H )
local T;
if IsIntersectionOfCongruenceSubgroups(G) then
return ForAll( DefiningCongruenceSubgroups(G), T -> IsSubset(T,H) );
elif IsPrincipalCongruenceSubgroup(G) or
IsCongruenceSubgroupGamma1(G) or IsCongruenceSubgroupGammaUpper1(G) or
IsCongruenceSubgroupGamma0(G) or IsCongruenceSubgroupGammaUpper0(G) then
return IsInt( LevelOfCongruenceSubgroup(H) / LevelOfCongruenceSubgroup(G) );
else
# for a case of another type of congruence subgroup
TryNextMethod();
fi;
end);
InstallMethod( IsSubset,
"for a congruence subgroup and CongruenceSubgroupGamma1",
[ IsCongruenceSubgroup, IsCongruenceSubgroupGamma1 ],
0,
function( G, H )
local T;
if IsIntersectionOfCongruenceSubgroups(G) then
return ForAll( DefiningCongruenceSubgroups(G), T -> IsSubset(T,H) );
elif IsPrincipalCongruenceSubgroup(G) or
IsCongruenceSubgroupGammaUpper1(G) or IsCongruenceSubgroupGammaUpper0(G) then
return false;
elif IsCongruenceSubgroupGamma1(G) or IsCongruenceSubgroupGamma0(G) then
return IsInt( LevelOfCongruenceSubgroup(H) / LevelOfCongruenceSubgroup(G) );
else
# for a case of another type of congruence subgroup
TryNextMethod();
fi;
end);
InstallMethod( IsSubset,
"for a congruence subgroup and CongruenceSubgroupGammaUpper1",
[ IsCongruenceSubgroup, IsCongruenceSubgroupGammaUpper1 ],
0,
function( G, H )
local T;
if IsIntersectionOfCongruenceSubgroups(G) then
return ForAll( DefiningCongruenceSubgroups(G), T -> IsSubset(T,H) );
elif IsPrincipalCongruenceSubgroup(G) or
IsCongruenceSubgroupGamma1(G) or IsCongruenceSubgroupGamma0(G) then
return false;
elif IsCongruenceSubgroupGammaUpper1(G) or IsCongruenceSubgroupGammaUpper0(G) then
return IsInt( LevelOfCongruenceSubgroup(H) / LevelOfCongruenceSubgroup(G) );
else
# for a case of another type of congruence subgroup
TryNextMethod();
fi;
end);
InstallMethod( IsSubset,
"for a congruence subgroup and CongruenceSubgroupGamma0",
[ IsCongruenceSubgroup, IsCongruenceSubgroupGamma0 ],
0,
function( G, H )
local T;
if IsIntersectionOfCongruenceSubgroups(G) then
return ForAll( DefiningCongruenceSubgroups(G), T -> IsSubset(T,H) );
elif IsPrincipalCongruenceSubgroup(G) or
IsCongruenceSubgroupGamma1(G) or IsCongruenceSubgroupGammaUpper1(G) or IsCongruenceSubgroupGammaUpper0(G) then
return false;
elif IsCongruenceSubgroupGamma0(G) then
return IsInt( LevelOfCongruenceSubgroup(H) / LevelOfCongruenceSubgroup(G) );
else
# for a case of another type of congruence subgroup
TryNextMethod();
fi;
end);
InstallMethod( IsSubset,
"for a congruence subgroup and CongruenceSubgroupGammaUpper0",
[ IsCongruenceSubgroup, IsCongruenceSubgroupGammaUpper0 ],
0,
function( G, H )
local T;
if IsIntersectionOfCongruenceSubgroups(G) then
return ForAll( DefiningCongruenceSubgroups(G), T -> IsSubset(T,H) );
elif IsPrincipalCongruenceSubgroup(G) or
IsCongruenceSubgroupGamma1(G) or IsCongruenceSubgroupGammaUpper1(G) or IsCongruenceSubgroupGamma0(G) then
return false;
elif IsCongruenceSubgroupGammaUpper0(G) then
return IsInt( LevelOfCongruenceSubgroup(H) / LevelOfCongruenceSubgroup(G) );
else
# for a case of another type of congruence subgroup
TryNextMethod();
fi;
end);
InstallMethod( IsSubset,
"for a congruence subgroup and intersection of congruence subgroups",
[ IsCongruenceSubgroup, IsIntersectionOfCongruenceSubgroups ],
0,
function( G, H )
local DG, DH;
# here we can check only sufficient conditions, and they are not
# satisfied, then we call the next method
if IsIntersectionOfCongruenceSubgroups(G) then
if ForAll( DefiningCongruenceSubgroups(H), DH ->
ForAll( DefiningCongruenceSubgroups(G), DG ->
IsSubset(G,DH) ) ) then
return true;
else
TryNextMethod();
fi;
elif IsPrincipalCongruenceSubgroup(G) or
IsCongruenceSubgroupGamma1(G) or IsCongruenceSubgroupGammaUpper1(G) or
IsCongruenceSubgroupGamma0(G) or IsCongruenceSubgroupGammaUpper0(G) then
if ForAll( DefiningCongruenceSubgroups(H), DH -> IsSubset(G,DH) ) then
return true;
else
TryNextMethod();
fi;
else
# for a case of another type of congruence subgroup
TryNextMethod();
fi;
end);
#############################################################################
##
## Intersection2
##
#############################################################################
InstallMethod( Intersection2,
"for a pair of congruence subgroups",
[ IsCongruenceSubgroup, IsCongruenceSubgroup ],
0,
function( G, H )
#
# Case 1 - at least one subgroup is an intersection of congruence subgroups
#
if IsIntersectionOfCongruenceSubgroups(G) or
IsIntersectionOfCongruenceSubgroups(H) then
return IntersectionOfCongruenceSubgroups(G,H);
#
# Case 2 - the diagonal (both subgroups has the same type)
#
elif IsPrincipalCongruenceSubgroup(G) and IsPrincipalCongruenceSubgroup(H) then
return PrincipalCongruenceSubgroup( Lcm( LevelOfCongruenceSubgroup(G),
LevelOfCongruenceSubgroup(H) ) );
elif IsCongruenceSubgroupGamma1(G) and IsCongruenceSubgroupGamma1(H) then
return CongruenceSubgroupGamma1( Lcm( LevelOfCongruenceSubgroup(G),
LevelOfCongruenceSubgroup(H) ) );
elif IsCongruenceSubgroupGammaUpper1(G) and IsCongruenceSubgroupGammaUpper1(H) then
return CongruenceSubgroupGammaUpper1( Lcm( LevelOfCongruenceSubgroup(G),
LevelOfCongruenceSubgroup(H) ) );
elif IsCongruenceSubgroupGamma0(G) and IsCongruenceSubgroupGamma0(H) then
return CongruenceSubgroupGamma0( Lcm( LevelOfCongruenceSubgroup(G),
LevelOfCongruenceSubgroup(H) ) );
elif IsCongruenceSubgroupGammaUpper0(G) and IsCongruenceSubgroupGammaUpper0(H) then
return CongruenceSubgroupGammaUpper0( Lcm( LevelOfCongruenceSubgroup(G),
LevelOfCongruenceSubgroup(H) ) );
#
# Case 3 - Subgroups has different level
#
elif LevelOfCongruenceSubgroup(G) <> LevelOfCongruenceSubgroup(H) then
return IntersectionOfCongruenceSubgroups(G,H);
#
# Now subgroups have the same level
#
elif IsCongruenceSubgroupGamma1(G) and IsCongruenceSubgroupGamma0(H) then
return G; # so all properties and attributes of G will be preserved
elif IsCongruenceSubgroupGamma0(G) and IsCongruenceSubgroupGamma1(H) then
return H;
elif IsCongruenceSubgroupGammaUpper1(G) and IsCongruenceSubgroupGammaUpper0(H) then
return G;
elif IsCongruenceSubgroupGammaUpper0(G) and IsCongruenceSubgroupGammaUpper1(H) then
return H;
elif IsCongruenceSubgroupGamma0(G) and IsCongruenceSubgroupGammaUpper0(H) or IsCongruenceSubgroupGammaUpper0(G) and IsCongruenceSubgroupGamma0(H) then
return IntersectionOfCongruenceSubgroups(G,H);
else
return PrincipalCongruenceSubgroup(LevelOfCongruenceSubgroup(G));
fi;
end);
#############################################################################
##
## Indices of congruence subgroups
##
#############################################################################
InstallMethod( Index,
"for a natural SL_2(Z) and a congruence subgroup",
[ IsNaturalSL, IsCongruenceSubgroup ],
0,
function( G, H )
local n, prdiv, r, p;
n := LevelOfCongruenceSubgroup(H);
if HasIsPrincipalCongruenceSubgroup( H ) and
IsPrincipalCongruenceSubgroup( H ) then
if n=1 then
Assert( 1, IndexInPSL2ZByFareySymbol( FareySymbol ( H ) ) = 1 );
return 1;
elif n=2 then
Assert( 1, IndexInPSL2ZByFareySymbol( FareySymbol ( H ) ) = 6 );
return 12; # not 6, since we are in SL, not in PSL
else
prdiv := Set( Factors( n ) );
r := n^3; # not (n^3)/2 since we are in SL, not in PSL
for p in prdiv do
r := r*(1-1/p^2);
od;
Assert( 1, IndexInPSL2ZByFareySymbol( FareySymbol ( H ) ) = r/2 );
return r;
fi;
elif ( HasIsCongruenceSubgroupGamma0( H ) and IsCongruenceSubgroupGamma0( H ) ) or
( HasIsCongruenceSubgroupGammaUpper0( H ) and IsCongruenceSubgroupGammaUpper0( H ) ) then
# for CongruenceSubgroupGamma0 we use the formula
# [ SL_2(Z) : CongruenceSubgroupGamma0(n) ] = n * "Product over prime p | n" ( 1 + 1/p )
prdiv := Set( Factors( n ) );
r := n;
for p in prdiv do
r := r*(1+1/p);
od;
Assert( 1, IndexInPSL2ZByFareySymbol( FareySymbol ( H ) ) = r );
return r;
elif ( HasIsCongruenceSubgroupGamma1( H ) and IsCongruenceSubgroupGamma1( H ) ) or
( HasIsCongruenceSubgroupGammaUpper1( H ) and IsCongruenceSubgroupGammaUpper1( H ) ) then
# for CongruenceSubgroupGamma1 we use the formula
# [ CongruenceSubgroupGamma0(n) : CongruenceSubgroupGamma1(n) ] = n * "Product over prime p | n" ( 1 - 1/p )
# Combining with the previous case, we get that
# [ SL_2(Z) : CongruenceSubgroupGamma1(n) ] = n^2 * "Product over prime p | n" ( 1 - 1/p^2 )
prdiv := Set( Factors( n ) );
r := n^2;
for p in prdiv do
r := r*(1-1/p^2);
od;
Assert( 1, IndexInPSL2ZByFareySymbol( FareySymbol ( H ) ) = r/2 );
return r;
else
# if H is not in any of the cases above, for example is an intersection
# of some congruence subgroups, we derive the index from its Farey symbol
if [[-1,0],[0,-1]] in H then
return IndexInPSL2ZByFareySymbol( FareySymbol ( H ) ) ;
else
return IndexInPSL2ZByFareySymbol( FareySymbol ( H ) ) * 2;
fi;
fi;
end);
InstallMethod( IndexInSL2Z,
"for a congruence subgroup",
[ IsCongruenceSubgroup ],
0,
G -> Index( SL(2,Integers), G ) );
InstallMethod( Index,
"for a pair of congruence subgroups",
[ IsCongruenceSubgroup, IsCongruenceSubgroup ],
0,
function( G, H )
if IsSubgroup( G, H ) then
return IndexInSL2Z(H)/IndexInSL2Z(G);
fi;
end);
#############################################################################
##
## Generators of confruence subgroups from Farey symbols
##
#############################################################################
InstallMethod( GeneratorsOfGroup,
"for a congruence subgroup",
[ IsCongruenceSubgroup ],
0,
function(G)
local gens, i;
Info( InfoCongruence, 1, "Using the Congruence package for GeneratorsOfGroup ...");
gens := GeneratorsByFareySymbol( FareySymbol( G ) );
for i in [ 1 .. Length(gens) ] do
if not gens[i] in G then
gens[i] := -gens[i];
Assert( 1, gens[i] in G );
fi;
od;
return gens;
end );
#############################################################################
##
#E
##
congruence-1.2.3/lib/random.gi 0000664 0003717 0003717 00000016441 13503171577 017445 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W random.gi The Congruence package Ann Dooms
#W Eric Jespers
#W Alexander Konovalov
##
##
#############################################################################
##
## This file contains implementations of methods to construct random elements
## of congruence subgroups CongruenceSubgroupGamma, CongruenceSubgroupGamma0,
## CongruenceSubgroupGammaUpper0, CongruenceSubgroupGamma1 and
## CongruenceSubgroupGammaUpper1.
## The idea is to select two random entries a and b in the same row or column
## of the matrix, such that a and b will satisfy the requirements arising
## from the congruence subgroup. For example, for the principal congruence
## subgroup we will select a and b as follows:
## a := 1 + n * Random( [ -10 .. 10 ] );
## b := n * Random( [ -10 .. 10 ] );
## After this we can find such x and y for the other row (or column) of the
## matrix that its determinant will be equal to one. If the resulting matrix
## will be not in the congruence subgroup because of not suitable x and y,
## we will repeat this process for another a and b until we will find
## suitable x and y.
## For each type of congruence subgroups, we provide one- and two-argument
## versions of Random. The one-argument version uses Random( [ -10 .. 10 ] )
## to generate a and b, ## and in the two-argument version Random([ -m..m ])
## will be used, where m is given by the second argument.
#############################################################################
##
## The principal congruence subgroup of level N consists of all matrices
## of the form [ 1+N N ]
## [ N 1+N ]
##
InstallMethod( Random,
"for a principal congruence subgroup",
[ IsPrincipalCongruenceSubgroup ],
0,
function( G )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := 1 + n * Random( [ -10 .. 10 ] );
b := n * Random( [ -10 .. 10 ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1 and
IsInt( -gcd.coeff2/n ) and
IsInt( (gcd.coeff1-1)/n );
return [ [ a, b ],
[ -gcd.coeff2, gcd.coeff1 ] ];
end);
InstallOtherMethod( Random,
"for a principal congruence subgroup",
[ IsPrincipalCongruenceSubgroup, IsPosInt ],
0,
function( G, m )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := 1 + n * Random( [ -m .. m ] );
b := n * Random( [ -m .. m ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1 and
IsInt( -gcd.coeff2/n ) and
IsInt( (gcd.coeff1-1)/n );
return [ [ a, b ],
[ -gcd.coeff2, gcd.coeff1 ] ];
end);
#############################################################################
##
## The congruence subgroup CongruenceSubgroupGamma0(N) consists of all matrices
## of the form [ * * ]
## [ N * ]
##
InstallMethod( Random,
"for a congruence subgroup CongruenceSubgroupGamma0",
[ IsCongruenceSubgroupGamma0 ],
0,
function( G )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := Random( [ -n*10 .. n*10 ] );
b := n * Random( [ -10 .. 10 ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1;
return [ [ a, -gcd.coeff2 ],
[ b, gcd.coeff1 ] ];
end);
InstallOtherMethod( Random,
"for a congruence subgroup CongruenceSubgroupGamma0",
[ IsCongruenceSubgroupGamma0, IsPosInt ],
0,
function( G, m )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := Random( [ -n*m .. n*m ] );
b := n * Random( [ -m .. m ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1;
return [ [ a, -gcd.coeff2 ],
[ b, gcd.coeff1 ] ];
end);
#############################################################################
##
## The congruence subgroup CongruenceSubgroupGammaUpper0(N) consists of all matrices
## of the form [ * N ]
## [ * * ]
##
InstallMethod( Random,
"for a congruence subgroup CongruenceSubgroupGammaUpper0",
[ IsCongruenceSubgroupGammaUpper0 ],
0,
function( G )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := Random( [ -n*10 .. n*10 ] );
b := n * Random( [ -10 .. 10 ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1;
return [ [ a, b ],
[ -gcd.coeff2, gcd.coeff1 ] ];
end);
InstallOtherMethod( Random,
"for a congruence subgroup CongruenceSubgroupGammaUpper0",
[ IsCongruenceSubgroupGammaUpper0, IsPosInt ],
0,
function( G, m )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := Random( [ -n*m .. n*m ] );
b := n * Random( [ -m .. m ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1;
return [ [ a, b ],
[ -gcd.coeff2, gcd.coeff1 ] ];
end);
#############################################################################
##
## The congruence subgroup CongruenceSubgroupGamma1(N) consists of all matrices
## of the form [ 1+N * ]
## [ N 1+N ]
##
InstallMethod( Random,
"for a congruence subgroup CongruenceSubgroupGamma1",
[ IsCongruenceSubgroupGamma1 ],
0,
function( G )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := 1 + n * Random( [ -10 .. 10 ] );
b := n * Random( [ -10 .. 10 ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1 and IsInt( (gcd.coeff1-1)/n );
return [ [ a, -gcd.coeff2 ],
[ b, gcd.coeff1 ] ];
end);
InstallOtherMethod( Random,
"for a congruence subgroup CongruenceSubgroupGamma1",
[ IsCongruenceSubgroupGamma1, IsPosInt ],
0,
function( G, m )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := 1 + n * Random( [ -m .. m ] );
b := n * Random( [ -m .. m ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1 and IsInt( (gcd.coeff1-1)/n );
return [ [ a, -gcd.coeff2 ],
[ b, gcd.coeff1 ] ];
end);
#############################################################################
##
## The congruence subgroup CongruenceSubgroupGammaUpper1(N) consists of all matrices
## of the form [ 1+N N ]
## [ * 1+N ]
##
InstallMethod( Random,
"for a congruence subgroup CongruenceSubgroupGammaUpper1",
[ IsCongruenceSubgroupGammaUpper1 ],
0,
function( G )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := 1 + n * Random( [ -10 .. 10 ] );
b := n * Random( [ -10 .. 10 ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1 and IsInt( (gcd.coeff1-1)/n );
return [ [ a, b ],
[ -gcd.coeff2, gcd.coeff1 ] ];
end);
InstallOtherMethod( Random,
"for a congruence subgroup CongruenceSubgroupGammaUpper1",
[ IsCongruenceSubgroupGammaUpper1, IsPosInt ],
0,
function( G, m )
local n, a, b, gcd;
n := LevelOfCongruenceSubgroup( G );
repeat
a := 1 + n * Random( [ -m .. m ] );
b := n * Random( [ -m .. m ] );
gcd := Gcdex( a, b );
until gcd.gcd = 1 and IsInt( (gcd.coeff1-1)/n );
return [ [ a, b ],
[ -gcd.coeff2, gcd.coeff1 ] ];
end);
#############################################################################
##
#E
## congruence-1.2.3/lib/factor.g 0000664 0003717 0003717 00000017347 13503171577 017300 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W factor.gi The Congruence package Helena Verrill
##
##
#############################################################################
# it will be useful to find the maximum value of the labels
# though if space is not a problem, this could just return
# the Length of the labels.
__congruence_max_label:= function(L)
local s, i;
s:=1;
for i in [1..Length(L)] do
if (not L[i] = "even") and (not L[i] = "odd") and L[i] > s then
s := L[i];
fi;
od;
return s;
end;;
# For a list of labels L such as
# [1,3,4,7,4,7,3,1,"odd","even"], for reference, indices are:
# 1 2 3 4 5 6 7 8 9 10
# want to produce a list:
# [[9],[10],[1,8],[],[2,7],[3,5],...]
# this is the list of the form:
# [[all indices with L[x] = "odd"],[all indices with L[x] = "even"],
# [all indices with L[x] = 1], ....]
# assume L is a list of integers, or "odd" or "even".
__congruence_edgepairs := function(L)
local max, pairs, i;
pairs:=[];
max:=__congruence_max_label(L);
for i in [1..max+2] do
pairs[i] := [];
od;
for i in [1..Length(L)] do
if L[i]="odd" then
Add(pairs[1],i);
elif L[i]="even" then
Add(pairs[2],i);
else
Add(pairs[L[i]+2],i);
fi;
od;
return pairs;
end;;
# for each edge of a Farey Symbol, we compute the generator
# which maps that edge to another edge.
# (this is done at the same time as the fundamental
# domain is computed, but the data may not have been stored,
# and has to be recomputed; suggest change for a future version)
# this function gives "edge gluing matrices" as a number in the
# list of generators (gens); negative entries mean the inverse matrix,
# e.g., -5 would mean (5th generator)^(-1)
# (note, the list of labels in a Farey sequence says which edge is
# glued to which; -2 and -3 means there is an elliptic point order
# 2 or 3)
#
# the input is assumed to be a FareySymbol;
# another version of this function could take input to be the group
#
# Note, if the output of this function was
# stored as an attribute of the FareySymbol,
# then it would not have to be recomputed
#
__congruence_gluing_matrices := function(FS)
local cusps, gens, label_list, glue_list, l, i, index, gfs, labels, matrix;
# the following is a list of the cusps of the sequence,
# and other data extracted from the FareySymbol
gfs := GeneralizedFareySequence(FS);
labels := LabelsOfFareySymbol(FS);
gens := GeneratorsByFareySymbol( FS );
# make a list of which edges have a given label:
label_list := __congruence_edgepairs(labels);
# the following list will be what is finally returned,
# a list of integers as described above.
glue_list := [];
# make list of which generator joins two edges,
# in the non elliptic case
for i in [3..Length(label_list)] do
l := label_list[i];
matrix := MatrixByFreePairOfIntervals( gfs, l[1], l[2] );
index := PositionNthOccurrence( gens ,matrix,1);
if index = "fail" then
index := -PositionNthOccurrence(gens,matrix^(-1),1);
fi;
glue_list[l[1]] := index;
glue_list[l[2]] := -index;
od;
# Now deal with elliptic elements:
for i in label_list[1] do
matrix := MatrixByOddInterval( gfs, i );
index := PositionNthOccurrence(gens,matrix,1);
if index = "fail" then
index := -PositionNthOccurrence(gens,matrix^(-1),1);
glue_list[i] := -index;
else
glue_list[i] := -index;
fi;
od;
for i in label_list[2] do
matrix := MatrixByEvenInterval( gfs, i );
index := PositionNthOccurrence(gens,matrix,1);
if index = "fail" then
index := -PositionNthOccurrence(gens,matrix^(-1),1);
glue_list[i] := -index;
else
glue_list[i] := -index;
fi;
od;
return glue_list;
end;;
# following function determines which edge an image ImL of
# a domain is the longest
#
# The function either returns a index of an edge
# which is a number between 1 and #L-1,
# or it returns "overlap" meaning that there is overlap, but not equality.
__congruence_longest_edge := function(ImL)
local i, minImL, maxImL, maxindex, minindex;
for i in [1..Length(ImL)] do
if ImL[i] = infinity then
return "infinity";
fi;
od;
minImL := Minimum(ImL);
maxImL := Maximum(ImL);
maxindex := PositionNthOccurrence( ImL ,maxImL,1);
return maxindex;
end;;
# Need to be able to apply action of matrices to cusps
__congruence_fractionallineartransformation:= function(g,c)
local den, num;
if c = infinity then
if g[2][1] = 0 then
return infinity;
else
return g[1][1]/g[2][1];
fi;
else
num:=g[1][1]*c + g[1][2];
den:=g[2][1]*c + g[2][2];
if den = 0 then
return infinity;
else
return num/den;
fi;
fi;
end;;
__congruence_PSL2multiply := function(g,L)
local imL, i;
imL := [];
for i in [1..Length(L)] do
Add(imL,__congruence_fractionallineartransformation(g,L[i]));
od;
return imL;
end;;
# this an algorithm to determine a word for
# a given matrix g in G in terms of the generators:
find_word_ver2 := function(FS,glue_list,g)
local gens, L, ImL, done, word,letter,i, edge, h, maybesame, inf;
gens := GeneratorsByFareySymbol( FS );
L := GeneralizedFareySequence( FS );
ImL := __congruence_PSL2multiply(g,L);
word:=[];
h := g;
done := false;
while not done do;
edge := __congruence_longest_edge(ImL);
if edge = "infinity" then
# check equality of L and ImL:
maybesame := true;
i := 1;
while i < Length(L) and maybesame do
if not L[i] = ImL[i] then
maybesame := false;
fi;
i := i+1;
od;
if maybesame then
done := true;
return Reversed(word);
fi;
# now assume the domains are not equal
inf := PositionNthOccurrence( ImL , infinity ,1);
if inf = 1 and
ImL[2]L[2] then
return "g is not in the group";
elif
ImL[i+1]L[2] then
return "g is not in the group";
fi;
# now assume the domains do not overlap
if ImL[inf+1] >= L[2] then
letter := glue_list[inf];
elif inf = 1 then
letter := glue_list[Length(glue_list)];
else
letter := glue_list[inf-1];
fi;
Add(word,letter);
h:=h*gens[AbsoluteValue(letter)]^(-SignInt(letter));
ImL := __congruence_PSL2multiply(h,L);
else
# get next "letter" in the word for the matrix:
letter := glue_list[edge];
Add(word,letter);
h:=h*gens[AbsoluteValue(letter)]^(-SignInt(letter));
ImL := __congruence_PSL2multiply(h,L);
fi;
od;
return Reversed(word);
end;;
#############################################################################
#
# FactorizeMat( G, g )
#
__congruence_FactorizeMat := function( G, g )
return find_word_ver2( FareySymbol(G),
__congruence_gluing_matrices(FareySymbol(G)),
g );
end;
#############################################################################
#
# CheckFactorizeMat(gens,word)
#
# the following function is for testing purposes:
# gens is a list of generators, "word" a sequence of integers, none
# of which is bigger than the size of the list of generators.
# a word [4,6,-3] will return the product gens[4]*gens[6]*gens[3]^(-1)
#
__congruence_CheckFactorizeMat := function(gens,word)
local g, i;
g := [[1,0],[0,1]];
for i in word do
g := g*gens[AbsoluteValue(i)]^SignInt(i);
od;
return g;
end; congruence-1.2.3/lib/cong.g 0000664 0003717 0003717 00000017463 13503171577 016747 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W cong.g The Congruence package Ann Dooms
#W Eric Jespers
#W Alexander Konovalov
##
##
#############################################################################
#############################################################################
#
# CanEasilyCompareCongruenceSubgroups( G, H )
#
InstallMethod( CanEasilyCompareCongruenceSubgroups,
"for two congruence subgroups",
[ IsCongruenceSubgroup, IsCongruenceSubgroup ],
function ( G, H )
local i;
if ForAll( [ G, H ], IsPrincipalCongruenceSubgroup ) or
ForAll( [ G, H ], IsCongruenceSubgroupGamma0 ) or
ForAll( [ G, H ], IsCongruenceSubgroupGammaUpper0 ) or
ForAll( [ G, H ], IsCongruenceSubgroupGamma1 ) or
ForAll( [ G, H ], IsCongruenceSubgroupGammaUpper1 ) then
return LevelOfCongruenceSubgroup(G)=LevelOfCongruenceSubgroup(H);
elif ForAll( [ G, H ], IsIntersectionOfCongruenceSubgroups ) then
# we use the canonical ordering of subgroups
# in the intersection of congruence subgroups
if Length(DefiningCongruenceSubgroups(G)) <>
Length(DefiningCongruenceSubgroups(H)) then
return false;
else
return ForAll( [ 1 .. Length(DefiningCongruenceSubgroups(G)) ], i ->
CanEasilyCompareCongruenceSubgroups(
DefiningCongruenceSubgroups(G)[i],
DefiningCongruenceSubgroups(H)[i]) );
fi;
else
return false;
fi;
end);
#############################################################################
#
# CanReduceIntersectionOfCongruenceSubgroups( G, H )
#
# This function mimics the structure of the method for Intersection for
# congruence subgroups. It returns true, if their intersection can be reduced
# to one of the canonical congruence subgroups, and false otherwise, i.e. the
# intersection can be expressed only as IntersectionOfCongruenceSubgroups.
# This is used in IntersectionOfCongruenceSubgroups to reduce the list of
# canonical subgroups forming the intersection.
#
InstallMethod( CanReduceIntersectionOfCongruenceSubgroups,
"for two congruence subgroups",
[ IsCongruenceSubgroup, IsCongruenceSubgroup ],
function( G, H )
#
# Case 1 - at least one subgroup is an intersection of congruence subgroups
#
if IsIntersectionOfCongruenceSubgroups(G) or
IsIntersectionOfCongruenceSubgroups(H) then
return false;
#
# Case 2 - the diagonal (both subgroups has the same type)
#
elif IsPrincipalCongruenceSubgroup(G) and IsPrincipalCongruenceSubgroup(H) then
return true;
elif IsCongruenceSubgroupGamma1(G) and IsCongruenceSubgroupGamma1(H) then
return true;
elif IsCongruenceSubgroupGammaUpper1(G) and IsCongruenceSubgroupGammaUpper1(H) then
return true;
elif IsCongruenceSubgroupGamma0(G) and IsCongruenceSubgroupGamma0(H) then
return true;
elif IsCongruenceSubgroupGammaUpper0(G) and IsCongruenceSubgroupGammaUpper0(H) then
return true;
#
# Case 3 - Subgroups has different level
#
elif LevelOfCongruenceSubgroup(G) <> LevelOfCongruenceSubgroup(H) then
return false;
#
# Now subgroups have the same level
#
elif IsCongruenceSubgroupGamma1(G) and IsCongruenceSubgroupGamma0(H) then
return true;
elif IsCongruenceSubgroupGamma0(G) and IsCongruenceSubgroupGamma1(H) then
return true;
elif IsCongruenceSubgroupGammaUpper1(G) and IsCongruenceSubgroupGammaUpper0(H) then
return true;
elif IsCongruenceSubgroupGammaUpper0(G) and IsCongruenceSubgroupGammaUpper1(H) then
return true;
elif IsCongruenceSubgroupGamma0(G) and IsCongruenceSubgroupGammaUpper0(H) or IsCongruenceSubgroupGammaUpper0(G) and IsCongruenceSubgroupGamma0(H) then
return false;
else
return true;
fi;
end);
#############################################################################
#
# NumeratorOfGFSElement( gfs, i )
#
# Returns the numerator of the i-th term of the generalised Farey sequence
# gfs: for the 1st infinite entry returns -1, for the last one returns 1,
# for all other entries returns usual numerator.
#
InstallGlobalFunction( "NumeratorOfGFSElement",
function(gfs,i)
if i in [ 2 .. Length(gfs)-1 ] then
return NumeratorRat( gfs[i] );
elif i=1 then
return -1; # infinity on the left
elif i=Length(gfs) then
return 1; # infinity on the right
else
Error("There is no entry number ", i, " in !!! \n");
fi;
end);
#############################################################################
#
# DenominatorOfGFSElement( gfs, i )
#
# Returns the denominator of the i-th term of the generalised Farey sequence
# gfs: for both infinite entries returns 0, for the other ones returns usual
# denominator.
#
InstallGlobalFunction( "DenominatorOfGFSElement",
function(gfs,i)
if i in [ 2 .. Length(gfs)-1 ] then
return DenominatorRat( gfs[i] );
elif i=1 or i=Length(gfs) then
return 0;
else
Error("There is no entry number ", i, " in !!! \n");
fi;
end);
#############################################################################
#
# IsValidFareySymbol( fs )
#
# This function is used in FareySymbolByData to validate its output
#
InstallGlobalFunction( "IsValidFareySymbol" ,
function( fs )
local gfs, labels, n, i, t;
gfs := GeneralizedFareySequence(fs);
labels := LabelsOfFareySymbol(fs);
n := Length(gfs);
if ForAny( [ 1 .. Length(labels) ], t -> not IsBound(labels[t] ) ) then
Error(" must not contain holes !!! \n");
fi;
if Length(labels)<>n-1 then
Error("Lengths of and do not match !!! \n");
fi;
if gfs[1]<>infinity or gfs[n]<>infinity then
Error("First and last elements of must be infinity !!! \n");
fi;
if not 0 in gfs then
Error(" must contain at least one zero element !!! \n");
fi;
for i in [ 1 .. n-1 ] do
if NumeratorOfGFSElement(gfs,i+1) * DenominatorOfGFSElement(gfs,i) -
NumeratorOfGFSElement(gfs,i) * DenominatorOfGFSElement(gfs,i+1) <> 1 then
Error("a", i+1, "*b", i, " - a", i, "*b", i+1, " <> 1 !!! \n");
fi;
od;
if ForAny( Collected(labels), t -> IsInt(t[1]) and t[2]<>2 ) then
Error(" are not properly paired !!! \n");
fi;
return true;
end);
#############################################################################
#
# MatrixByEvenInterval( gfs, i )
#
InstallGlobalFunction( "MatrixByEvenInterval",
function(gfs,i)
local ai, bi, ai1, bi1;
ai := NumeratorOfGFSElement(gfs,i);
bi := DenominatorOfGFSElement(gfs,i);
ai1 := NumeratorOfGFSElement(gfs,i+1);
bi1 := DenominatorOfGFSElement(gfs,i+1);
return [ [ ai1*bi1 + ai*bi, -ai^2 - ai1^2 ],
[ bi^2 + bi1^2, -ai1*bi1 - ai*bi ] ];
end);
#############################################################################
#
# MatrixByOddInterval( gfs, i )
#
InstallGlobalFunction( "MatrixByOddInterval",
function(gfs,j)
local aj, bj, aj1, bj1;
aj := NumeratorOfGFSElement(gfs,j);
bj := DenominatorOfGFSElement(gfs,j);
aj1 := NumeratorOfGFSElement(gfs,j+1);
bj1 := DenominatorOfGFSElement(gfs,j+1);
return [ [ aj1*bj1 + aj*bj1 + aj*bj, -aj^2 - aj*aj1 - aj1^2 ],
[ bj^2 + bj*bj1 + bj1^2, -aj1*bj1 - aj1*bj - aj*bj ] ];
end);
#############################################################################
#
# MatrixByFreePairOfIntervals( gfs, k, kp )
#
InstallGlobalFunction( "MatrixByFreePairOfIntervals",
function(gfs,k,kp)
local ak, bk, ak1, bk1, akp, bkp, akp1, bkp1;
ak := NumeratorOfGFSElement(gfs,k);
bk := DenominatorOfGFSElement(gfs,k);
ak1 := NumeratorOfGFSElement(gfs,k+1);
bk1 := DenominatorOfGFSElement(gfs,k+1);
akp := NumeratorOfGFSElement(gfs,kp);
bkp := DenominatorOfGFSElement(gfs,kp);
akp1 := NumeratorOfGFSElement(gfs,kp+1);
bkp1 := DenominatorOfGFSElement(gfs,kp+1);
return [ [ akp1*bk1 + akp*bk, -akp*ak - akp1*ak1 ],
[ bkp*bk + bkp1*bk1, -ak1*bkp1 - ak*bkp ] ];
end);
#############################################################################
##
#E
##
congruence-1.2.3/lib/cong.gd 0000664 0003717 0003717 00000022357 13503171577 017111 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W cong.gd The Congruence package Ann Dooms
#W Eric Jespers
#W Alexander Konovalov
##
##
#############################################################################
#############################################################################
##
## InfoCongruence
##
## We declare new Info class for algorithms from the Congruence package. It
## has 3 levels - 0, 1 and 2. Default level is 1, and it is used to display
## messages when the package is used to replace existing GAP methods.
## To change Info level to k, use command SetInfoLevel(InfoCongruence, k)
DeclareInfoClass("InfoCongruence");
#############################################################################
##
## IsCongruenceSubgroup( )
##
## We create category of congruence subgroups as a subcategory of matrix
## groups, and declare properties that are used to distinguish several
## important classes of congruence subgroups
DeclareCategory( "IsCongruenceSubgroup", IsMatrixGroup );
#############################################################################
##
## IsPrincipalCongruenceSubgroup( )
##
## The principal congruence subgroup of level N consists of all matrices
## of the form [ 1+N N ]
## [ N 1+N ]
##
DeclareProperty( "IsPrincipalCongruenceSubgroup", IsCongruenceSubgroup );
InstallTrueMethod(IsCongruenceSubgroup, IsPrincipalCongruenceSubgroup);
#############################################################################
##
## IsCongruenceSubgroupGamma0( )
##
## The congruence subgroup CongruenceSubgroupGamma0(N) consists of all matrices
## of the form [ * * ]
## [ N * ]
##
DeclareProperty( "IsCongruenceSubgroupGamma0", IsCongruenceSubgroup );
InstallTrueMethod(IsCongruenceSubgroup, IsCongruenceSubgroupGamma0);
#############################################################################
##
## IsCongruenceSubgroupGammaUpper0( )
##
## The congruence subgroup CongruenceSubgroupGammaUpper0(N) consists of all matrices
## of the form [ * N ]
## [ * * ]
##
DeclareProperty( "IsCongruenceSubgroupGammaUpper0", IsCongruenceSubgroup );
InstallTrueMethod(IsCongruenceSubgroup, IsCongruenceSubgroupGammaUpper0);
#############################################################################
##
## IsCongruenceSubgroupGamma1( )
##
## The congruence subgroup CongruenceSubgroupGamma1(N) consists of all matrices
## of the form [ 1+N * ]
## [ N 1+N ]
##
DeclareProperty( "IsCongruenceSubgroupGamma1", IsCongruenceSubgroup );
InstallTrueMethod(IsCongruenceSubgroup, IsCongruenceSubgroupGamma1);
#############################################################################
##
## IsCongruenceSubgroupGammaUpper1( )
##
## The congruence subgroup CongruenceSubgroupGammaUpper1(N) consists of all matrices
## of the form [ 1+N N ]
## [ * 1+N ]
##
DeclareProperty( "IsCongruenceSubgroupGammaUpper1", IsCongruenceSubgroup );
InstallTrueMethod(IsCongruenceSubgroup, IsCongruenceSubgroupGammaUpper1);
#############################################################################
##
## IsCongruenceSubgroupGammaMN( )
##
## The congruence subgroup CongruenceSubgroupGammaMN(M,N) consists of all matrices
## of the form [ 1+M M ]
## [ N 1+N ]
##
DeclareProperty( "IsCongruenceSubgroupGammaMN", IsCongruenceSubgroup );
InstallTrueMethod(IsCongruenceSubgroup, IsCongruenceSubgroupGammaMN);
#############################################################################
##
## IsIntersectionOfCongruenceSubgroups( )
##
## This property will be uses for subgroups of SL_2(Z) that were constructed
## as intersection of a finite number of congruence subgroups of types
## CongruenceSubgroupGamma, CongruenceSubgroupGamma_0,
## CongruenceSubgroupGamma^0, CongruenceSubgroupGamma_1,
## CongruenceSubgroupGamma^1 and CongruenceSubgroupGammaMN
##
DeclareProperty( "IsIntersectionOfCongruenceSubgroups", IsCongruenceSubgroup );
InstallTrueMethod(IsCongruenceSubgroup, IsIntersectionOfCongruenceSubgroups);
#############################################################################
##
## PrincipalCongruenceSubgroup( n )
## CongruenceSubgroupGamma0( n )
## CongruenceSubgroupGammaUpper0( n )
## CongruenceSubgroupGamma1( n )
## CongruenceSubgroupGammaUpper1( n )
## CongruenceSubgroupGammaMN( m, n )
##
## Declaration of global functions - constructors of congruence subgroups
##
DeclareOperation("PrincipalCongruenceSubgroup", [IsPosInt]);
DeclareOperation("CongruenceSubgroupGamma0", [IsPosInt]);
DeclareOperation("CongruenceSubgroupGammaUpper0", [IsPosInt]);
DeclareOperation("CongruenceSubgroupGamma1", [IsPosInt]);
DeclareOperation("CongruenceSubgroupGammaUpper1", [IsPosInt]);
DeclareOperation("CongruenceSubgroupGammaMN", [IsPosInt,IsPosInt]);
#############################################################################
##
## LevelOfCongruenceSubgroup( )
##
## The (arithmetic) level of a congruence subgroup G is the smallest positive
## number N such that G contains the principal congruence subgroup of level N
##
DeclareAttribute( "LevelOfCongruenceSubgroup", IsCongruenceSubgroup );
#############################################################################
##
## LevelOfCongruenceSubgroupGammaMN( )
##
## For the congruence subgroup GammaMN we need to store additionally
## two integers determining the 1st and 2nd lines of the matrix
##
DeclareAttribute( "LevelOfCongruenceSubgroupGammaMN", IsCongruenceSubgroup );
#############################################################################
##
## IndexInSL2Z( )
##
## The index of a congruence subgroup in SL_2(Z) will be stored as its
## attribute. This also will allow us to install a method for Index(G,H) when
## G is SL_2(Z) and H is a congruence subgroup. You should remember that we
## are working with the SL_2(Z), because it is available in GAP, and not with
## the PSL_2(Z) since the latter is not implemented in GAP.
##
DeclareAttribute( "IndexInSL2Z", IsCongruenceSubgroup );
#############################################################################
##
## IntersectionOfCongruenceSubgroups( )
##
## We declare special type of congruence subgroups that are intersections of
## a finite number congruence subgroups of types CongruenceSubgroupGamma,
## CongruenceSubgroupGamma_0, CongruenceSubgroupGamma^0, CongruenceSubgroupGamma_1
## and CongruenceSubgroupGamma^1. The list of subgroups defining this
## intersection will be stored in the attribute "DefiningCongruenceSubgroups".
##
DeclareGlobalFunction("IntersectionOfCongruenceSubgroups");
DeclareAttribute( "DefiningCongruenceSubgroups",
IsCongruenceSubgroup );
#############################################################################
#
# CanEasilyCompareCongruenceSubgroups( G, H )
#
DeclareOperation( "CanEasilyCompareCongruenceSubgroups", [ IsCongruenceSubgroup, IsCongruenceSubgroup ] );
#############################################################################
#
# CanReduceIntersectionOfCongruenceSubgroups( G, H )
#
# This function mimics the structure of the method for Intersection for
# congruence subgroups. It returns true, if their intersection can be reduced
# to one of the canonical congruence subgroups, and false otherwise, i.e. the
# intersection can be expressed only as IntersectionOfCongruenceSubgroups.
# This is used in IntersectionOfCongruenceSubgroups to reduce the list of
# canonical subgroups forming the intersection.
#
DeclareOperation( "CanReduceIntersectionOfCongruenceSubgroups", [ IsCongruenceSubgroup, IsCongruenceSubgroup ] );
#############################################################################
#
# NumeratorOfGFSElement( gfs, i )
#
# Returns the numerator of the i-th term of the generalised Farey sequence
# gfs: for the 1st infinite entry returns -1, for the last one returns 1,
# for all other entries returns usual numerator.
#
DeclareGlobalFunction( "NumeratorOfGFSElement" );
#############################################################################
#
# DenominatorOfGFSElement( gfs, i )
#
# Returns the denominator of the i-th term of the generalised Farey sequence
# gfs: for both infinite entries returns 0, for the other ones returns usual
# denominator.
#
DeclareGlobalFunction( "DenominatorOfGFSElement" );
#############################################################################
#
# IsValidFareySymbol( fs )
#
# This function is used in FareySymbolByData to validate its output
#
DeclareGlobalFunction( "IsValidFareySymbol" );
#############################################################################
#
# MatrixByEvenInterval( gfs, i )
#
DeclareGlobalFunction( "MatrixByEvenInterval" );
#############################################################################
#
# MatrixByOddInterval( gfs, i )
#
DeclareGlobalFunction( "MatrixByOddInterval" );
#############################################################################
#
# MatrixByFreePairOfIntervals( gfs, k, kp )
#
DeclareGlobalFunction( "MatrixByFreePairOfIntervals" );
#############################################################################
##
#E
##
congruence-1.2.3/lib/farey.gi 0000664 0003717 0003717 00000026771 13503171577 017302 0 ustar gap-jenkins gap-jenkins #############################################################################
##
#W farey.gi The Congruence package Ann Dooms
#W Eric Jespers
#W Alexander Konovalov
##
##
#############################################################################
#############################################################################
##
## IsFareySymbolDefaultRep
##
DeclareRepresentation( "IsFareySymbolDefaultRep",
IsPositionalObjectRep,
[ 1, 2 ] );
#############################################################################
##
## FareySymbolByData( , )
##
## This constructor creates Farey symbol with the given generalized Farey
## sequence and list of labels. It also checks conditions from the definition
## of Farey symbol and returns an error if they are not satisfied
##
InstallMethod( FareySymbolByData,
"for two lists that are g.F.S. and labels for Farey symbol",
[ IsList, IsList ],
0,
function( gfs, labels)
local fs;
fs :=Objectify( NewType( NewFamily("FareySymbolsFamily", IsFareySymbol),
IsFareySymbol), [ gfs, labels ] );
if IsValidFareySymbol(fs) then
return fs;
else
Error(" is not a valid Farey symbol !!! \n");
fi;
end);
#############################################################################
##
## GeneralizedFareySequence( )
## LabelsOfFareySymbol( )
##
## The data used to create the Farey symbol are stored as its attributes
##
InstallMethod( GeneralizedFareySequence,
"for Farey symbol in default representation",
[ IsFareySymbol ],
fs -> fs![1]);
InstallMethod( LabelsOfFareySymbol,
"for Farey symbol in default representation",
[ IsFareySymbol ],
fs -> fs![2] );
#############################################################################
##
## ViewObj( fs )
## PrintObj( fs )
##
InstallMethod( ViewObj,
"for Farey symbol",
[ IsFareySymbol ],
0,
function(fs)
Print( GeneralizedFareySequence(fs), "\n",
LabelsOfFareySymbol(fs) );
end);
InstallMethod( PrintObj,
"for Farey symbol",
[ IsFareySymbol ],
0,
function(fs)
Print( "FareySymbolByData( ", GeneralizedFareySequence(fs),
", ", LabelsOfFareySymbol(fs), " ] " );
end);
#############################################################################
##
## FareySymbol( )
##
## For a subgroup of a finite index G, this attribute stores the
## corresponding Farey symbol. The algorithm for its computation must work
## with any matrix group for which the membership test is available
##
InstallMethod( FareySymbol,
"for a congruence subgroup",
[ IsCongruenceSubgroup ],
0,
function( G )
local gfs, # generalized Farey sequence (g.F.S.)
labels, # labels of this g.F.S.
fs, # resulting Farey symbol
i, j, k, t, # counters
stepnr, # number of the inductive ste
newvertex, # new vertex to be inserted on the current inductive step
unpairednr, # number of the 1st vertex of the unpaired side
lastlabel, # last used label
mat, # matrix by free pair of intervals
unpairednumbers, # list of positions with assigned labels
denominators, # denominators of current g.F.S. elements
possibledenominators, # list of denominators arising from these positions
minden, # minimum of possible denominators
pos, # chosen position of minden in possibledenominators
nrlabels, # number of labels assigned
range1, # range for the search of odd and even labels
range2, # range for the search of free (i.e.numerical) labels
isfirstlabelssearch; # flag for determining of the range1 and range2
#
# Initial data setup
#
if LevelOfCongruenceSubgroup(G)=1 then
return FareySymbolByData( [ infinity, 0, infinity ], ["even","odd"]) ;
fi;
gfs := [ infinity, 0, infinity ];
labels:=[];
nrlabels:=0;
stepnr:=0;
lastlabel:=0;
isfirstlabelssearch:=true;
#
# we perform the next loop until we will have fully labeled gfs
#
while nrlabels < Length( gfs ) - 1 do
stepnr:=stepnr+1;
Info( InfoCongruence, 2, "Step ", stepnr,
" : g.F.S. of length ", Length(gfs),
" with ", nrlabels, " labels");
Info( InfoCongruence, 3, " gfs = ", gfs );
Info( InfoCongruence, 3, "labels = ", labels );
#
# 1. Choose any of the unpaired sides and insert new vertex
#
# 1.1. Find unpaired side that will give us a new vertex
# with the minimal denominator (on the first step we
# do some trick to get [infinity,0,1,infinity])
unpairednumbers := Filtered( [ 1 .. Length(gfs)-1 ], i ->
not IsBound( labels[ i ] ) );
Info( InfoCongruence, 3, "Positions of unpaired labels : ", unpairednumbers );
# to avoid repeated calls of DenominatorOfGFSElement, we are caching
# values of denominators from required positions
denominators := [];
for i in unpairednumbers do
if not IsBound(denominators[i]) then
denominators[i]:=DenominatorOfGFSElement(gfs,i);
fi;
denominators[i+1]:=DenominatorOfGFSElement(gfs,i+1);
od;
possibledenominators := List( unpairednumbers, i ->
denominators[i] + denominators[i+1] );
Info( InfoCongruence, 3, "Possible denominators : ", possibledenominators );
minden := Minimum(possibledenominators);
# we give priority to positive numbers in g.F.S.
pos:=PositionProperty( [ 1 .. Length(unpairednumbers) ], i ->
( possibledenominators[i] = minden ) and
( NumeratorOfGFSElement( gfs, unpairednumbers[i] ) >=0 ) );
if pos=fail then
pos:=PositionProperty( [ 1 .. Length(unpairednumbers) ], i ->
possibledenominators[i] = minden );
fi;
unpairednr := unpairednumbers[ pos ];
#i:=1;
#repeat
# pos := PositionNthOccurrence( possibledenominators, minden, i );
# i := i+1;
# unpairednr := unpairednumbers[ pos ];
#until NumeratorOfGFSElement(gfs, unpairednr) >= 0;
#
# 1.2. Compute new vertex by the Farey sequence rule
#
newvertex := ( NumeratorOfGFSElement(gfs, unpairednr) +
NumeratorOfGFSElement(gfs, unpairednr+1) ) / minden;
#
# 1.3. Insert this new vertex and an empty spot for the label
#
Info( InfoCongruence, 2, "Inserting ", newvertex,
" at position ", unpairednr+1);
Add( gfs, newvertex, unpairednr+1);
Add( unpairednumbers, unpairednr, pos );
for i in [ pos+1 .. Length(unpairednumbers) ] do
unpairednumbers[i] := unpairednumbers[i]+1;
od;
Add( labels, "hole" , unpairednr );
Unbind(labels[unpairednr]);
#
# 2. For each of new sides, we check if they are paired and
# assign labels, if this is the case
#
if isfirstlabelssearch then
range1 := [ 1 .. Length(gfs)-1 ];
range2 := [ 1 .. Length(gfs)-1 ];
else
# if we already checked all cases for all possible labels,
# on each new step it is enough to check only new intervals
range1 := [ unpairednr, unpairednr+1 ];
# Slower but more obvious options for range2 could be:
# range2 := [ 1 .. Length(gfs)-1 ];
# range2:= Filtered( [ 1 .. Length(gfs)-1 ], i -> not IsBound( labels[ i ] ) );
# but we use the fastest one
range2 := unpairednumbers;
fi;
if not ( IsPrincipalCongruenceSubgroup(G) and
LevelOfCongruenceSubgroup(G) > 2 ) then
for i in range1 do
# we do not check that labels[i] is not bound because this is
# guaranteed by the algorithm
mat := MatrixByOddInterval( gfs, i );
if mat in G or -mat in G then
labels[i]:="odd";
nrlabels:=nrlabels+1;
Info( InfoCongruence, 2, "Putting label ", lastlabel,
" at position ", i );
else
mat := MatrixByEvenInterval( gfs, i );
if mat in G or -mat in G then
labels[i]:="even";
nrlabels:=nrlabels+1;
Info( InfoCongruence, 2, "Putting label ", lastlabel,
" at position ", i );
fi;
fi;
od;
fi;
for i in range1 do
for j in range2 do
# we eliminate the case i=j since we always check different intervals
# now we check that both labels[i] and labels[j] are not bound for a case
# if they were already assigned during the search for odd/even labels
if i<>j and not IsBound( labels[i] ) and not IsBound( labels[j] ) then
mat := MatrixByFreePairOfIntervals( gfs, i, j );
if mat in G or -mat in G then
lastlabel := lastlabel+1;
labels[i]:=lastlabel;
labels[j]:=lastlabel;
nrlabels:=nrlabels+2;
Info( InfoCongruence, 2, "Putting label ", lastlabel,
" at positions ", i, " and ", j );
# since i-th interval can be paired only with one j-th interval,
# we quit from inner loop and go to the next i
break;
fi;
fi;
od;
od;
isfirstlabelssearch:=false;
if stepnr mod 25000 = 0 then
Error("You reached the checkpoint on the ", stepnr, "th iteration \n",
"Currently you have g.F.S. of length ", Length(gfs),
" with ", nrlabels, " labels assigned \n",
"Use the index of the subgroup to get an idea about possible length of the g.F.S.:\n",
"it will be equal to the index of in PSL_2Z minus the number of odd intervals in g.F.S.\n");
fi;
od;
fs := FareySymbolByData( gfs, labels) ;
return fs;
end);
#############################################################################
#
# GeneratorsByFareySymbol( fs )
#
InstallGlobalFunction( GeneratorsByFareySymbol,
function( fs )
local gfs, labels, usedlabels, gens, i, j, m;
gfs := GeneralizedFareySequence(fs);
labels := LabelsOfFareySymbol(fs);
usedlabels:=[];
gens:=[];
for i in [ 1 .. Length(labels) ] do
if labels[i]="even" then
Info( InfoCongruence, 2, "labels[", i, "] = ", labels[i] );
m := MatrixByEvenInterval( gfs, i );
Add( gens, m );
if InfoLevel( InfoCongruence ) = 2 then
Display(m);
fi;
elif labels[i]="odd" then
Info( InfoCongruence, 2, "labels[", i, "] = ", labels[i] );
m := MatrixByOddInterval( gfs, i );
Add( gens, m );
if InfoLevel( InfoCongruence ) = 2 then
Display(m);
fi;
elif not labels[i] in usedlabels then
j := PositionNthOccurrence( labels, labels[i], 2 );
Info( InfoCongruence, 2, "labels[", i, "] = ", labels[i],
" = labels[", j, "]" );
m := MatrixByFreePairOfIntervals( gfs, i, j );
Add( gens, m );
Add( usedlabels, labels[i] );
if InfoLevel( InfoCongruence ) = 2 then
Display(m);
fi;
fi;
od;
return gens;
end);
#############################################################################
#
# IndexInPSL2ZByFareySymbol( fs )
#
# By the proposition 7.2 [Kulkarni], for the Farey symbol with underlying
# generalized Farey sequence { infinity, x0, x1, ..., xn, infinity }, the
# index in PSL_2(Z) is given by the formula d = 3*n + e3, where e3 is the
# number of odd intervals.
#
InstallGlobalFunction( IndexInPSL2ZByFareySymbol,
function( fs )
local n, e3, x, d;
n := Length( GeneralizedFareySequence(fs) ) - 3;
e3:= Number( LabelsOfFareySymbol(fs), x -> x = "odd" );
d := 3 * n + e3;
return d;
end);
#############################################################################
##
#E
##
congruence-1.2.3/lib/units.g 0000664 0003717 0003717 00000012626 13503171577 017157 0 ustar gap-jenkins gap-jenkins #############################################################################
#
# units.g The Congruence package Ann Dooms
# Eric Jespers
# Alexander Konovalov
#
#############################################################################
#############################################################################
#
# NormalSubgroupsForM2Q(G,H)
#
# Returns a list of normal subgroups N of G such that quotient G/N is H.
#
NormalSubgroupsForM2Q := function( G, H )
local ord,m, N;
ord:= Size(G)/Size(H);
# Can we speedup this computing only normal subgroups of given size?
m:=Filtered( NormalSubgroups(G) , N -> Size(N)=ord);
m:=Filtered( m, N -> IdGroup( G/N ) = IdGroup( H ) );
return m;
end;
#############################################################################
#
# GeneratorsInM2Q(G,H)
#
# Returns a list of lists of generators of a subgroup of f.i. in M_2(Q),
# one for each homomorphic image.
# H has to be S3 or D8!
#
GeneratorsInM2Q:=function(G,H)
local k,m;
if IdGroup(H)=[6,1] then
k:=3; # H = S_3
else
k:=4; # H = D_8
fi;
m:=NormalSubgroupsForM2Q(G,H);
if Length(m) > 0 then
return GeneratorsOfGroup( PrincipalCongruenceSubgroup(k*Size(G)/Size(H) ) );
else
return [ ];
fi;
end;
#############################################################################
#
# MatrixEntries( matrix, k )
#
# Returns a list with integer entries. Will be applied with k=4n or 3n.
# PROBLEM: some matrices gave non-integers! SOLUTION: multiplied with -I_2!
#
MatrixEntries := function( matrix, k )
local g11,g12,g21,g22;
g11:=(matrix[1][1]-1)/k;
if not IsInt(g11) then
matrix:=-matrix;
g11:=(matrix[1][1]-1)/k;
fi;
g12:=matrix[1][2]/k;
g21:=matrix[2][1]/k;
g22:=(matrix[2][2]-1)/k;
return [ g11, g12, g21, g22 ];
end;
#############################################################################
#
# D8Alpha(matrix,n)
#
# Returns a list with integer entries.
# Will be applied with n = order of the normal subgroup N determining M_2(Q).
#
D8Alpha := function(matrix,n)
local m,a0,a1,a2,a3;
m := MatrixEntries(matrix,4*n);
a0 := m[1] + m[4];
a1 := m[1] - m[2] + 2*m[3] - m[4];
a2 := m[1] + 2*m[3] - m[4];
a3 :=-m[1] + m[2] + m[4];
return [ a0, a1, a2, a3 ];
end;
#############################################################################
#
# S3Alpha(matrix,n)
#
# Returns a list with integer entries.
# Will be applied with n = order of the normal subgroup N determining M_2(Q).
#
S3Alpha:= function(matrix,n)
local m,a0,a1,a2,a3;
m := MatrixEntries(matrix,3*n);
a0 := m[1] + m[4];
a1 := 2*m[1] + 3*m[2] - m[3] - m[4];
a2 := -2*m[1] - 3*m[2] + m[3] + 2*m[4];
a3 := -m[1] - 3*m[2] + m[4];
return [ a0, a1, a2, a3 ];
end;
#############################################################################
#
# Alphas( G, H )
#
# Returns a list of lists with integer entries which will serve for the units in U(ZG).
#
Alphas := function( G, H )
local gen,f,alpha,i;
gen := GeneratorsInM2Q( G, H );
if IdGroup(H)=[6,1] then
f:=S3Alpha;
else
f:=D8Alpha;
fi;
alpha:=[];
if Length(gen) > 0 then
for i in [1..Length(gen)] do
alpha[i] := f( gen[i], Size(G)/Size(H) );
od;
fi;
return alpha;
end;
#############################################################################
#
# LiftGenerator(G,N)
#
# Lifts a minimal list of generators form G/N to G.
#
LiftGenerator := function( G, N )
local l,q,s,hom,i;
l:=[];
hom:=NaturalHomomorphismByNormalSubgroup(G,N);
q := Image( hom );
s := MinimalGeneratingSet( q );
for i in [ 1 .. Length(s) ] do
Add( l, PreImagesRepresentative( hom,s[i]) );
od;
return l;
end;
#############################################################################
#
# CreateUnits(G,H)
#
# Creates units of ZG. H must be D8 or S3.
#
CreateUnits:=function(G,H)
local m,alpha,a,b,x,y,ZG,emb,hat,u,i,j;
m:=NormalSubgroupsForM2Q(G,H);
alpha:=Alphas(G,H);
a:=[];
b:=[];
ZG:=GroupRing(Integers,G);
emb := Embedding(G,ZG);
hat:=[];
u:=[];
if Length(m)<>0 then
for i in [1..Length(m)] do
hat[i]:=Sum( List(m[i], x->x^emb));
u[i]:=[];
x := LiftGenerator(G,m[i])[1];
y := LiftGenerator(G,m[i])[2];
if x^2=Identity(G) then
a[i]:=y^emb;
b[i]:=x^emb;
else
a[i]:=x^emb;
b[i]:=y^emb;
fi;
if IdGroup(H)=[6,1] then
for j in [1..Length(alpha)] do
u[i][j]:=Identity(ZG) +
(alpha[j][1]*Identity(ZG) +
alpha[j][2]*a[i] +
alpha[j][3]*b[i] +
alpha[j][4]*a[i]^2*b[i])*(Identity(ZG)-a[i])*hat[i];
od;
else
for j in [1..Length(alpha)] do
u[i][j]:=Identity(ZG) +
(alpha[j][1]*Identity(ZG) +
alpha[j][2]*a[i] +
alpha[j][3]*b[i] +
alpha[j][4]*a[i]*b[i])*(Identity(ZG)-a[i]^2)*hat[i];
od;
fi;
od;
else
fi;
return u;
end;
#############################################################################
#
# UnitsOfZGOfFiniteIndexInM2Q(G)
#
UnitsOfZGOfFiniteIndexInM2Q:=
function(G)
local u,v;
u:=[];
v:=[];
if IsNilpotent(G)=true then
u:=CreateUnits(G,DihedralGroup(8));
else
u:=CreateUnits(G,DihedralGroup(8));
v:=CreateUnits(G,DihedralGroup(6));
fi;
return [u,v];
end; congruence-1.2.3/doc/chapBib_mj.html 0000664 0003717 0003717 00000010635 13503171577 020546 0 ustar gap-jenkins gap-jenkins
GAP (Congruence) - References
[CLLT93] Chan, S.-P., Lang, M.-L., Lim, C.-H. and Tan, S. P.,
Special polygons for subgroups of the modular group and
applications,
Internat. J. Math.,
4 (1)
(1993),
11--34.
[Kul91] Kulkarni, R. S.,
An arithmetic-geometric method in the study of the subgroups
of the modular group,
Amer. J. Math.,
113 (6)
(1991),
1053--1133.
[LLT95a] Lang, M.-L., Lim, C.-H. and Tan, S. P.,
An algorithm for determining if a subgroup of the modular
group is congruence,
J. London Math. Soc. (2),
51 (3)
(1995),
491--502.
[LLT95b] Lang, M.-L., Lim, C.-H. and Tan, S. P.,
Independent generators for congruence subgroups of Hecke
groups,
Math. Z.,
220 (4)
(1995),
569--594.
Congruence is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. For details, see the FSF's own site http://www.gnu.org/licenses/gpl.html.
If you obtained Congruence, we would be grateful for a short notification sent to one of the authors.
If you publish a result which was partially obtained with the usage of Congruence, please cite it in the following form:
We are very grateful to Mong-Lung Lang, Chong-Hai Lim and Ser Peow Tan for their comments provided while implementing algorithms from [LLT95a] and [LLT95b], and to Francqui Stichting (Belgium) for the support of the third author.
The package Congruence provides functions to construct several types of canonical congruence subgroups in SL_2(ℤ), and also intersections of a finite number of such subgroups. They will return a matrix group in the category IsCongruenceSubgroup, which is defined as a subcategory of IsMatrixGroup, and which will have a distinguishing property determining whether it is a congruence subgroup of one of the canonical types, or an intersection of such congruence subgroups (if it can not be reduced to one of the canonical congruence subgroups). To start to work with the package, you need first to load it as follows:
gap>LoadPackage("congruence");
-----------------------------------------------------------------------------
Loading Congruence 1.1.0 (Congruence subgroups of SL(2,Integers))
by Ann Dooms (http://homepages.vub.ac.be/~andooms),
Eric Jespers (http://homepages.vub.ac.be/~efjesper),
Alexander Konovalov (http://www.cs.st-andrews.ac.uk/~alexk/), and
Helena Verrill (http://www.math.lsu.edu/~verrill).
-----------------------------------------------------------------------------
true
2.1 Construction of congruence subgroups
2.1-1 PrincipalCongruenceSubgroup
‣ PrincipalCongruenceSubgroup( N )
( operation )
Returns the principal congruence subgroup Γ(N) of level N in SL_2(ℤ).
This subgroup consists of all matrices of the form
[1+N*a N*b]
[ N*c 1+N*d]
where a,b,c,d are integers. The returned group will have the property IsPrincipalCongruenceSubgroup (2.2-1).
Returns the congruence subgroup Γ_0(N) of level N in SL_2(ℤ).
This subgroup consists of all matrices of the form
[a b]
[N*c d]
where a,b,c,d are integers. The returned group will have the property IsCongruenceSubgroupGamma0 (2.2-2).
gap>G0_4:=CongruenceSubgroupGamma0(4);
<congruence subgroup CongruenceSubgroupGamma_0(4) in SL_2(Z)>
2.1-3 CongruenceSubgroupGammaUpper0
‣ CongruenceSubgroupGammaUpper0( N )
( operation )
Returns the congruence subgroup Γ^0(N) of level N in SL_2(ℤ).
This subgroup consists of all matrices of the form
[a N*b]
[c d]
where a,b,c,d are integers. The returned group will have the property IsCongruenceSubgroupGammaUpper0 (2.2-3).
gap>GU0_2:=CongruenceSubgroupGammaUpper0(2);
<congruence subgroup CongruenceSubgroupGamma^0(2) in SL_2(Z)>
2.1-4 CongruenceSubgroupGamma1
‣ CongruenceSubgroupGamma1( N )
( operation )
Returns the congruence subgroup Γ_1(N) of level N in SL_2(ℤ).
This subgroup consists of all matrices of the form
[1+N*a b]
[ N*c 1+N*d]
where a,b,c,d are integers. The returned group will have the property IsCongruenceSubgroupGamma1 (2.2-4).
gap>G1_6:=CongruenceSubgroupGamma1(6);
<congruence subgroup CongruenceSubgroupGamma_1(6) in SL_2(Z)>
2.1-5 CongruenceSubgroupGammaUpper1
‣ CongruenceSubgroupGammaUpper1( N )
( operation )
Returns the congruence subgroup Γ^1(N) of level N in SL_2(ℤ).
This subgroup consists of all matrices of the form
[1+N*a N*b]
[ c 1+N*d]
where a,b,c,d are integers. The returned group will have the property IsCongruenceSubgroupGammaUpper1 (2.2-5).
gap>GU1_4:=CongruenceSubgroupGammaUpper1(4);
<congruence subgroup CongruenceSubgroupGamma^1(4) in SL_2(Z)>
2.1-6 IntersectionOfCongruenceSubgroups
‣ IntersectionOfCongruenceSubgroups( G1, G2, ..., GN )
( function )
‣ Intersection( G1, G2, ..., GN )
( function )
Returns the intersection of its arguments, which can be congruence subgroups or their intersections, constructed with the same function. It is not necessary for the user to use IntersectionOfCongruenceSubgroups, since it will be called automatically from Intersection.
The returned group will have the property IsIntersectionOfCongruenceSubgroups (2.2-6).
The list of congruence subgroups that form the intersection can be obtained using DefiningCongruenceSubgroups (2.3-3). Note, that when the intersection appears to be one of the canonical congruence subgroups, the package will recognize this and will return a canonical subgroup of the appropriate type.
gap>I:=IntersectionOfCongruenceSubgroups(G0_4,GU1_4);
<principal congruence subgroup of level 4 in SL_2(Z)>
gap>J:=IntersectionOfCongruenceSubgroups(G0_4,G1_6);
<intersection of congruence subgroups of resulting level 12 in SL_2(Z)>
2.2 Properties of congruence subgroups
A congruence subgroup constructed by one of the five above listed functions will have certain properties determining its type. These properties will be used for method selection by Congruence algorithms. Note that they do not provide an actual test whether a certain matrix group is a congruence subgroup or not.
2.2-1 IsPrincipalCongruenceSubgroup
‣ IsPrincipalCongruenceSubgroup( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by PrincipalCongruenceSubgroup (2.1-1) (or reduced to one as a result of an intersection) and returns false otherwise.
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by CongruenceSubgroupGamma0 (2.1-2) (or reduced to one as a result of an intersection) and returns false otherwise.
2.2-3 IsCongruenceSubgroupGammaUpper0
‣ IsCongruenceSubgroupGammaUpper0( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by CongruenceSubgroupGammaUpper0 (2.1-3) (or reduced to one as a result of an intersection) and returns false otherwise.
2.2-4 IsCongruenceSubgroupGamma1
‣ IsCongruenceSubgroupGamma1( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by CongruenceSubgroupGamma1 (2.1-4) (or reduced to one as a result of an intersection) and returns false otherwise.
2.2-5 IsCongruenceSubgroupGammaUpper1
‣ IsCongruenceSubgroupGammaUpper1( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by CongruenceSubgroupGammaUpper1 (2.1-5) (or reduced to one as a result of an intersection) and returns false otherwise.
2.2-6 IsIntersectionOfCongruenceSubgroups
‣ IsIntersectionOfCongruenceSubgroups( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by IntersectionOfCongruenceSubgroups (2.1-6) and without being one of the canonical congruence subgroups, otherwise it returns false.
The next three attributes store key properties of congruence subgroups.
2.3-1 LevelOfCongruenceSubgroup
‣ LevelOfCongruenceSubgroup( G )
( attribute )
Stores the level of the congruence subgroup G. The (arithmetic) level of a congruence subgroup G is the smallest positive number N such that G contains the principal congruence subgroup of level N.
Stores the index of the congruence subgroup G in SL_2(ℤ).
gap>IndexInSL2Z(G_8);
384
gap>G_2:=PrincipalCongruenceSubgroup(2);
<principal congruence subgroup of level 2 in SL_2(Z)>
gap>IndexInSL2Z(G_2);
12
gap>IndexInSL2Z(GU1_4);
12
2.3-3 DefiningCongruenceSubgroups
‣ DefiningCongruenceSubgroups( G )
( attribute )
Returns: list of congruence subgroups
For an intersection of congruence subgroups, returns the list of congruence subgroups forming this intersection. For a canonical congruence subgroup returns a list of length one containing that subgroup.
gap>DefiningCongruenceSubgroups(J);
[ <congruence subgroup CongruenceSubgroupGamma_0(4) in SL_2(Z)>,
<congruence subgroup CongruenceSubgroupGamma_1(6) in SL_2(Z)> ]
gap>P:=PrincipalCongruenceSubgroup(6);
<principal congruence subgroup of level 6 in SL_2(Z)>
gap>Q:=PrincipalCongruenceSubgroup(10);
<principal congruence subgroup of level 10 in SL_2(Z)>
gap>G:=IntersectionOfCongruenceSubgroups(Q,P);
<principal congruence subgroup of level 30 in SL_2(Z)>
gap>DefiningCongruenceSubgroups(G);
[ <principal congruence subgroup of level 30 in SL_2(Z)> ]
2.4 Operations for congruence subgroups
Congruence installs several special methods for operations already available in GAP.
2.4-1 Random
‣ Random( G )
( operation )
‣ Random( G, m )
( operation )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns random element. In the two-argument form, the second parameter will control the absolute value of randomly selected entries of the matrix.
gap>Random(G_2) in G_2;
true
gap>Random(G_8,2) in G_8;
true
2.4-2 \in
‣ \in( m, G )
( operation )
It is easy to implement the membership test for congruence subgroups and their intersections.
For congruence subgroups G,H in the category IsCongruenceSubgroup, returns true if G and H are of the same type listed in PrincipalCongruenceSubgroup (2.1-1) --> CongruenceSubgroupGammaUpper1 (2.1-5) and have the same LevelOfCongruenceSubgroup (2.3-1) or if G and H are of the type IntersectionOfCongruenceSubgroups (2.1-6) and the groups from DefiningCongruenceSubgroups (2.3-3) are in one to one correspondence, otherwise it returns false.
Congruence provides methods for IsSubset for congruence subgroups. IsSubset returns true if H is a subset of G. These methods make it possible to use IsSubgroup operation for congruence subgroups.
If a congruence subgroup H is a subgroup of a congruence subgroup G, we can easily compute the index of H in G, since we know the index of both subgroups in SL_2(ℤ).
A Farey symbol is a compact and useful way to represent a subgroup of finite index in SL_2(ℤ) from which one can deduce independent generators for this subgroup. It consists of two components, namely a so-called generalised Farey sequence (gfs) and an ordered list of labels, giving additional structure to the gfs.
A generalised Farey sequence (g.F.S.) is an ordered list of the form -infinity, x_0, x_1, ... , x_n, infinity, where
1. the x_i = a_i/b_i are rational numbers in reduced form arranged in increasing order for i = 0, ... , n;
2. x_0, ... , x_n ∈ Z, and some x_i = 0;
3. we define x_-1=-infinity=-1/0 and x_n+1=infinity=1/0;
4. a_i+1b_i-a_ib_i+1=1 for i=-1, ... ,n.
The ordered list of labels of a Farey symbol gives an additional structure to the gfs. The labels correspond to each consecutive pair of x_i's and are of the following types:
1. even,
2. odd,
3. a natural number, which occurs in the list of labels exactly twice or not at all.
Note that the actual values of numerical labels are not important; it is the pairing of two intervals that matters.
The package Congruence provides functions to construct Farey symbols by the given generalised Farey sequence and corresponding list of labels. The returned Farey symbol will belong to the category IsFareySymbol and will have the representation IsFareySymbolDefaultRep.
3.1 Construction of Farey symbols
3.1-1 FareySymbolByData
‣ FareySymbolByData( gfs, labels )
( function )
This constructor creates the Farey symbol with the given generalized Farey sequence and list of labels. It also checks conditions from the definition of Farey symbol and returns an error if they are not satisfied. The data used to create the Farey symbol are stored as its attributes GeneralizedFareySequence (3.2-1) and LabelsOfFareySymbol (3.2-4).
Returns the numerator of the i-th term of the generalised Farey sequence gfs: for the 1st infinite entry returns -1, for the last one returns 1, for all other entries returns the usual numerator.
Returns the denominator of the i-th term of the generalised Farey sequence gfs: for both infinite entries returns 0, for the other ones returns the usual denominator.
The GAP package Congruence provides functions to construct several types of canonical congruence subgroups in \(SL_2(ℤ)\), and also intersections of a finite number of such subgroups.
Furthermore, it implements the algorithm for generating Farey symbols for congruence subgroups and using them to produce a system of independent generators for these subgroups.
Using the package, one can also determine indices of congruence subgroups and their intersections in \(SL_2(ℤ)\) and in other congruence subgroups, generate their random elements and check element memberships. Success of other group theoretical constructions mostly depends on whether they could be expressed in terms of group generators or not.
Congruence does not use external binaries and, therefore, works without restrictions on the operating system. It requires at least version GAP 4.5, and no compatibility with previous releases of GAP 4 is guaranteed.
Installation of the package is standard and follows the guidelines from the GAP manual (see Reference: Installing a GAP Package. After the package is installed, you can start GAP and load the Congruence package using the command:
A Farey symbol is a compact and useful way to represent a subgroup of finite index in \(SL_2(ℤ)\) from which one can deduce independent generators for this subgroup. It consists of two components, namely a so-called generalised Farey sequence (gfs) and an ordered list of labels, giving additional structure to the gfs.
A generalised Farey sequence (g.F.S.) is an ordered list of the form \({ -infinity, x_0, x_1, ... , x_n, infinity }\), where
1. the \(x_i = a_i/b_i\) are rational numbers in reduced form arranged in increasing order for \(i = 0, ... , n\);
2. \(x_0, ... , x_n \in Z\), and some \(x_i = 0\);
3. we define \(x_{-1}=-infinity=-1/0\) and \(x_{n+1}=infinity=1/0\);
4. \(a_{i+1}b_{i}-a_{i}b_{i+1}=1\) for \(i=-1, ... ,n\).
The ordered list of labels of a Farey symbol gives an additional structure to the gfs. The labels correspond to each consecutive pair of \(x_i\)'s and are of the following types:
1. even,
2. odd,
3. a natural number, which occurs in the list of labels exactly twice or not at all.
Note that the actual values of numerical labels are not important; it is the pairing of two intervals that matters.
The package Congruence provides functions to construct Farey symbols by the given generalised Farey sequence and corresponding list of labels. The returned Farey symbol will belong to the category IsFareySymbol and will have the representation IsFareySymbolDefaultRep.
3.1 Construction of Farey symbols
3.1-1 FareySymbolByData
‣ FareySymbolByData( gfs, labels )
( function )
This constructor creates the Farey symbol with the given generalized Farey sequence and list of labels. It also checks conditions from the definition of Farey symbol and returns an error if they are not satisfied. The data used to create the Farey symbol are stored as its attributes GeneralizedFareySequence (3.2-1) and LabelsOfFareySymbol (3.2-4).
Returns the numerator of the i-th term of the generalised Farey sequence gfs: for the 1st infinite entry returns -1, for the last one returns 1, for all other entries returns the usual numerator.
Returns the denominator of the i-th term of the generalised Farey sequence gfs: for both infinite entries returns 0, for the other ones returns the usual denominator.
congruence-1.2.3/doc/chapInd.txt 0000664 0003717 0003717 00000003313 13503171577 017744 0 ustar gap-jenkins gap-jenkins
[1XIndex[101X
[2X\in[102X 2.4-2
[2XCanEasilyCompareCongruenceSubgroups[102X 2.4-3
[5XCongruence[105X package .-1
[2XCongruenceSubgroupGamma0[102X 2.1-2
[2XCongruenceSubgroupGamma1[102X 2.1-4
[2XCongruenceSubgroupGammaUpper0[102X 2.1-3
[2XCongruenceSubgroupGammaUpper1[102X 2.1-5
[2XDefiningCongruenceSubgroups[102X 2.3-3
[2XDenominatorOfGFSElement[102X 3.2-3
[2XFareySymbol[102X 4.1-1
[2XFareySymbolByData[102X 3.1-1
[2XGeneralizedFareySequence[102X 3.2-1
[2XGeneratorsByFareySymbol[102X 4.2-4
[2XGeneratorsOfGroup[102X 4.2-5
[2XIndex[102X 2.4-5
[2XIndexInPSL2ZByFareySymbol[102X 4.3-1
[2XIndexInSL2Z[102X 2.3-2
[2XInfoCongruence[102X 5.1-1
[2XIntersection[102X 2.1-6
[2XIntersectionOfCongruenceSubgroups[102X 2.1-6
[10XIsCongruenceSubgroup[110X 1.1 2.
[2XIsCongruenceSubgroupGamma0[102X 2.2-2
[2XIsCongruenceSubgroupGamma1[102X 2.2-4
[2XIsCongruenceSubgroupGammaUpper0[102X 2.2-3
[2XIsCongruenceSubgroupGammaUpper1[102X 2.2-5
[10XIsFareySymbol[110X 3.
[10XIsFareySymbolDefaultRep[110X 3.
[2XIsIntersectionOfCongruenceSubgroups[102X 2.2-6
[2XIsPrincipalCongruenceSubgroup[102X 2.2-1
[2XIsSubset[102X 2.4-4
[2XIsValidFareySymbol[102X 3.1-2
[2XLabelsOfFareySymbol[102X 3.2-4
[2XLevelOfCongruenceSubgroup[102X 2.3-1
[2XMatrixByEvenInterval[102X 4.2-1
[2XMatrixByFreePairOfIntervals[102X 4.2-3
[2XMatrixByOddInterval[102X 4.2-2
[2XNumeratorOfGFSElement[102X 3.2-2
[2XPrincipalCongruenceSubgroup[102X 2.1-1
[2XRandom[102X 2.4-1
one and two argument versions 2.4-1
-------------------------------------------------------
congruence-1.2.3/doc/service.xml 0000664 0003717 0003717 00000001426 13503171577 020022 0 ustar gap-jenkins gap-jenkins Service functions of the &Congruence; packageAdditional information displayed by &Congruence; algorithmsInfoCongruence is a special Info class for &Congruence; algorithms.
It has 3 levels: 0, 1 (default) and 2. To change the info level to k,
use the command SetInfoLevel(InfoCongruence, k).
In the example below we use this mechanism to see more details during
the Farey symbol construction for a congruence subgroup.
congruence-1.2.3/doc/cong.xml 0000664 0003717 0003717 00000040446 13503171577 017315 0 ustar gap-jenkins gap-jenkins Construction of congruence subgroupsIsCongruenceSubgroup
The package &Congruence; provides functions to construct several
types of canonical congruence subgroups in SL_2(&ZZ;), and also
intersections of a finite number of such subgroups. They will return
a matrix group in the category IsCongruenceSubgroup,
which is defined as a subcategory of IsMatrixGroup, and
which will have a distinguishing property determining whether it is
a congruence subgroup of one of the canonical types, or an intersection
of such congruence subgroups (if it can not be reduced to one of the
canonical congruence subgroups).
To start to work with the package, you need first to load it as follows:
LoadPackage("congruence");
-----------------------------------------------------------------------------
Loading Congruence 1.1.0 (Congruence subgroups of SL(2,Integers))
by Ann Dooms (http://homepages.vub.ac.be/~andooms),
Eric Jespers (http://homepages.vub.ac.be/~efjesper),
Alexander Konovalov (http://www.cs.st-andrews.ac.uk/~alexk/), and
Helena Verrill (http://www.math.lsu.edu/~verrill).
-----------------------------------------------------------------------------
true
]]>
Construction of congruence subgroups
Returns the principal congruence subgroup \Gamma(N) of level N
in SL_2(&ZZ;).
This subgroup consists of
all matrices of the form
where a,b,c,d are integers.
The returned group will have the property
.
G_8:=PrincipalCongruenceSubgroup(8);
gap> IsGroup(G_8);
true
gap> IsMatrixGroup(G_8);
true
gap> DimensionOfMatrixGroup(G_8);
2
gap> MultiplicativeNeutralElement(G_8);
[ [ 1, 0 ], [ 0, 1 ] ]
gap> One(G);
[ [ 1, 0 ], [ 0, 1 ] ]
gap> [[1,2],[3,4]] in G_8;
false
gap> [[1,8],[8,65]] in G_8;
true
gap> SL_2:=SL(2,Integers);
SL(2,Integers)
gap> IsSubgroup(SL_2,G_8);
true
]]>
Returns the congruence subgroup \Gamma_0(N)
of level N in SL_2(&ZZ;).
This subgroup consists of
all matrices of the form
where a,b,c,d are integers.
The returned group will have the property
.
G0_4:=CongruenceSubgroupGamma0(4);
]]>
Returns the congruence subgroup \Gamma^0(N)
of level N in SL_2(&ZZ;).
This subgroup consists of
all matrices of the form
where a,b,c,d are integers.
The returned group will have the property
.
GU0_2:=CongruenceSubgroupGammaUpper0(2);
]]>
Returns the congruence subgroup \Gamma_1(N)
of level N in SL_2(&ZZ;).
This subgroup consists of
all matrices of the form
where a,b,c,d are integers.
The returned group will have the property
.
G1_6:=CongruenceSubgroupGamma1(6);
]]>
Returns the congruence subgroup \Gamma^1(N)
of level N in SL_2(&ZZ;).
This subgroup consists of
all matrices of the form
where a,b,c,d are integers.
The returned group will have the property
.
GU1_4:=CongruenceSubgroupGammaUpper1(4);
]]>
Returns the intersection of its arguments, which can be
congruence subgroups or their intersections, constructed
with the same function. It is not necessary for the user
to use IntersectionOfCongruenceSubgroups, since
it will be called automatically from Intersection.
The returned group will have the property
.
The list of congruence subgroups that form the intersection
can be obtained using .
Note, that when the intersection appears to be one of the
canonical congruence subgroups, the package will recognize
this and will return a canonical subgroup of the
appropriate type.
I:=IntersectionOfCongruenceSubgroups(G0_4,GU1_4);
gap> J:=IntersectionOfCongruenceSubgroups(G0_4,G1_6);
]]>
Properties of congruence subgroups
A congruence subgroup constructed by one of the five above listed functions
will have certain properties determining its type. These properties will be
used for method selection by &Congruence; algorithms. Note that they do not
provide an actual test whether a certain matrix group is a congruence subgroup
or not.
For a congruence subgroup G in the category
IsCongruenceSubgroup, returns true if G was
constructed by
(or reduced to one as a result of an intersection) and
returns false otherwise.
IsPrincipalCongruenceSubgroup(G_8);
true
gap> IsPrincipalCongruenceSubgroup(G0_4);
false
gap> IsPrincipalCongruenceSubgroup(I);
true
]]>
For a congruence subgroup G in the category
IsCongruenceSubgroup, returns true if
G was constructed by (or reduced to one as a result of an intersection)
and returns false otherwise.
For a congruence subgroup G in the category
IsCongruenceSubgroup, returns true if
G was constructed by (or reduced to one as a result of an intersection)
and returns false otherwise.
For a congruence subgroup G in the category
IsCongruenceSubgroup, returns true if
G was constructed by (or reduced to one as a result of an intersection)
and returns false otherwise.
For a congruence subgroup G in the category
IsCongruenceSubgroup, returns true if
G was constructed by (or reduced to one as a result of an intersection)
and returns false otherwise.
For a congruence subgroup G in the category
IsCongruenceSubgroup, returns true if
G was constructed by
and
without being one of the canonical congruence
subgroups, otherwise it returns false.
IsIntersectionOfCongruenceSubgroups(I);
false
gap> IsIntersectionOfCongruenceSubgroups(J);
true
]]>
Attributes of congruence subgroups
The next three attributes store key properties of congruence subgroups.
Stores the level of the congruence subgroup G. The (arithmetic) level of a congruence subgroup G is the smallest positive
number N such that G contains the principal congruence subgroup of level N.
LevelOfCongruenceSubgroup(G_8);
8
gap> LevelOfCongruenceSubgroup(G1_6);
6
gap> LevelOfCongruenceSubgroup(I);
4
gap> LevelOfCongruenceSubgroup(J);
12
]]>
Stores the index of the congruence subgroup G in SL_2(&ZZ;).
IndexInSL2Z(G_8);
384
gap> G_2:=PrincipalCongruenceSubgroup(2);
gap> IndexInSL2Z(G_2);
12
gap> IndexInSL2Z(GU1_4);
12
]]>
list of congruence subgroups
For an intersection of congruence subgroups, returns
the list of congruence subgroups forming this intersection.
For a canonical congruence subgroup returns a list of length
one containing that subgroup.
DefiningCongruenceSubgroups(J);
[ ,
]
gap> P:=PrincipalCongruenceSubgroup(6);
gap> Q:=PrincipalCongruenceSubgroup(10);
gap> G:=IntersectionOfCongruenceSubgroups(Q,P);
gap> DefiningCongruenceSubgroups(G);
[ ]
]]>
Operations for congruence subgroups
&Congruence; installs several special methods for operations already
available in &GAP;.
For a congruence subgroup G in the category
IsCongruenceSubgroup, returns random element.
In the two-argument form, the second parameter will
control the absolute value of randomly selected
entries of the matrix.
Random(G_2) in G_2;
true
gap> Random(G_8,2) in G_8;
true
]]>
It is easy to implement the membership test for
congruence subgroups and their intersections.
\in([ [ 21, 10 ], [ 2, 1 ] ],G_2);
true
gap> \in([ [ 21, 10 ], [ 2, 1 ] ],G_8);
false
]]>
For congruence subgroups G,H in the category
IsCongruenceSubgroup, returns true if
G and H are of the same type listed in
-->
and have the same
or if G and H
are of the type and
the groups from
are in one
to one correspondence, otherwise it returns false.
CanEasilyCompareCongruenceSubgroups(G_8,I);
false
]]>
&Congruence; provides methods for IsSubset
for congruence subgroups. IsSubset returns true
if H is a subset of G. These methods make it possible
to use IsSubgroup operation for congruence subgroups.
IsSubset(G_2,G_8);
true
gap> IsSubset(G_8,G_2);
false
gap> f:=[PrincipalCongruenceSubgroup,CongruenceSubgroupGamma1,CongruenceSubgroupGammaUpper1,CongruenceSubgroupGamma0,CongruenceSubgroupGammaUpper0];;
gap> g1:=List(f, t -> t(2));;
gap> g2:=List(f, t -> t(4));;
gap> for g in g2 do
> Print( List( g1, x -> IsSubgroup(x,g) ), "\n");
> od;
[ true, true, true, true, true ]
[ false, true, false, true, false ]
[ false, false, true, false, true ]
[ false, false, false, true, false ]
[ false, false, false, false, true ]
]]>
If a congruence subgroup H is a subgroup of a congruence
subgroup G, we can easily compute the index of H in
G, since we know the index of both subgroups in SL_2(&ZZ;).
Index(G_2,G_8);
32
]]>
congruence-1.2.3/doc/chap4.html 0000664 0003717 0003717 00000037100 13503171577 017523 0 ustar gap-jenkins gap-jenkins
GAP (Congruence) - Chapter 4: Farey symbols for congruence subgroups
The package Congruence provides functions to construct Farey symbols for finite index subgroups. The algorithm used in the package allows to construct a Farey symbol for any finite index subgroup of SL_2(ℤ) for which it is possible to check whether a given matrix belongs to this subgroup or not.
The development of an algorithm to determine the Farey symbol for a subgroup G of a finite index in SL_2(ℤ) was started by Ravi Kulkarni in [Kul91] and later it was improved by Mong-Lung Lang, Chong-Hai Lim and Ser-Peow Tan in [LLT95b], [LLT95a].
4.1 Computation of the Farey symbol for a finite index subgroup
4.1-1 FareySymbol
‣ FareySymbol( G )
( attribute )
For a subgroup of a finite index G, this attribute stores one of the Farey symbols corresponding to the congruence subgroup G. The algorithm for its computation will work for any matrix group for which a membership test is available.
4.2 Computation of generators of a finite index subgroup from its Farey symbol
If fs is the Farey symbol for a group G with r_1 even labels, r_2 odd labels and r_3 pairs of intervals, then G is generated by r_1+r_2+r_3 matrices, which form a set of independent generators for G. These matrices are constructed as follows:
for each even interval [x_i, x_i+1], take the matrix
By Proposition 7.2 in [Kulkarni], for the Farey symbol with underlying generalized Farey sequence [infinity, x0, x1, ..., xn, infinity], the index in PSL_2(Z) is given by the formula d = 3*n + e3, where e3 is the number of odd intervals.
congruence-1.2.3/doc/nocolorprompt.css 0000664 0003717 0003717 00000000313 13503171577 021261 0 ustar gap-jenkins gap-jenkins
/* colors for ColorPrompt like examples */
span.GAPprompt {
color: #000000;
font-weight: normal;
}
span.GAPbrkprompt {
color: #000000;
font-weight: normal;
}
span.GAPinput {
color: #000000;
}
congruence-1.2.3/doc/lefttoc.css 0000664 0003717 0003717 00000000474 13503171577 020014 0 ustar gap-jenkins gap-jenkins /* leftmenu.css Frank Lübeck */
/* Change default CSS to show section menu on left side */
body {
padding-left: 28%;
}
body.chap0 {
padding-left: 2%;
}
div.ChapSects div.ContSect:hover div.ContSSBlock {
left: 15%;
}
div.ChapSects {
left: 1%;
width: 25%;
}
congruence-1.2.3/doc/intro.xml 0000664 0003717 0003717 00000004041 13503171577 017511 0 ustar gap-jenkins gap-jenkins IntroductionGeneral aims of &Congruence; packageIsCongruenceSubgroup
The &GAP; package &Congruence; provides functions to construct several
types of canonical congruence subgroups in SL_2(&ZZ;), and also
intersections of a finite number of such subgroups.
Furthermore, it implements the algorithm for generating Farey symbols for
congruence subgroups and using them to produce a system of independent
generators for these subgroups.
Using the package, one can also determine indices of congruence subgroups and
their intersections in SL_2(&ZZ;) and in other congruence subgroups,
generate their random elements and check element memberships. Success of other
group theoretical constructions mostly depends on whether they could be
expressed in terms of group generators or not.
For the theoretical backround, we refer to ,
, and .
Installation and system requirements
&Congruence; is distributed in standard formats (tar.gz,
tar.bz2, -win.zip) and can be obtained from
http://www.cs.st-andrews.ac.uk/~alexk/congruence/.
&Congruence; does not use external binaries and, therefore, works without
restrictions on the operating system.
It requires at least version &GAP; 4.5, and no compatibility with
previous releases of &GAP; 4 is guaranteed.
Installation of the package is standard and follows the guidelines from the
&GAP; manual (see .
After the package is installed, you can start &GAP; and load
the &Congruence; package using the command:
LoadPackage("congruence");
]]>
congruence-1.2.3/doc/chap2_mj.html 0000664 0003717 0003717 00000100722 13503171577 020210 0 ustar gap-jenkins gap-jenkins
GAP (Congruence) - Chapter 2: Construction of congruence subgroups
The package Congruence provides functions to construct several types of canonical congruence subgroups in \(SL_2(ℤ)\), and also intersections of a finite number of such subgroups. They will return a matrix group in the category IsCongruenceSubgroup, which is defined as a subcategory of IsMatrixGroup, and which will have a distinguishing property determining whether it is a congruence subgroup of one of the canonical types, or an intersection of such congruence subgroups (if it can not be reduced to one of the canonical congruence subgroups). To start to work with the package, you need first to load it as follows:
gap>LoadPackage("congruence");
-----------------------------------------------------------------------------
Loading Congruence 1.1.0 (Congruence subgroups of SL(2,Integers))
by Ann Dooms (http://homepages.vub.ac.be/~andooms),
Eric Jespers (http://homepages.vub.ac.be/~efjesper),
Alexander Konovalov (http://www.cs.st-andrews.ac.uk/~alexk/), and
Helena Verrill (http://www.math.lsu.edu/~verrill).
-----------------------------------------------------------------------------
true
2.1 Construction of congruence subgroups
2.1-1 PrincipalCongruenceSubgroup
‣ PrincipalCongruenceSubgroup( N )
( operation )
Returns the principal congruence subgroup \(\Gamma(N)\) of level N in \(SL_2(ℤ)\).
This subgroup consists of all matrices of the form
[1+N*a N*b]
[ N*c 1+N*d]
where \(a\),\(b\),\(c\),\(d\) are integers. The returned group will have the property IsPrincipalCongruenceSubgroup (2.2-1).
Returns the congruence subgroup \(\Gamma_0(N)\) of level N in \(SL_2(ℤ)\).
This subgroup consists of all matrices of the form
[a b]
[N*c d]
where \(a\),\(b\),\(c\),\(d\) are integers. The returned group will have the property IsCongruenceSubgroupGamma0 (2.2-2).
gap>G0_4:=CongruenceSubgroupGamma0(4);
<congruence subgroup CongruenceSubgroupGamma_0(4) in SL_2(Z)>
2.1-3 CongruenceSubgroupGammaUpper0
‣ CongruenceSubgroupGammaUpper0( N )
( operation )
Returns the congruence subgroup \(\Gamma^0(N)\) of level N in \(SL_2(ℤ)\).
This subgroup consists of all matrices of the form
[a N*b]
[c d]
where \(a\),\(b\),\(c\),\(d\) are integers. The returned group will have the property IsCongruenceSubgroupGammaUpper0 (2.2-3).
gap>GU0_2:=CongruenceSubgroupGammaUpper0(2);
<congruence subgroup CongruenceSubgroupGamma^0(2) in SL_2(Z)>
2.1-4 CongruenceSubgroupGamma1
‣ CongruenceSubgroupGamma1( N )
( operation )
Returns the congruence subgroup \(\Gamma_1(N)\) of level N in \(SL_2(ℤ)\).
This subgroup consists of all matrices of the form
[1+N*a b]
[ N*c 1+N*d]
where \(a\),\(b\),\(c\),\(d\) are integers. The returned group will have the property IsCongruenceSubgroupGamma1 (2.2-4).
gap>G1_6:=CongruenceSubgroupGamma1(6);
<congruence subgroup CongruenceSubgroupGamma_1(6) in SL_2(Z)>
2.1-5 CongruenceSubgroupGammaUpper1
‣ CongruenceSubgroupGammaUpper1( N )
( operation )
Returns the congruence subgroup \(\Gamma^1(N)\) of level N in \(SL_2(ℤ)\).
This subgroup consists of all matrices of the form
[1+N*a N*b]
[ c 1+N*d]
where \(a\),\(b\),\(c\),\(d\) are integers. The returned group will have the property IsCongruenceSubgroupGammaUpper1 (2.2-5).
gap>GU1_4:=CongruenceSubgroupGammaUpper1(4);
<congruence subgroup CongruenceSubgroupGamma^1(4) in SL_2(Z)>
2.1-6 IntersectionOfCongruenceSubgroups
‣ IntersectionOfCongruenceSubgroups( G1, G2, ..., GN )
( function )
‣ Intersection( G1, G2, ..., GN )
( function )
Returns the intersection of its arguments, which can be congruence subgroups or their intersections, constructed with the same function. It is not necessary for the user to use IntersectionOfCongruenceSubgroups, since it will be called automatically from Intersection.
The returned group will have the property IsIntersectionOfCongruenceSubgroups (2.2-6).
The list of congruence subgroups that form the intersection can be obtained using DefiningCongruenceSubgroups (2.3-3). Note, that when the intersection appears to be one of the canonical congruence subgroups, the package will recognize this and will return a canonical subgroup of the appropriate type.
gap>I:=IntersectionOfCongruenceSubgroups(G0_4,GU1_4);
<principal congruence subgroup of level 4 in SL_2(Z)>
gap>J:=IntersectionOfCongruenceSubgroups(G0_4,G1_6);
<intersection of congruence subgroups of resulting level 12 in SL_2(Z)>
2.2 Properties of congruence subgroups
A congruence subgroup constructed by one of the five above listed functions will have certain properties determining its type. These properties will be used for method selection by Congruence algorithms. Note that they do not provide an actual test whether a certain matrix group is a congruence subgroup or not.
2.2-1 IsPrincipalCongruenceSubgroup
‣ IsPrincipalCongruenceSubgroup( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by PrincipalCongruenceSubgroup (2.1-1) (or reduced to one as a result of an intersection) and returns false otherwise.
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by CongruenceSubgroupGamma0 (2.1-2) (or reduced to one as a result of an intersection) and returns false otherwise.
2.2-3 IsCongruenceSubgroupGammaUpper0
‣ IsCongruenceSubgroupGammaUpper0( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by CongruenceSubgroupGammaUpper0 (2.1-3) (or reduced to one as a result of an intersection) and returns false otherwise.
2.2-4 IsCongruenceSubgroupGamma1
‣ IsCongruenceSubgroupGamma1( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by CongruenceSubgroupGamma1 (2.1-4) (or reduced to one as a result of an intersection) and returns false otherwise.
2.2-5 IsCongruenceSubgroupGammaUpper1
‣ IsCongruenceSubgroupGammaUpper1( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by CongruenceSubgroupGammaUpper1 (2.1-5) (or reduced to one as a result of an intersection) and returns false otherwise.
2.2-6 IsIntersectionOfCongruenceSubgroups
‣ IsIntersectionOfCongruenceSubgroups( G )
( property )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns true if G was constructed by IntersectionOfCongruenceSubgroups (2.1-6) and without being one of the canonical congruence subgroups, otherwise it returns false.
The next three attributes store key properties of congruence subgroups.
2.3-1 LevelOfCongruenceSubgroup
‣ LevelOfCongruenceSubgroup( G )
( attribute )
Stores the level of the congruence subgroup G. The (arithmetic) level of a congruence subgroup G is the smallest positive number N such that G contains the principal congruence subgroup of level N.
Stores the index of the congruence subgroup G in \(SL_2(ℤ)\).
gap>IndexInSL2Z(G_8);
384
gap>G_2:=PrincipalCongruenceSubgroup(2);
<principal congruence subgroup of level 2 in SL_2(Z)>
gap>IndexInSL2Z(G_2);
12
gap>IndexInSL2Z(GU1_4);
12
2.3-3 DefiningCongruenceSubgroups
‣ DefiningCongruenceSubgroups( G )
( attribute )
Returns: list of congruence subgroups
For an intersection of congruence subgroups, returns the list of congruence subgroups forming this intersection. For a canonical congruence subgroup returns a list of length one containing that subgroup.
gap>DefiningCongruenceSubgroups(J);
[ <congruence subgroup CongruenceSubgroupGamma_0(4) in SL_2(Z)>,
<congruence subgroup CongruenceSubgroupGamma_1(6) in SL_2(Z)> ]
gap>P:=PrincipalCongruenceSubgroup(6);
<principal congruence subgroup of level 6 in SL_2(Z)>
gap>Q:=PrincipalCongruenceSubgroup(10);
<principal congruence subgroup of level 10 in SL_2(Z)>
gap>G:=IntersectionOfCongruenceSubgroups(Q,P);
<principal congruence subgroup of level 30 in SL_2(Z)>
gap>DefiningCongruenceSubgroups(G);
[ <principal congruence subgroup of level 30 in SL_2(Z)> ]
2.4 Operations for congruence subgroups
Congruence installs several special methods for operations already available in GAP.
2.4-1 Random
‣ Random( G )
( operation )
‣ Random( G, m )
( operation )
For a congruence subgroup G in the category IsCongruenceSubgroup, returns random element. In the two-argument form, the second parameter will control the absolute value of randomly selected entries of the matrix.
gap>Random(G_2) in G_2;
true
gap>Random(G_8,2) in G_8;
true
2.4-2 \in
‣ \in( m, G )
( operation )
It is easy to implement the membership test for congruence subgroups and their intersections.
For congruence subgroups G,H in the category IsCongruenceSubgroup, returns true if G and H are of the same type listed in PrincipalCongruenceSubgroup (2.1-1) --> CongruenceSubgroupGammaUpper1 (2.1-5) and have the same LevelOfCongruenceSubgroup (2.3-1) or if G and H are of the type IntersectionOfCongruenceSubgroups (2.1-6) and the groups from DefiningCongruenceSubgroups (2.3-3) are in one to one correspondence, otherwise it returns false.
Congruence provides methods for IsSubset for congruence subgroups. IsSubset returns true if H is a subset of G. These methods make it possible to use IsSubgroup operation for congruence subgroups.
If a congruence subgroup H is a subgroup of a congruence subgroup G, we can easily compute the index of H in G, since we know the index of both subgroups in \(SL_2(ℤ)\).
5.1 Additional information displayed by Congruence algorithms
5.1-1 InfoCongruence
‣ InfoCongruence
( info class )
InfoCongruence is a special Info class for Congruence algorithms. It has 3 levels: 0, 1 (default) and 2. To change the info level to k, use the command SetInfoLevel(InfoCongruence, k).
In the example below we use this mechanism to see more details during the Farey symbol construction for a congruence subgroup.
[CLLT93] Chan, S.-P., Lang, M.-L., Lim, C.-H. and Tan, S. P.,
Special polygons for subgroups of the modular group and
applications,
Internat. J. Math.,
4 (1)
(1993),
11--34.
[Kul91] Kulkarni, R. S.,
An arithmetic-geometric method in the study of the subgroups
of the modular group,
Amer. J. Math.,
113 (6)
(1991),
1053--1133.
[LLT95a] Lang, M.-L., Lim, C.-H. and Tan, S. P.,
An algorithm for determining if a subgroup of the modular
group is congruence,
J. London Math. Soc. (2),
51 (3)
(1995),
491--502.
[LLT95b] Lang, M.-L., Lim, C.-H. and Tan, S. P.,
Independent generators for congruence subgroups of Hecke
groups,
Math. Z.,
220 (4)
(1995),
569--594.
Congruence is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. For details, see the FSF's own site http://www.gnu.org/licenses/gpl.html.
If you obtained Congruence, we would be grateful for a short notification sent to one of the authors.
If you publish a result which was partially obtained with the usage of Congruence, please cite it in the following form:
We are very grateful to Mong-Lung Lang, Chong-Hai Lim and Ser Peow Tan for their comments provided while implementing algorithms from [LLT95a] and [LLT95b], and to Francqui Stichting (Belgium) for the support of the third author.
The package Congruence provides functions to construct Farey symbols for finite index subgroups. The algorithm used in the package allows to construct a Farey symbol for any finite index subgroup of \(SL_2(ℤ)\) for which it is possible to check whether a given matrix belongs to this subgroup or not.
The development of an algorithm to determine the Farey symbol for a subgroup G of a finite index in \(SL_2(ℤ)\) was started by Ravi Kulkarni in [Kul91] and later it was improved by Mong-Lung Lang, Chong-Hai Lim and Ser-Peow Tan in [LLT95b], [LLT95a].
4.1 Computation of the Farey symbol for a finite index subgroup
4.1-1 FareySymbol
‣ FareySymbol( G )
( attribute )
For a subgroup of a finite index G, this attribute stores one of the Farey symbols corresponding to the congruence subgroup G. The algorithm for its computation will work for any matrix group for which a membership test is available.
4.2 Computation of generators of a finite index subgroup from its Farey symbol
If fs is the Farey symbol for a group \(G\) with \(r_1\) even labels, \(r_2\) odd labels and \(r_3\) pairs of intervals, then \(G\) is generated by \(r_1+r_2+r_3\) matrices, which form a set of independent generators for \(G\). These matrices are constructed as follows:
for each even interval \([x_i, x_{i+1}]\), take the matrix
By Proposition 7.2 in [Kulkarni], for the Farey symbol with underlying generalized Farey sequence [infinity, x0, x1, ..., xn, infinity], the index in \(PSL_2(Z)\) is given by the formula d = 3*n + e3, where e3 is the number of odd intervals.
The GAP package Congruence provides functions to construct several types of canonical congruence subgroups in SL_2(ℤ), and also intersections of a finite number of such subgroups.
Furthermore, it implements the algorithm for generating Farey symbols for congruence subgroups and using them to produce a system of independent generators for these subgroups.
Using the package, one can also determine indices of congruence subgroups and their intersections in SL_2(ℤ) and in other congruence subgroups, generate their random elements and check element memberships. Success of other group theoretical constructions mostly depends on whether they could be expressed in terms of group generators or not.
Congruence does not use external binaries and, therefore, works without restrictions on the operating system. It requires at least version GAP 4.5, and no compatibility with previous releases of GAP 4 is guaranteed.
Installation of the package is standard and follows the guidelines from the GAP manual (see Reference: Installing a GAP Package. After the package is installed, you can start GAP and load the Congruence package using the command:
5.1 Additional information displayed by Congruence algorithms
5.1-1 InfoCongruence
‣ InfoCongruence
( info class )
InfoCongruence is a special Info class for Congruence algorithms. It has 3 levels: 0, 1 (default) and 2. To change the info level to k, use the command SetInfoLevel(InfoCongruence, k).
In the example below we use this mechanism to see more details during the Farey symbol construction for a congruence subgroup.
congruence-1.2.3/doc/gens.xml 0000664 0003717 0003717 00000021456 13503171577 017323 0 ustar gap-jenkins gap-jenkins Farey symbols for congruence subgroups
The package &Congruence; provides functions to construct Farey symbols
for finite index subgroups. The algorithm used in the package allows
to construct a Farey symbol for any finite index subgroup of SL_2(&ZZ;)
for which it is possible to check whether a given matrix belongs to this
subgroup or not.
The development of an algorithm to determine the Farey symbol for a
subgroup G of a finite index in SL_2(&ZZ;) was started by Ravi
Kulkarni in and later it was improved by Mong-Lung Lang,
Chong-Hai Lim and Ser-Peow Tan in , .
Computation of the Farey symbol for a finite index subgroup
For a subgroup of a finite index G, this attribute stores one of the
Farey symbols corresponding
to the congruence subgroup G. The algorithm for its computation will work
for any matrix group for which a membership test is available.
FareySymbol(PrincipalCongruenceSubgroup(8));
[ infinity, 0, 1/4, 1/3, 3/8, 2/5, 1/2, 3/5, 5/8, 2/3, 3/4, 1, 5/4, 4/3,
11/8, 7/5, 3/2, 8/5, 13/8, 5/3, 7/4, 2, 9/4, 7/3, 19/8, 12/5, 5/2, 13/5,
21/8, 8/3, 11/4, 3, 13/4, 10/3, 27/8, 17/5, 7/2, 18/5, 29/8, 11/3, 15/4, 4,
17/4, 13/3, 9/2, 14/3, 19/4, 5, 21/4, 16/3, 11/2, 17/3, 23/4, 6, 25/4,
19/3, 13/2, 20/3, 27/4, 7, 29/4, 22/3, 15/2, 23/3, 31/4, 8, infinity ]
[ 1, 17, 10, 26, 32, 18, 19, 27, 30, 5, 2, 2, 13, 28, 26, 20, 21, 29, 27, 7,
3, 3, 16, 31, 28, 22, 23, 33, 29, 9, 4, 4, 5, 30, 31, 24, 25, 32, 33, 12,
6, 6, 7, 19, 18, 15, 8, 8, 9, 21, 20, 10, 11, 11, 12, 23, 22, 13, 14, 14,
15, 25, 24, 16, 17, 1 ]
gap> FareySymbol(CongruenceSubgroupGamma0(20));
[ infinity, 0, 1/5, 1/4, 2/7, 3/10, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5, 1,
infinity ]
[ 1, 3, 4, 6, 7, 7, 5, 2, 2, 3, 6, 4, 5, 1 ]
]]>
Computation of generators of a finite index subgroup from its Farey symbol
If fs is the Farey symbol for a group G with r_1 even
labels, r_2 odd labels and r_3 pairs of intervals, then G is
generated by r_1+r_2+r_3 matrices, which form a set of independent
generators for G. These matrices are constructed as follows:
for each even interval [x_i, x_{i+1}], take the matrix
for each odd interval [x_j,x_{j+1}], take the matrix
for each pair of free intervals [x_k,x_{k+1}] and
[x_s,x_{s+1}], take the matrix
Returns the matrix corresponding to the even interval i in the generalized Farey sequence gfs.
H:=CongruenceSubgroupGamma0(5);
gap> fs:=FareySymbol(H);
[ infinity, 0, 1/2, 1, infinity ]
[ 1, "even", "even", 1 ]
gap> gfs:=GeneralizedFareySequence(fs);
[ infinity, 0, 1/2, 1, infinity ]
gap> MatrixByEvenInterval(gfs,2);
[ [ 2, -1 ], [ 5, -2 ] ]
]]>
Returns the matrix corresponding to the odd interval i in the generalized Farey sequence gfs.
fs_oo:=FareySymbolByData([infinity,0,infinity],["odd","odd"]);;
gap> gfs_oo:=GeneralizedFareySequence(fs_oo);
[ infinity, 0, infinity ]
gap> MatrixByOddInterval(gfs_oo,1);
[ [ -1, -1 ], [ 1, 0 ] ]
]]>
Returns the matrix corresponding to the pair of free intervals k and kp in the generalized Farey sequence gfs.
fs_free:=FareySymbolByData([infinity,0,1,2,infinity],[1,2,2,1]);;
gap> gfs_free:=GeneralizedFareySequence(fs_free);;
gap> MatrixByFreePairOfIntervals(gfs_free,2,3);
[ [ 3, -2 ], [ 2, -1 ] ]
]]>
Returns a set of matrices constructed as above.
fs_eo:=FareySymbolByData([infinity,0,infinity],["even","odd"]);;
gap> GeneratorsByFareySymbol(last);
[ [ [ 0, -1 ], [ 1, 0 ] ], [ [ 0, -1 ], [ 1, -1 ] ] ]
gap> GeneratorsByFareySymbol(fs);
[ [ [ 1, 1 ], [ 0, 1 ] ], [ [ 2, -1 ], [ 5, -2 ] ], [ [ 3, -2 ], [ 5, -3 ] ] ]
gap> GeneratorsByFareySymbol(fs_oo);
[ [ [ -1, -1 ], [ 1, 0 ] ], [ [ 0, -1 ], [ 1, -1 ] ] ]
gap> GeneratorsByFareySymbol(fs_free);
[ [ [ 1, 2 ], [ 0, 1 ] ], [ [ 3, -2 ], [ 2, -1 ] ] ]
]]>
Returns a set of generators for the finite index group G in SL_2(Z).
G:=PrincipalCongruenceSubgroup(2);
gap> FareySymbol(G);
[ infinity, 0, 1, 2, infinity ]
[ 2, 1, 1, 2 ]
gap> GeneratorsOfGroup(G);
#I Using the Congruence package for GeneratorsOfGroup ...
[ [ [ 1, 2 ], [ 0, 1 ] ], [ [ 3, -2 ], [ 2, -1 ] ] ]
gap> H:=CongruenceSubgroupGamma0(5);
gap> GeneratorsOfGroup(H);
#I Using the Congruence package for GeneratorsOfGroup ...
[ [ [ 1, 1 ], [ 0, 1 ] ], [ [ 2, -1 ], [ 5, -2 ] ], [ [ 3, -2 ], [ 5, -3 ] ] ]
gap> I:=IntersectionOfCongruenceSubgroups(PrincipalCongruenceSubgroup(2),CongruenceSubgroupGamma0(3));
gap> FareySymbol(I);
[ infinity, 0, 1/3, 1/2, 2/3, 1, 4/3, 3/2, 5/3, 2, infinity ]
[ 1, 5, 4, 3, 2, 2, 3, 4, 5, 1 ]
gap> GeneratorsOfGroup(I);
#I Using the Congruence package for GeneratorsOfGroup ...
[ [ [ 1, 2 ], [ 0, 1 ] ], [ [ 11, -2 ], [ 6, -1 ] ],
[ [ 19, -8 ], [ 12, -5 ] ], [ [ 17, -10 ], [ 12, -7 ] ],
[ [ 7, -6 ], [ 6, -5 ] ] ]
]]>
Other properties derived from Farey symbols
By Proposition 7.2 in [Kulkarni], for the Farey symbol with underlying
generalized Farey sequence [infinity, x0, x1, ..., xn, infinity], the
index in PSL_2(Z) is given by the formula d = 3*n + e3, where e3 is the
number of odd intervals.
IndexInPSL2ZByFareySymbol(fs);
6
gap> IndexInPSL2ZByFareySymbol(fs_oo);
2
gap> IndexInPSL2ZByFareySymbol(fs_free);
6
]]>
congruence-1.2.3/doc/chapInd_mj.html 0000664 0003717 0003717 00000014704 13503171577 020565 0 ustar gap-jenkins gap-jenkins
GAP (Congruence) - Index