forked from gap-system/gap
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathsimple.gd
141 lines (132 loc) · 5.02 KB
/
simple.gd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#############################################################################
##
## This file is part of GAP, a system for computational discrete algebra.
## This file's authors include Alexander Hulpke.
##
## Copyright of GAP belongs to its developers, whose names are too numerous
## to list here. Please refer to the COPYRIGHT file for details.
##
## SPDX-License-Identifier: GPL-2.0-or-later
##
## This file contains basic constructions for nonabelian simple groups of bounded size,
## if necessary by calling the `atlasrep' package.
##
#############################################################################
##
#F SimpleGroup( <id> [,<param1>[,<param2>[] )
##
## <#GAPDoc Label="SimpleGroup">
## <ManSection>
## <Func Name="SimpleGroup" Arg='id [,param]'/>
##
## <Description>
## This function will construct <B>an</B> instance of the specified nonabelian simple group.
## Groups are specified via their name in ATLAS style notation, with parameters added
## if necessary. The intelligence applied to parsing the name is limited, and at the
## moment no proper extensions can be constructed.
## For groups which do not have a permutation representation of small degree
## the <Package>AtlasRep</Package> package might need to be installed
## to construct these groups.
## <Example><![CDATA[
## gap> g:=SimpleGroup("M(23)");
## M23
## gap> Size(g);
## 10200960
## gap> g:=SimpleGroup("PSL",3,5);
## PSL(3,5)
## gap> Size(g);
## 372000
## gap> g:=SimpleGroup("PSp6",2);
## PSp(6,2)
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction("SimpleGroup");
#############################################################################
##
#F EpimorphismFromClassical( <G> )
##
## <#GAPDoc Label="EpimorphismFromClassical">
## <ManSection>
## <Func Name="EpimorphismFromClassical" Arg='G'/>
##
## <Description>
## For a nonabelian (almost) simple group this homomorphsim will try to construct an
## epimorphism from a classical group onto it (or return fail if it does
## not work or is not yet implemented).
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction("EpimorphismFromClassical");
#############################################################################
##
#F SimpleGroupsIterator( [<start>,<end>] )
##
## <#GAPDoc Label="SimpleGroupsIterator">
## <ManSection>
## <Func Name="SimpleGroupsIterator" Arg='[start[,end]]'/>
##
## <Description>
## This function returns an iterator that will run over all nonabelian simple groups, starting
## at order <A>start</A> if specified, up to order <M>10^{27}</M> (or -- if specified
## -- order <A>end</A>). If the option <A>NOPSL2</A> is given, groups of type
## <M>PSL_2(q)</M> are omitted.
## <Example><![CDATA[
## gap> it:=SimpleGroupsIterator(20000);
## <iterator>
## gap> List([1..8],x->NextIterator(it));
## [ A8, PSL(3,4), PSL(2,37), PSp(4,3), Sz(8), PSL(2,32), PSL(2,41),
## PSL(2,43) ]
## gap> it:=SimpleGroupsIterator(1,2000);;
## gap> l:=[];;for i in it do Add(l,i);od;l;
## [ A5, PSL(2,7), A6, PSL(2,8), PSL(2,11), PSL(2,13) ]
## gap> it:=SimpleGroupsIterator(20000,100000:NOPSL2);;
## gap> l:=[];;for i in it do Add(l,i);od;l;
## [ A8, PSL(3,4), PSp(4,3), Sz(8), PSU(3,4), M12 ]
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
DeclareGlobalFunction("SimpleGroupsIterator");
BindGlobal("SIMPLE_GROUPS_ITERATOR_RANGE",10^27);
#############################################################################
##
#F ClassicalIsomorphismTypeFiniteSimpleGroup(<G>] )
##
## <#GAPDoc Label="ClassicalIsomorphismTypeFiniteSimpleGroup">
## <ManSection>
## <Func Name="ClassicalIsomorphismTypeFiniteSimpleGroup" Arg='G'/>
## This function returns a result equivalent to (and based on)
## <Ref Func="IsomorphismTypeInfoFiniteSimpleGroup"/>, but returns a
## classically names series (consistent with
## <Ref Func="SimpleGroup"/>) and the parameter always in a list. This makes it
## easier to parse the result.
## <Description>
## <Example><![CDATA[
## gap> ClassicalIsomorphismTypeFiniteSimpleGroup(SimpleGroup("O+",8,2));
## rec( parameter := [ 8, 2 ], series := "O+" )
## gap> IsomorphismTypeInfoFiniteSimpleGroup(SimpleGroup("O+",8,2));
## rec( name := "D(4,2) = O+(8,2)", parameter := [ 4, 2 ], series := "D" )
## ]]></Example>
## </Description>
## </ManSection>
## <#/GAPDoc>
DeclareGlobalFunction("ClassicalIsomorphismTypeFiniteSimpleGroup");
DeclareAttribute("DataAboutSimpleGroup",IsGroup,"mutable");
#############################################################################
##
#F SufficientlySmallDegreeSimpleGroupOrder(n)
##
## <#GAPDoc Label="SufficientlySmallDegreeSimpleGroupOrder">
## <ManSection>
## <Func Name="SufficientlySmallDegreeSimpleGroupOrder" Arg='n'/>
## For an order <M>n</M> this function returns a heuristic bound for a
## small permutation degree of a simple group of that exact order.
## This function
## can be used to decide whether it is worth to try the `SmallerDegree'
## reduction.
## <#/GAPDoc>
DeclareGlobalFunction("SufficientlySmallDegreeSimpleGroupOrder");