File: simple.gd

package info (click to toggle)
gap 4r8p6-2
  • links: PTS
  • area: main
  • in suites: stretch
  • size: 33,476 kB
  • ctags: 7,663
  • sloc: ansic: 108,841; xml: 47,807; sh: 3,628; perl: 2,342; makefile: 796; asm: 62; awk: 6
file content (137 lines) | stat: -rw-r--r-- 4,830 bytes parent folder | download | duplicates (3)
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
#############################################################################
##
#W  simple.gd                 GAP Library                    Alexander Hulpke
##
##
#Y  Copyright (C) 2011 The GAP Group
##
##  This file contains basic constructions for 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 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 who do not have a permutation representation of small degree the
##  ATLASREP package might need to be installed to construct theses 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 an (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 simple groups, starting
##  at order <A>start</A> if specified, up to order <M>10^{18}</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");


#############################################################################
##
#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);

#############################################################################
##
#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 woth to try the `SmallerDegree'
##  reduction.
##  <#/GAPDoc>
DeclareGlobalFunction("SufficientlySmallDegreeSimpleGroupOrder");