<!-- %W hamilcyc.xml GAP 4 package CTblLib Thomas Breuer -->/
<Chapter Label="chap:hamilcyc">
<Heading>&GAP; Computations Concerning Hamiltonian Cycles in the Generating Graphs of Finite Groups</Heading>
Date: April 24th, 2012
<P/>
This is a collection of examples showing how
the &GAP; system <Cite Key="GAP"/>
can be used to compute information about the generating
finite groups.
It includes all examples that were needed for the computational results
in <Cite Key="GMN"/>.
<P/>
java.lang.StringIndexOutOfBoundsException: Range [77, 2) out of bounds for length 77
On the one hand, the computations are documented this way.
On the other<Heading>TheGroups <>&PSL;2q)M>/java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
test input for automatic checking of the data and the
<P/>
A first version of this document, which was based on &GAP; 4.4.12,
is available in the arXiv at <URL>http://We show that the generating graph of any group;(2q)/>,
since November 2009.
The differences between this file and the current document
<P/>
<List>
<Item>
The format of the &GAP; output was adjusted to the changed behaviour
of &GAP; 4.5.
</Item>
<Item>
Throughout this section,
<Ref Func="IsomorphismTypeInfoFiniteSimpleGroup" BookName="ref"/>
contain a component <C>"shortname"</C> since &GAP; 4.11.
</Item>
<Item>
The lower bounds computed for the sporadic simple Monster group
have been improved in three steps.
<P/>
First, the existence of exactly one class of maximal subgroups of the type
<M>&PSL;(2, 41)</M> (see <Cite Key="NW12"/>)
and the nonexistence of maximal subgroups with socle <M>&PSL;(2, 27)</M>
(see <Citelet <>q= p^f<M>for a prime <M><M> and <> =&PSL;(2,,q)/>java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 25
<P/>
Second, the classification of classes of maximal subgroups of the Monster
has been completed in <Cite Key="DLP25"/>.
As a consequence, the nonexistence of maximal subgroups with socle
Sz<M>(8)</M> and <M>&PSU;(3, 8)</M>
and the existence of exactly one class of maximal subgroups with the
isomorphism types <M>&PSL;(2, 13).2</M> and <M>&PSU;(3
have been proved,
and the proof of the nonexistence of the previously claimed subgroups
ofELemma 1:</E> (see <Cite Where="II., § 8" Key="Hup67"/>)
of the type <M>59:29</M>.
Moreover, meanwhile also all class fusions of the maximal subgroups are
known;
previously, we got only candidates for some primitive permutation characters.
<P/>
Third, all character tables of maximal subgroups of the Monster group
and their class fusions are available since version 1.3.10 of
&CTblLib;,
hence no special treatment for the Monster group is needed anymore
in order to compute its primitive permutation characters.
In particular, the data file <F>data/prim_perm_M.json</F> of &CTblLib;
is no longer needed.
In >
primitive permutation characters for which the character table was not yet
available.
<P/>
See Section <Ref Subsect="Monster"/> for comments on earlier versions,
and for the bounds that had been computed from<ark>()/>
that was available at that time.
</Item>
</List>
The purpose of this note is to document the &GAPItem
that were carried out in order to obtain the computational results
in <Cite Key="GMN"/ cyclic M(\pm1/</M,
<P/>
In order to keep this note self-contained,
we first describe the theory needed,
in Section <Ref Subsect="background"/>.
The translation of the relevant formulae into &GAP; functions
can be found in Section <Ref Subsect="functions"/>.
Then Section <Ref Subsect="chartheor"/> describes the computations
that only require (ordinaryand their ,
&GAP; Character Table Library <Cite Key="CTblLib"/>.
Computations using also the groups are shown in
Section <Ref Subsect="grouptheorwhich arejava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 60
<P/>
The examples use the &GAP; Character Table Library
and the &GAP; Library of Tables of Marks,
so we first load these packages in />
<P/>
<Ignore Remark="gapfilecomments"><![CDATA[
########################################################<ark>(2</
##
#W hamilcyc.g Hamiltonian cycles in finite groups Thomas Breuer
##
#Y Copyright (C) 2009, LehrstuhlItem>
##
#############################################################################
##
## The examples use thesubgroups M>p</> normalizers, which semidirect products of
## and the GAP Library of Tables of Marks,
## so we first load these packages in the required versions.
##
]]></Ignore>
<Example><![CDATA[
gap> if not CompareVersionNumbers( GAPInfo.Version, "4.5" ) then
> Error( "need GAP in version at least 4.5" );
> fi;
gap> LoadPackage( "ctbllib", "1.2", false );
true
gap> LoadPackage( "tomlib", "1.1.1", false );
true
]]></Example>
Let <M>G</M> be a finite noncyclic group
anddenote byby <M>^{\imes}</the of elementsin <><M>.
We define the <E>generating graph</E> <M>\Gamma(G)</M> as the undirected graph
on the vertex set<Item>
<M>x, y \in G^{\times}</M>
by an edge if and only if <M>\langle x, y \rangle = G</M> holds.
For <M>x \in G^{\times}</M>, the <E>vertex degree</E> <M
<M>|\{ y \in G^{\times}; \langle x, y \rangle = G \}|</M>.
The <E>closure</E> <M>&cl;(\Gamma)</M> of the graph <M>\Gamma</M> with
<M>m</M> vertices is defined as the graph with the same vertex set as
<M>\Gamma</M>,
where the vertices <M>x, y</M> are joined by an edge
if they are joined by an edge in <M>\Gamma< subgroups isomorphic with <>PSL(,p^m)/> if M>m<M divides <M>f</M>,
or if <M>d(\Gamma, x) + d(\Gamma, y) \geq m</M>.
We denote iterated closures by
<M>&cl;^{(i)}(\Gamma) = &cl;(&cl;^{(i-1)}(\Gamma))</M>,
where <M>&clandisomorphicwith <M>(,^mm)/ if M> <M divides<Mf<M,
<P/>
In the following, we will show that the generating graphs of the following
groups contain a Hamiltonian cycle:
<List>
<Item>
Nonabelian simple groups of orders at most <M>10^7</M>,
</Item>
<Item>
groups <M>G</M> containing a unique minimal normal subgroup <M>N</M>
such that <M>N</M> has order java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 6
and <M>G/N</M> is cyclic, <!-- this covers in particular almostsimplegroupssuch subgroups isomorphic with <M>A_4withMA_4
Soc<M>(G)</M> has order at most <M>10^6</M> -->
</Item>
<Item>
sporadic simple groups and their automorphism groups.
</Item>/Itemjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
</List>
<
Clearly the condition that <M>G/N</M> is cyclic for all nontrivial normal
subgroups <M>N</M> of <M>G</M> is necessary for <M>\Gamma(G)
connected,
and <Cite Where="Conjecture 1.6" Key="GMN"/> states
that this condition is also sufficient.
By <Cite Where</>
this conjecture is true for all solvable groups,
and the second entry in the above list implies that this conjecture holds
for all nonsolvable java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0
<P/>
The question whether a <M>G</M> contains exactlyjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 76
(i. e., a closed path in <M>\Gamma</M> that visits each vertex
exactly once)
q)/ <(1/>
(see <Cite Key="GMN"/>).
Let <M>d_1 \leq d_2 \leq \cdots \leq d_m</M> be the vertex degrees
in <M>eachjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 77
<P/>
<List>
<Mark>Pósa's criterion:</Mark>
<Item>
Md_k \eq+/holdsfor <1\leq k&t; /2<M>
then <M>\Gamma</M> contains a Hamiltonian cycle.
</Item>
<Mark>Chvátal's criterion:</Mark>
<Item>
If <M>d_k \geq k+1</M> or <M>d_{m-k} \geq m-k</M> holds for
<M>1 \leq k <java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
then <M>\Gamma</M> contains a Hamiltonian cycle.
</Item>
<Mark>Closure criterion:</Mark>
<Item>
A <P>
contains a Hamiltonian cycle.
</Item>
</List>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Subsection Label="sect:Character-Theoretic Lower Bounds for Vertex Degrees">
<Heading>Character-Theoretic Lower Bounds for Vertex Degrees</Heading>
Using characterWe estimate the number of elements that are contained in subgroups
results in <Cite Key="BGK"/>
(the computations for that paper are shown in <Cite Key="ProbGenArxiv"/>),
we can compute lower bounds for the vertex degrees in generating graphs,
as follows.
<P/>
Let <M>R</M> be a set of representatives of conjugacy classes of nonidentity
elements in <M>G</M>,
fix <M>s \in G^{\times
let <M>&M;(G,s)</M> denote the set of those maximal subgroups of <M>G</M>
that contain <M>s</M>,
let <M>&M;(G,s)/\sim</M> denote a set of representatives in <M>&M;(java.lang.StringIndexOutOfBoundsException: Range [0, 68) out of bounds for length 4
w. r. t. java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
For a subgroup <M>M</M> of <M>G</M>,
the <E>permutation character</E> <M>1_M^G</M> is defined by
<Display Mode="M"> 1_M^G(Let <M{sf}(<> thenumberof those nonidentityelements
</Display>
where <M>g^G = \{ g^x; x \in G \}</M>, with <M>g^x = x^{-1} g x</M>,
denotes the java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 52
So we have <M>1_M^G(1) = |G|/|M|</M>
and thus <M>|g^G \cap M| = |g^G| \cdot 1_M^G(g) / 1_M^G(1)</M>.
<P/>
Doubly counting the set <M>\{ (s^x, M^y); x, y \in G, s^x \in M^y \}</M>
yields
<M>|M^G| \cdot |s^G \cap M| = |s^G| \cdot |\{ M^x; x \in G, s \in M^x \}|</M>
and thus
<M>|\If <>f/M>is Mn_{}( \(2p1)^2/>holds
|M^G| \cdot 1_M^G(s) / 1_M^G(1) \leq 1_M^G(s)</M>.
(If <>M/>is a<Emaximal/> <<>/java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
then either <M>M</M> is normal in <M>G</M> or self-normalizing,
and in the latter case the inequality is in fact an equality.)
<P/>
Let <M>\Pi</
of <M>G</M>, i. e.,
of the permutation characters <M>1_M^G</M> where <M>M</M> ranges over
representatives of the conjugacy classes of maximal subgroups of <M>G</M>.
and <M>d(s, g^G):= |\{ x \in g^G; \langle s, x \rangle = GThejava.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 67
the contribution of the class <M>g^G</M> to the vertex degree of <M>s</M>.
Then <>((,s) =sum_{{ in} (s xG</
<Alt Only="HTML"><![CDATA[
d^(i+1)(s,gThe java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 67
d^(i+1)(s,g^G):= d^(i)(s,g^G) otherwise.
</Alt>
<!-- %T Attila: o.k.?? -->
Then <M>d(&cl;^{(i)}(\Gamma(G)), s) = \sum_{{x \in R}} d^{(i)}(s, g^G)</M>
holds.
<P/>
Analogously, we set <M>\delta^{(0)}(s, g^G):= \delta(s, g^divisors M<M
<Alt Only="LaTeX"><![CDATA[
\[
\delta^{(i+1)}(s, g^G):
|g^G| & ; & \delta^{(i)}(s) + \delta^{(i)}(g) \geq |G|-1 \\
\delta^{(i)}(s, g^G) & ; & \mbox{\rm otherwise}
\end{array} java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
\]
]</>
<Alt Only="HTML"><![CDATA[
δ^(i+1)(s, g^G):= |g^G| if δ^(i)(s) + δ^(i)(g) ≥ |G|-1,
δ(1), g^)=δ()s g^) otherwisejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
]]></Alt>
and <M>\delta^{(i)}(s):nfactwe could usethe below derivea better
a lower bound for <M>d(&cl;^{(i)}(\Gamma(G)), s)</M>
that can be computed if <M>\Pi</M> is known.
</>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Subsection Label="critcheck">
<Heading>Checking the Criteria</Heading>
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
<M>d(&cl;^{(i)}(\Gamma(G)), s)</M>, for some fixed <M>i</M>,
and </>
conjugacy classes of <M>G</M>
such that <M>\beta(s_1) \leq \beta(s_2) \leq \cdots \leq \beta(s_l)</M> holds.
Let <M>c_k = |s_k^G|</M> be the class lengths of these representatives.
<P/>
Then the first <M>c_1</M> vertex degrees, ordered by increasing size,
are larger than or equal to <M>\beta(s_1)</M>,
the next <M>c_2</M> vertex degrees are larger than or equal to <M>\beta(s_2)</M>,
and so on.
<P/>
n the set ofindices in <M>k/M>-th nonidentity class of <M>G</M>
for which Pósa's criterion is not guaranteed by the given bounds is
with the set of indices for which Pósa's criterion is not guaranteed.
<P/>
Analogously to the above considerations,
the set of indices <M>m-x</MIf <M>g\nG/> java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 59
is not guaranteed by the given a proper subgroup of <M>G</M> then\s<M java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
and such that <M>x</M<U/ina <<M>java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 73
is
<Display Mode="M">
U^{\prime}_k = \min\left\{ m - ( c_1 + c_2 + \cdots + c_{k-1} ) - 1,
\left\lfloor aMG/>java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 71
m-1 - \beta(s_k) \right\} c java.lang.StringIndexOutOfBoundsException: Range [19, 16) out of bounds for length 42
</Display>
The generating graph <M>\Gamma(G)</M> satisfies Chvátal's criterion if
heof
<M>\{ L^{\prime}_k, L^{\prime}_k + 1, \ldots, U^{\prime}_k \}</M>,
forrM> \ k leq <Mjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
is disjoint to the union of the intervals <M>\{ L_k,<><> to>(1)k</>or <>(-11/k/>java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
for <M>1 \leq k \leq l</M>.
</Subsection>
</Section>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="functions">
<Heading>&GAP; Functions for the Computations</Heading>
We describe two approaches to compute, for a given group <P/>
vertex degrees for the generating graph of <M>G</M> or lower bounds for them,
by calculating exact vertex degrees from <M>G</java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
(see Section <Ref Subsect="groups"/>)
or vertex java.lang.StringIndexOutOfBoundsException: Range [61, 62) out of bounds for length 61
character-theoretic information about <M>G</M> and its subgroups
(see Section <Ref Subsect="characters"/>).
Section&; =clos"> java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 76
of vertex degrees of iterated closures.
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Subsection Label="groups">
<eadingComputing Vertex Degrees from the Group</Heading>
In this section,
the task is to compute the vertex degrees <M>d(s,g^G)</M> using explicit
computations with the group <M>G</M>.
<P/>
The function <C>IsGeneratorsOfTransPermGroup</C> checks whether the permutations
in java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 4
<E>provided that</E> <C>G</C> is transitive on its moved points.
(Note that testing the necessary condition that the elements in <C>list</C>
generate a transitive group is usually much faster than testing generation.)
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 71
<P/>
<Ignore <M>q \eq 5</M>
#############################################################################
##
#F IsGeneratorsOfTransPermGroup( <G>, <list>(The statement of the lemma is trivially true for <M>q \leq 5</M>.)
##
## Let <G> be a finite group that acts *transitively* on its moved points,
## and <list> a list of elements in <G>.
##
## 'IsGeneratorsOfTransPermGroup' returns 'true' if the permutations in
## <list> generate <G>, and 'false' otherwise.
## TheFor primes<f/, M></>is <>G/2M
## generated by 'list' to be transitive, and the check for transitivity
#much thisgroup toG'.
##
## (The same function is used also in another examples file,
## do not use 'BindGlobal'.)
#java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
]]></Ignore>
<Example><![CDATA[
gap> rsOfTransPermGroup:= function( G, list )
> local S;
>
> if not IsTransitive( G ) then
> Error( "<G> must be transitive on its moved points" );
>fi
> S:= SubgroupNC( G, list );
>
> return IsTransitive( S, MovedPoints( G ) )
>exists,
> end;;
]]></Example>
<P/>
Thefunction>java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 56
<E>transitive</E>java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
(in order to be allowed to use <>(java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 76
the list <C>classes</C> of conjugacy classes of <M>G</M>
(in order to prescribe an ordering of the classes),
and list <<C java.lang.StringIndexOutOfBoundsException: Range [66, 43) out of bounds for length 73
and returns the matrix <M>[ d(s, g^G) ]_{s, g}</M> of vertex degrees,
with and columns indexed bynonidentity class representatives
ordered as in the list <C>classes</C>.
(The class containing the identity element may be contained in <C>classes</C>.)
<P/>
The following criteria are used in this function.
<P/>
<List>
<Item>
The function tests
<M>C_G(g)</M>-<M>C_G(s)</M>-double cosets,
where <M>C_G(g):= \{ x \in G; g x = x g \}</M>
denotes Finally, if <M>f</M> is not a prime then <M>N</M> is smaller than <M>|G|/2</M>
Note that for <M>c_1 \in C_G(g)</M>, <M>c_2 \in C_G(s)</M>,
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 48
<M>\langle s, g^{c_1 r c_2} \rangle = \langle s, g^r \rangle^{c_2}</M>.
If <M>which is truefor <>q geq 256/.
the double coset <M>D = C_G(g) r C_G(s)</M> contributes <M>|D|/|C_G(g)|</M>
tothe vertex <>d(, g^)/>java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
java.lang.StringIndexOutOfBoundsException: Range [18, 13) out of bounds for length 39 <!-- % explicitly: --> <!-- % \begin{eqnarray*} --> <!-- % d(s,g^G) & = & |\{ x \in g^G, \langle s, x \rangle = G \}| \\ --> cases java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 56 <!-- % & = & |\{ x \in G, \langle s, g^x \rangle = G \}| / |C_G(g)| \\ --> <!-- % & = & \sum_{r \in R} |\{ x \in C_G(g) r C_G(s), --> <!-- % \langle s, g^r \rangle = G \}| / |C_G(g)| \\ --> <!-- % & = & \sum_{r} |C_G(g) r C_G(s)| / |C_G(g)|, --> <!-- % \end{eqnarray*} --> <!-- % where <M>R</M> is a set of double coset representatives, i. e., --> <!-- % \[ --> <!-- % G = \bigcup_{r \in R} C_G(g) r C_G(s), --> <!-- % \] --> <!-- % and the last sum runs over all those representatives <M>r</M> such that --> <!-- % <M>\langle s, g^r \rangle = G</M> holds. -->
</Item>
<Item>
We have <M>d(s, g^G) \cdot |C_G(g)| = d(g, s^G) \cdot |C_G(s)|</M>.
(To see this,
either establish a bijection of the above double cosets,
or doubly count the edges betweenósa java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
of <M>s</M> and <M>g</M>.)
</Item>
<java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
If <M>\langle s_1 \rangle = \langle s_2 \rangle</M> and
<M>\langle g_1 \rangle = \langle g_2 \rangle</M> hold then we have
<M>d(s_1, g_1^G) = d(s_2, g_1^G) = d(s_1, g_2^G) = d(<M>2<</M>,M3/M> M>4<> java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 72
so only one of these values must be computed.
</>
<Item>
If both <M>s</M> and <M>g</M> are contained in
then <M>d(s, g^G)</M> is zero.
</Item>
<Item>
If <M>G</M> is not a dihedral group and both <M>s</M> and <M>g</M> are involutions
then <M>d(s, g^G)</M> is zero.
</Item>
</List>
<>
<Ignore Remark="gapfilecomments"><![CDATA[
################################Let<>n(, )/M>denote the number of elements of order <M>m</M> in <M>G</M>,
##
#F VertexDegreesGeneratingGraph( <G>, <classes>, <normalsubgroups> )
##
## let<M\varphi()/ of residues M>/.
## <classes> be the list of conjugacy classes of <G>
## (in order to prescribe>
## and <normalsubgroups> be a list of proper normal subgroups of <G>.
##
##<java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 70
## ordered as in the list <classes>.
## (The class containing the identity element java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 57
## 'classes'.)
##
]]></Ignore>
<Example><![CDATA[
gap> BindGlobal( "VertexDegreesGeneratingGraph",
> function( G, classes, normalsubgroups )
> local nccl, matrix,java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
> nsg, g_j, gen, pair, d, pow;
>
> if not IsTransitive( G ) then
> Error( "<G> must be transitive on its moved points" );
> fi;
>
> classes:= Filtered( classes,
> C -> Order( Representative( C ) ) <> 1 );
> nccl:= Length( classes );
> matrix:= [];
> cents:= [];
> : ]java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
> normalsubgroupspos:= [];
> for i in [ 1 .. nccl ] do
> matrix[i]:= [];
> if IsBound( powers[i] ) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 7
> # The i-th row equals the earlier row 'powers[i]'.
> <!-- end of lemma -->
> matrix[i][j]:= matrix[ powers[i] ][j];
> matrix[j][i]:= matrix[j][ powers[i] ];
> od;
> else
> # We have to compute the values.
> g_i:= Representative( classes[i] );
> nsg:= Filtered( [ 1 .. Length( normalsubgroups ) ],
> i -> g_i in normalsubgroups[i] );
> normalsubgroupspos[i]:= nsg;
> cents[i]:= Centralizer( G, g_i );
> for j in [ 1 .. i ] do
> g_j:= Representative( classes[j] );
> if IsBound( powers[j] ) then
> <P/
> matrix[j][i]:= matrix[ powers[j] ][i];
> elif not IsEmpty( Intersection( nsg, java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 0
> or ( Order( g_i ) = 2
> and not IsDihedralGroup( G ) ) then
> matrix[i][j]:= 0;
> matrix[j][i]:= 0;
> else
> # Compute $d(g_i, g_j^G)$.
> =0;
> for pair in DoubleCosetRepsAndSizes( G, cents[j],
> cents[i] ) do
> if IsGeneratorsOfTransPermGroup( G,
> 1] then
> gen:= gen + pair[2];
> fi;
> od;
> matrix[i][j]:= gen / Size( If <M>varphi(1/k \eq 12/M>theneach of orderM3<M,
> if i <> j then
> / ([i )
> fi;
> fi;
> od;
>
> # For later, provide information about algebraic conjugacy.
> for d ( rimeResidues(( )) [1 do
> pow:= g_i^d;
> for j in [ i+1 .. nccl ] do
>
> powers[j]:= i;
> break;
> fi;
> od;
> od;
> fi;
> od;
>
> return matrix;
> end );
]]></Example>
</Subsection>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->E>:<Ejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
<Subsection Label="characters Ms \in G</M> of order at most <M>5</M>.
<Heading>Computing Lower Bounds for Vertex Degrees</Heading>
In this section,
java.lang.StringIndexOutOfBoundsException: Range [48, 3) out of bounds for length 69
vertex degrees <M>d(s, g^G)</M> using character-theoretic methods.
<P/>
We provide &GAP; functions for computing
the multiset <M>\Pi</M> of the primitive permutation charactersgroup <21t
of a given group <M>G</M> and
for computing the lower bounds <M>\delta(s, g^G)</M> from <M>\Pi</M>.
<P/>
For many almost simple groups, the &GAP; libraries of character tables
and of tables of marks contain information for quickly computing
the primitive permutation characters of the group in question.
Therefore, the function <C>java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
notthe<G/ java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 70
(This function is shown already in <Cite Key="ProbGenArxiv"/>.thatjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 48
<<
If <M>T</M> is contained in the &GAP; Character Table Library
(see <Cite Key="CTblLib"/>)
then the complete set of primitive permutation characters
can be easily computed if the character tables of all maximal
subgroups and their class fusions into <M>T</M> are known
(in this case, we check whether the attribute
<Ref Func="Maxes" BookName="ctbllib"/>
of M>/>is java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
or if the table of marks of <M>G</M> and the class fusion from <M>T</M> into this
table of marks are known
(in this case, we check whether the attribute
<Ref Func="FusionToTom" BookName="ctbllib"/>
of <M>T</M> is bound).
If the attribute
<Ref Func="UnderlyingGroup" BookName="ref"/>
of <M>Tand least
stored as the value of this attribute
can be used to compute the primitive permutation characters.
The if </>was computedgroup M>G</>;
for tables in the &GAP; Character Table Library,
this is not the case by default.
<P>
The &GAP; function <C>PrimitivePermutationCharacters</C> tries to compute
the primitive permutation characters of a group using this information;
it returns the required list of characters if this can be computed this way,
otherwise <K>fail</K> is returned.
( java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 65
in order to store the permutation characters in the character table java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
once they have been computed.)
<P/>
<Ignore Remark="gapfilecomments"><![CDATA[
#############################################################################
##
# java.lang.StringIndexOutOfBoundsException: Range [37, 34) out of bounds for length 43
##
## For an ordinary character table <tbl> for which either the value of one
## of the attributes 'Maxes' or 'UnderlyingGroup' is stored or the table of
# marksiscontainedinthe GAP library marks,
## 'PrimitivePermutationCharacters' returns the list of all primitive
## permutation characters of <tbl>.
#fail is returned.
##
## We use 'InstallOtherMethod' not 'InstallMethod' because another test file
## declares the same attribute and installs the same method.
##
]]></Ignore>
<xample><![DATA[
gap> DeclareAttribute( "PrimitivePermutationCharacters",
> IsCharacterTable );
gap> InstallOtherMethod( PrimitivePermutationCharacters,
> [ IsCharacterTable ],
> function( tbl )
> local maxes, i, fus, poss, tom, G;
>
> if HasMaxes( tbl ) then
> maxes:= List( Maxes( tbl ), CharacterTable );
> for i in [ 1 .. Length( maxes ) ] do
> fus:= GetFusionMap( maxes[i], tbl );
> if fus = if <M>\varphi((q+1)/k) \geq 12</M>.
> fus:= PossibleClassFusions( maxes[i], tbl );
> poss:= Set( fus,
> map -> java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 10
> maxes[i], tbl,
> [ TrivialCharacter( maxes[i] ) ], map )[1] );
> if Length( poss ) = 1 then
> maxes[i]:= poss[1];
> else
> return fail;
> fi;
> else
> maxes[i]:= TrivialCharacter( maxes[i] )^tbl;
> fi;
> od;
> return maxes;
> elif HasFusionToTom( tbl ) then
> tom:= TableOfMarks( tbl );
> maxes:= MaximalSubgroupsTom( tom );
>return PermCharsTom(tbl,tom ) 1]}
> elif HasUnderlyingGroup( tbl ) then
> G:= UnderlyingGroup( tbl );
> return List( MaximalSubgroupClassReps( G ),
> M -> TrivialCharacter( M )^tbl );
> fi;
>
> return fail;
> end );
]]></Example> <!-- % improve: if HasMaxes but not all fusions available? (Babymonster!) -->
<P/>
The next function computes the lower bounds <M>\delta(s, g^G)</M> from
the two lists <C>classlengths</C> of conjugacy class lengths of the group <M>G</M>
and <C>prim</C> of all primitive permutation characters of <M>G</M>.
(The first entry in <C>classlengths</C> is assumed to represent P>
containing the identity element of <M>G</M>.)
The return value is the matrix that contains in row <M>i</M> and column <M>j</M>
the value <M>\delta(s, g^G)</M>, where <M>s</M> and <M>g</M> are in the conjugacy classes
represented by the <M>(i+1)</M<xample>!CDATA[
So the row sums of this matrix are the values <M>\delta(s)</M>.
<P/>
<Ignore Remark="gapfilecomments"><![CDATA[
#########################################################################> local name ordersnccl cl, ,bds,,
##
#F LowerBoundsVertexDegrees( <classlengths>, <prim> )
##
## For two lists <classlengths> of the conjugacy class lengths and <prim> of
## all primitive permutation characters of a group $G$, say,
## 'LowerBoundsVertexDegrees' returns a matrix <delta> such that
## '<delta>[i][j] = '$\delta(s, g^G)$ holds,
## for $s$ and $g$ in the 'i+1'-st and 'j+1'-st class of $G$,
## respectively.
##
## So the row sums in <delta> are the values $\delta(s)$.
##
]]></Ignore>
<Example><![CDATA[
gap> LowerBoundsVertexDegrees:= function( classlengths, prim )
> local sizes, nccl;
>
> nccl:= Length( classlengths );
> returnbds=List(LowerBoundsVertexDegrees, ) Sum )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
> i- ([2 . nccl ]
> j -> Maximum( 0, classlengths[j] - Sum( prim,
> pi -> classlengths - java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 68
> / pi[1] ) ) ) );
> end;;
]]></Example>
</Subsection>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Subsection ForAny( [ 1 .] i- i =2 ,
<Heading>Evaluating the (Lower Bounds for the) Vertex Degrees</Heading>
In i- bdsi-] < 2
the task is to compute (lower bounds for) the vertex degrees of iterated
of java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 73
of the graph itself,
and then to check the criteria of Pósa and Chvátal.
<P/>
The arguments of all java.lang.StringIndexOutOfBoundsException: Range [28, 23) out of bounds for length 59
the list <C>classlengths</C> of conjugacy class lengths for the group <M>G</M>
(including the class of the identity element, in the first position)
and a matrix <C>bounds</C> of the values <M>d^{(i)}(s, g^G)</M>
or <M>\delta^{(i)}(s Error( problem order ..5] "name)
with rows and columns indexed by nonidentity class representatives
<M>s</M> andfi
Such a matrix is returned by the functions <C>VertexDegreesGeneratingGraph</C> or
<C>LowerBoundsVertexDegrees</C>, respectively.
<P/>
The <LowerBoundsVertexDegreesOfClosure/ java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 79
matrix of the values <M>d^{(i+1)}(s, g^G)</M> or <M>\delta^{(i+1)}(s, g^G)</M(CharacterTable
respectively.
<P>
<Ignore Remark="gapfilecomments"><![CDATA[
##########################> od;
##
#F LowerBoundsVertexDegreesOfClosure( <classlengths>, <bounds> )
##
## Given the list <classlengths> of conjugacy class lengths for the group
## $G$ and a matrix <bounds> of the values $d^{(i)}(s, g^G)$ or
## $\<P>
## as is returned by 'VertexDegreesGeneratingGraph' or
## 'LowerBoundsVertexDegrees',
## java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
## $d^{(i+1)}(s, g^G)$ or $\delta^{(i+1)}(s, g^G)$, respectively.
##
]]></Ignore>
<Example><![CDATA[
gap> LowerBoundsVertexDegreesOfClosure:= function( classlengths, bounds )
> local delta, newbounds, size, i, j;
>
> delta=List( bounds, Sum );
> newbounds:= List( bounds, ShallowCopy );
> size:= Sum( classlengths );
> for i in [ 1 .. Length( bounds ) ] do
> for j in [ 1 .. Length( bounds ) ] do
> if delta[i] + delta[j] >= size - 1 then
> newbounds[i][j]:= classlengths[ j+1 ];
> fi;
> od;
> od;
>
> return newbounds;
> end;;
]]></Example>
<P/>
Once the values <M>d^{(i)}(s, g^G)</M> or <M>\delta^{(i)}(s, g^G)</M> are known,
we can check whether Pósa's or Chvátal's criterion is satisfied
for the graph <M>&cl;^{(i)}(\Gamma(G))</M>,
using the function <C>CheckCriteriaOfPosaAndChvatal</C> shown below.
(Of course a <E>negative</E> result is meaningless in the case that only
lower bounds for the vertex degrees are used.)
<P/>
The idea is to compute the row sums of the given matrix,
and to compute the intervals <M>\{ L_k, L_k + 1, \ldots, U_k \}</M>
and <M>\{ L^{\prime}_k, L^{\prime}_k + 1, \ldots, U^{\prime}_k \}</M>
that were introduced in Section <Ref Subsect="critcheck"/>.
<P/>
The function <C>CheckCriteriaOfPosaAndChvatal</C> returns,
given the list of class lengths of <M>G</M> and the matrix of (bounds for the)
vertex degrees, a record with the components
<C>badForPosa</C> (the list of those pairs <M>[ L_k, U_k ]</M> with the property
<M>L_k \leq U_k</M>),
<C>badForChvatal</C> (the list of pairs of lower and upper bounds of
nonempty intervals where Chvátal's criterion may be violated),
and <C>data</C> (the sorted list of triples <M>[ \delta(g_k), |g_k^G|, \iota(k) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
where <M>\iota(k)</M> is the row and column position of <M>g_k</ection>
<C>bounds</C>).
The ordering of class lengths must of course be compatible with the
ordering of rows and columns of the matrix,
and the identity element of </hapter>
list of class lengths.
<P/>
<Ignore Remark="gapfilecomments"><![CDATA[
#############################################################################
##
#F CheckCriteriaOfPosaAndChvatal( <classlengths>, <bounds> )
##
## Let <classlengths> be list of conjugacy class lengths of a group $G$,
## say, and <bounds> be a matrix of the values $d^{(i)}(s, g^G)$ or
## $\delta^{(i)}(s, g^G)$,
## as is returned for example by 'LowerBoundsVertexDegrees' or
## 'LowerBoundsVertexDegreesOfClosure'.
##
## 'CheckCriteriaOfPosaAndChvatal' returns a record with the following
## components.
##
## 'badForPosa':
## the list of those pairs $[ L_k, U_k ]$ with the property
## $L_k \leq U_k$,
##
## 'badForChvatal':
## the list of pairs of lower and upper bounds of nonempty intervals
## where Chvátal's criterion may be violated, and
##
## 'data':
## the sorted list of triples $[ \delta(g_k), |g_k^G|, \iota(k) ]$,
## where $\iota(k)$ is the row and column position of $g_k$
## in the matrix <bounds>.
##
## The generating graph $\Gamma(G)$ satisfies Pósa's criterion
## if the 'badForPosa' component is empty;
## the graph satisfies Chvátal's criterion if the 'badForChvatal'
## component is empty.
##
## The ordering of class lengths must of course be compatible with the
## ordering of rows and columns of the matrix,
## and the identity element of $G$ must belong to the first entry in the
## list of class lengths.
##
]]></Ignore>
<Example><![CDATA[
gap> CheckCriteriaOfPosaAndChvatal:= function( classlengths, bounds )
> local size, degs, addinterval, badForPosa, badForChvatal1, pos,
> half, i, low1, upp2, upp1, low2, badForChvatal, interval1,
> interval2;
>
> size:= Sum( classlengths );
> degs:= List( [ 2 .. Length( classlengths ) ],
> i -> [ Sum( bounds[ i-1 ] ), classlengths[i], i ] );
> Sort( degs );
>
> addinterval:= function( intervals, low, upp )
> if low <= upp then
> Add( intervals, [ low, upp ] );
> fi;
> end;
>
> badForPosa:= [];
> badForChvatal1:= [];
> pos:= 1;
> half:= Int( size / 2 ) - 1;
> for i in [ 1 .. Length( degs ) ] do
> # We have pos = c_1 + c_2 + \cdots + c_{i-1} + 1
> low1:= Maximum( pos, degs[i][1] ); # L_i
> upp2:= Minimum( half, size-1-pos, size-1-degs[i][1] ); # U'_i
> pos:= pos + degs[i][2];
> upp1:= Minimum( half, pos-1 ); # U_i
> low2:= Maximum( 1, size-pos ); # L'_i
> addinterval( badForPosa, low1, upp1 );
> addinterval( badForChvatal1, low2, upp2 );
> od;
>
> # Intersect intervals.
> badForChvatal:= [];
> for interval1 in badForPosa do
> for interval2 in badForChvatal1 do
> addinterval( badForChvatal,
> Maximum( interval1[1], interval2[1] ),
> Minimum( interval1[2], interval2[2] ) );
> od;
> od;
>
> return rec( badForPosa:= badForPosa,
> badForChvatal:= Set( badForChvatal ),
> data:= degs );
> end;;
]]></Example>
<P/>
Finally, the function <C>HamiltonianCycleInfo</C> assumes that the matrix <C>bounds</C>
contains lower bounds for the vertex degrees in the generating graph
<M>\Gamma</M>, and returns a string that describes the minimal <M>i</M> with the
property that the given bounds suffice to show that <M>cl^{(i)}(\Gamma)</M>
satisfies Pósa's or Chvátal's criterion,
if such a closure exists.
If no closure has this property, the string <C>"no decision"</C> is returned.
<P/>
<Ignore Remark="gapfilecomments"><![CDATA[
#############################################################################
##
#F HamiltonianCycleInfo( <classlengths>, <bounds> )
##
## Let <classlengths> be list of conjugacy class lengths of a group $G$,
## say, and <bounds> be a matrix of the values $d^{(i)}(s, g^G)$ or
## $\delta^{(i)}(s, g^G)$,
## as is returned for example by 'LowerBoundsVertexDegrees' or
## 'LowerBoundsVertexDegreesOfClosure'.
##
## 'HamiltonianCycleInfo' returns a string that describes the minimal $i$
## with the property that the given bounds suffice to show that
## $cl^{(i)}(\Gamma(G))$ satisfies Pósa's or Chvátal's criterion,
## if such a closure exists.
## If no closure has this property, the string '"no decision"' is returned.
##
]]></Ignore>
<Example><![CDATA[
gap> HamiltonianCycleInfo:= function( classlengths, bounds )
> local i, result, res, oldbounds;
>
> i:= 0;
> result:= rec( Posa:= fail, Chvatal:= fail );
> repeat
> res:= CheckCriteriaOfPosaAndChvatal( classlengths, bounds );
> if result.Posa = fail and IsEmpty( res.badForPosa ) then
> result.Posa:= i;
> fi;
> if result.Chvatal = fail and IsEmpty( res.badForChvatal ) then
> result.Chvatal:= i;
> fi;
> i:= i+1;
> oldbounds:= bounds;
> bounds:= LowerBoundsVertexDegreesOfClosure( classlengths,
> bounds );
> until oldbounds = bounds;
>
> if result.Posa <> fail then
> if result.Posa <> result.Chvatal then
> return Concatenation(
> "Chvatal for ", Ordinal( result.Chvatal ), " closure, ",
> "Posa for ", Ordinal( result.Posa ), " closure" );
> else
> return Concatenation( "Posa for ", Ordinal( result.Posa ),
> " closure" );
> fi;
> elif result.Chvatal <> fail then
> return Concatenation( "Chvatal for ", Ordinal( result.Chvatal ),
> " closure" );
> else
> return "no decision";
> fi;
> end;;
]]></Example>
In this section, we apply the functions introduced in Section <Ref Subsect="functions"/>
to character tables of almost simple groups
that are available in the &GAP; Character Table Library.
<P/>
Our first examples are the sporadic simple groups, in Section <Ref Subsect="spor"/>,
then their automorphism groups are considered in Section <Ref Subsect="sporaut"/>.
Small alternating and symmetric groups are treated in
Section <Ref Subsect="symmalt"/>.
<P/>
For our convenience, we provide a small function that takes as its
argument only the character table in question,
and returns a string, either <C>"no prim. perm. characters"</C> or the
return value of <C>HamiltonianCycleInfo</C> for the bounds computed from
the primitive permutation characters.
<P/>
<Ignore Remark="gapfilecomments"><![CDATA[
#############################################################################
##
#F HamiltonianCycleInfoFromCharacterTable( <tbl> )
##
## For a character table <tbl>, this function returns a string,
## either '"no prim. perm. characters"' or the return value of
## 'HamiltonianCycleInfo' for the bounds computed from the primitive
## permutation characters.
##
]]></Ignore>
<Example><![CDATA[
gap> HamiltonianCycleInfoFromCharacterTable:= function( tbl )
> local prim, classlengths, bounds;
>
> prim:= PrimitivePermutationCharacters( tbl );
> if prim = fail then
> return "no prim. perm. characters";
> fi;
> classlengths:= SizesConjugacyClasses( tbl );
> bounds:= LowerBoundsVertexDegrees( classlengths, prim );
> return HamiltonianCycleInfo( classlengths, bounds );
> end;;
]]></Example>
Since version 1.3.10 of &CTblLib;,
the &GAP; Character Table Library contains the tables of maximal subgroups
of all sporadic simple groups.
<P/>
<!-- % For the Baby Monster, --> <!-- % currently the class fusion of the 6-th maximal subgroup is not known. --> <!-- % It takes several hours of CPU time to verify that the permutation --> <!-- % character is uniquely determined by the character tables. -->
So the function <C>PrimitivePermutationCharacters</C>
can be used to compute all their primitive permutation characters.
It turns out that the information available in the
&GAP; Character Table Library is sufficient to prove that
the generating graph contains a Hamiltonian cycle.
In the original version of this file, a special treatment of the Monster
group had been necessary because not all character tabes of its maximal
subgroups were available, and also not all class fusions from some
maximal subgroups were known whose character tables were available.
This section shows the computations that were used at that time.
<P/>
Meanwhile the maximal subgroups of the Monster are classified,
see <Cite Key="DLP25"/>, their character tables are available,
and also all class fusions from the maximal subgroups are known.
Thus we can easily compute the primitive permutation characters
of the Monster group.
The computations shown in this section are not needed to prove the claims
from <Cite Key="GMN"/>, they are kept just for historical reasons.
Thus this section is an example how the availability of the full list of
primitive permutation characters of the Monster simplifies proofs.
<P/>
The situation for the following arguments is as follows.
We do not assume the knowledge of all primitive permutation characters of the
Monster group <M>M</M>, and we use only some of the character tables of the
maximal subgroups of <M>M</M> and only partial information on their
class fusions.
Note that for some maximal subgroups of <M>M</M>,
the permutation character is not uniquely determined by the character tables
involved.
However, we can compute upper bounds for the values of the primitive
permutation characters <M>1_S^M</M> from the possible class fusions
from <M>S</M> into <M>M</M> if the character table of <M>S</M> is known.
For the other subgroups <M>S</M>, the permutation characters <M>1_S^M</M>
have been computed with other methods.
Using this information, we will show that the generating graph of <M>M</M>
satisfies Pósa's criterion.
<P/>
The list <C>primdata</C> defined below has length <M>46</M>.
The entry at position <M>i</M> is a list of length one or two.
If <C>primdata[</C><M>i</M><C>]</C> has length one then its unique entry is
the identifier of the library character table of the <M>i</M>-th maximal
subgroup of <M>M</M>.
If <C>primdata[</C><M>i</M><C>]</C> has length two then its entries are
a string describing the structure of the <M>i</M>-th maximal subgroup
<M>S</M> of <M>M</M> and the permutation character <M>1_S^M</M>.
<P/>
(The construction of the explicitly given characters in this list
will be documented elsewhere.
Some of the constructions can be found
in Section <Ref Sect="sect:monsterperm"/>.)
We compute upper bounds for the permutation character values
in the cases where the characters are not given explicitly.
(We could improve this by using additional information about the class
fusions, but this will not be necessary.)
<P/>
<Example><![CDATA[
gap> s:= "dummy";; # Avoid a message about an unbound variable ...
gap> poss:= "dummy";; # Avoid a message about an unbound variable ...
gap> for entry in primdata do
> if not IsBound( entry[2] ) then
> s:= CharacterTable( entry[1] );
> poss:= Set( PossibleClassFusions( s, m ),
> x -> InducedClassFunctionsByFusionMap( s, m,
> [ TrivialCharacter( s ) ], x )[1] );
> entry[2]:= List( [ 1 .. NrConjugacyClasses( m ) ],
> i -> Maximum( List( poss, x -> x[i] ) ) );
> fi;
> od;
]]></Example>
<!-- This loop required about half an hour of CPU time in 2012,
but just six minutes in 2023. -->
<P/>
Now we estimate the lower bounds <M>\delta(s, g^G)</M> introduced in
Section <Ref Subsect="characters"/>.
Let <M>&M;</M> denote a set of representatives of the
classes of maximal subgroups of <M>M</M>.
Then
hence <M>\delta(s)</M> can be computed from the corresponding primitive
permutation characters,
and a lower bound for <M>\delta(s)</M> can be computed from the upper bounds for
the characters <M>1_S^G</M> which are given by the list <C>primdata</C>.
<P/>
This means that modifying the output of <C>LowerBoundsVertexDegrees</C>
as follows really yields lower bounds for the vertex degrees.
<P/>
<Example><![CDATA[
gap> prim:= List( primdata, x -> x[2] );;
gap> classlengths:= SizesConjugacyClasses( m );;
gap> bounds:= LowerBoundsVertexDegrees( classlengths, prim );;
]]></Example>
<P/>
Now we sum up the bounds for the individual classes.
It turns out that the minimal vertex degree is more than <M>99.99998</M>
percent of <M>|M|</M>.
This proves that the generating graph of the Monster
satisfies Pósa's criterion.
<E>Without</E> the results from <Cite Key="DLP25"/>,
we can argue as follows.
(This was the situation in earlier versions of this example file.)
<P/>
According to <Cite Key="NW12"/>,
any maximal subgroup of the Monster is either among the <M>44</M> known
classes from the above list except L<M>_2(13).2</M> and U<M>_3(4).4</M>,
or it is an almost simple group whose socle is one of
L<M>_2(13)</M>, Sz<M>(8)</M>, U<M>_3(4)</M>, and U<M>_3(8)</M>. <!-- % -> has been ruled out: L<M>_2(27)</M>, -->
<P/>
We show that the elements of such subgroups are contained in
the union of <M>55</M> conjugacy classes of the Monster
that cover less than one percent of the elements in the Monster.
For that, we compute the possible class fusions from the abovementioned
simple groups <M>S</M> into the Monster, and then the possible class fusions
from the automorphic extensions of <M>S</M> into the Monster,
using the possible class fusions of <M>S</M>.
(This approach is faster than computing each class fusion from scratch.)
<P/>
After the following computations,
the list <C>badclasses</C> will contain the positions of all those classes
of <M>M</M> that may contain elements in some of the hypothetical
maximal subgroups.
<P/>
For each simple group in question, we enter the identifiers of the
character tables of the automorphic extensions that can occur.
Note that the automorphism groups of the four groups have the structures
L<M>_2(13).2</M>, Sz<M>(8).3</M>, U<M>_3(4).4</M>,
and U<M>_3(8).(3 \times S_3)</M>, respectively.
We need not consider the groups U<M>_3(8).3^2</M> and
U<M>_3(8).(3 \times S_3)</M>
because already U<M>_3(8).3_2</M> does not admit an embedding into <M>M</M>,
and we need not consider the group U<M>_3(8).S_3</M> because its set of
elements is covered by its subgroups of the types U<M>_3(8).2</M> and
U<M>_3(8).3_2</M>.
<E>In the original version of this file, also hypothetical maximal
subgroups with socle</E> L<M>_2(27)</M> <E>had been considered.
As a consequence, the list</E> <C>badclasses</C> <E>computed above had length
<M>59</M> in the original version;
the list contained also the classes at the positions <M>90, 94, 95</M>,
and <M>96</M>,
that is, the classes</E> <C>26B</C>, <C>28B</C>, <C>28C</C>, <C>28D</C>.
<E>The proportion</E> <C>bad</C> <E>of elements in the classes of <M>M</M>
described by</E>
<C>badclasses</C> <E>was about <M>2.05</M> percent of <M>|M|</M>,
compared to the about <M>0.98</M> percent in the current version.</E>
<!-- % If we ignore L<M>_2(27)</M> then we do not get the classes [ 90, 94, 95, 96 ], --> <!-- % i.e., [ "26b", "28b", "28c", "28d" ]. -->
<P/>
Now we estimate the lower bounds <M>\delta(s, g^G)</M> introduced in
Section <Ref Subsect="characters"/>.
Let <M>&B;</M> denote the union of the classes described by <C>badclasses</C>,
and let <M>&M;</M> denote a set of representatives of the
<M>44</M> known classes of maximal subgroups of <M>M</M>.
hence <M>\delta(s)</M> can be computed from the corresponding primitive
permutation characters,
and a lower bound for <M>\delta(s)</M> can be computed from the upper bounds for
the characters <M>1_S^G</M> which are given by the list <C>primdata</C>.
<P/>
If <M>s \in &B;</M> then the above equation for <M>\delta(s, g^G)</M> holds
at least for <M>g \notin &B;</M>,
so <M>\sum_{{g \in R \setminus &B;}} \delta(s, g^G)</M> is a lower bound
for <M>\delta(s)</M>.
So <C>primdata</C> yields a lower bound for <M>\delta(s)</M> also for
<M>s \in &B;</M>,
by ignoring the pairs <M>(s, g)</M> where both <M>s</M> and <M>g</M> lie in
<M>&B;</M>.
<P/>
This means that modifying the output of <C>LowerBoundsVertexDegrees</C>
as follows really yields lower bounds for the vertex degrees.
(Note that the row and column positions in the matrix returned by
<C>LowerBoundsVertexDegrees</C> are shifted by one,
compared to <C>badclasses</C>.)
<P/>
<Example><![CDATA[
gap> prim:= List( primdata, x -> x[2] );;
gap> badpos:= Difference( badclasses, [ 1 ] ) - 1;;
gap> bounds:= LowerBoundsVertexDegrees( classlengths, prim );;
gap> for i in badpos do
> for j in badpos do
> bounds[i][j]:= 0;
> od;
> od;
]]></Example>
<P/>
Now we sum up the bounds for the individual classes.
It turns out that the minimal vertex degree is more than <M>99</M> percent
of <M>|M|</M>.
This proves that the generating graph of the Monster
satisfies Pósa's criterion.
<P/>
(And the minimal vertex degree of elements outside <M>&B;</M>
is more than <M>99.99998</M> percent of <M>|M|</M>.)
<P/>
<E>In the original version of this file,
we got only <M>97.95</M> percent of <M>|M|</M> as the lower bound
for the minimal vertex degree.
The bound for elements outside <M>&B;</M> was the same
in the original version.
The fact that the maximal subgroups of type</E> L<M>_2(41)</M>
<E>had been ignored in the original version
did not affect the lower bound for the minimal vertex degree.</E>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Subsection Label="sporaut">
<Heading>Nonsimple Automorphism Groups of Sporadic Simple Groups</Heading>
Next we consider the nonsimple automorphism groups of the sporadic simple
groups.
Nontrivial outer automorphisms exist exactly in <M>12</M> cases,
and then the simple group has index <M>2</M> in its automorphism group.
The character tables of the groups and their maximal subgroups are
available in &GAP;.
<P/>
<Example><![CDATA[
gap> spornames:= AllCharacterTableNames( IsSporadicSimple, true,
> IsDuplicateTable, false );;
gap> sporautnames:= AllCharacterTableNames( IsSporadicSimple, true,
> IsDuplicateTable, false,
> OfThose, AutomorphismGroup );;
gap> sporautnames:= Difference( sporautnames, spornames );
[ "F3+.2", "Fi22.2", "HN.2", "HS.2", "He.2", "J2.2", "J3.2", "M12.2", "M22.2", "McL.2", "ON.2", "Suz.2" ]
gap> for tbl in List( sporautnames, CharacterTable ) do
> info:= HamiltonianCycleInfoFromCharacterTable( tbl );
> Print( Identifier( tbl ), ": ", info, "\n" );
> od;
F3+.2: Chvatal for 0th closure, Posa for 1st closure
Fi22.2: Chvatal for 0th closure, Posa for 1st closure
HN.2: Chvatal for 0th closure, Posa for 1st closure
HS.2: Chvatal for 1st closure, Posa for 2nd closure
He.2: Chvatal for 0th closure, Posa for 1st closure
J2.2: Chvatal for 0th closure, Posa for 1st closure
J3.2: Chvatal for 0th closure, Posa for 1st closure
M12.2: Chvatal for 0th closure, Posa for 1st closure
M22.2: Posa for 1st closure
McL.2: Chvatal for 0th closure, Posa for 1st closure
ON.2: Chvatal for 0th closure, Posa for 1st closure
Suz.2: Chvatal for 0th closure, Posa for 1st closure
]]></Example>
</Subsection>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Subsection Label="symmalt">
<Heading>Alternating and Symmetric Groups <M>A_n</M>, <M>S_n</M>,
for <M>5 \leq n \leq 13</M></Heading>
For alternating and symmetric groups <M>A_n</M> and <M>S_n</M>, respectively,
with <M>5 \leq n \leq 13</M>,
the table of marks or the character tables of the group
and all its maximal subgroups are available in &GAP;.
So we can compute the character-theoretic bounds for vertex degrees.
<P/>
<Example><![CDATA[
gap> for tbl in List( [ 5 .. 13 ], i -> CharacterTable(
> Concatenation( "A", String( i ) ) ) ) do
> info:= HamiltonianCycleInfoFromCharacterTable( tbl );
> if info <> "Posa for 0th closure" then
> Print( Identifier( tbl ), ": ", info, "\n" );
> fi;
> od;
]]></Example>
<P/>
No messages are printed, so the generating graphs of the alternating
groups in question satisfy Pósa's criterion.
<P/>
<Example><![CDATA[
gap> for tbl in List( [ 5 .. 13 ], i -> CharacterTable(
> Concatenation( "S", String( i ) ) ) ) do
> info:= HamiltonianCycleInfoFromCharacterTable( tbl );
> Print( Identifier( tbl ), ": ", info, "\n" );
> od;
A5.2: no decision
A6.2_1: Chvatal for 4th closure, Posa for 5th closure
A7.2: Posa for 1st closure
A8.2: Chvatal for 2nd closure, Posa for 3rd closure
A9.2: Chvatal for 2nd closure, Posa for 3rd closure
A10.2: Chvatal for 2nd closure, Posa for 3rd closure
A11.2: Posa for 1st closure
A12.2: Chvatal for 2nd closure, Posa for 3rd closure
A13.2: Posa for 1st closure
]]></Example>
<P/>
We see that sufficiently large closures of the generating graphs of the
symmetric groups in question satisfy Pósa's criterion,
except that the bounds for the symmetric group <M>S_5</M> are not sufficient
for the proof.
In Section <Ref Subsect="smallalmostsimple"/>,
it is shown that the 2nd closure of the generating graph of <M>S_5</M>
satisfies Pósa's criterion.
<P/>
(We could find slightly better bounds derived only from character tables
which suffice to prove that the generating graph for <M>S_5</M> contains a
Hamiltonian cycle, but this seems to be not worth while.)
</Subsection>
</Section>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="grouptheor">
<Heading>Computations With Groups</Heading>
We prove in Section <Ref Subsect="smallsimp"/> that the generating
graphs of the nonabelian simple groups of order up to <M>10^6</M>
satisfy Pósa's criterion,
and that the same holds for those nonabelian simple
groups of order between <M>10^6</M> and <M>10^7</M> that are not isomorphic
with some <M>&PSL;(2,q)</M>.
(In Section <Ref Subsect="psl2q"/>,
it is shown that the generating graph of
<M>&PSL;(2,q)</M> satifies Pósa's criterion for any prime power <M>q</M>.)
Nonsimple nonsolvable groups of order up to <M>10^6</M>
are treated in Section <Ref Subsect="smallalmostsimple"/>.
<P/>
(We could increase the bounds <M>10^6</M> and <M>10^7</M> with more
computations, using the same methods.)
<P/>
For our convenience, we provide a small function that takes as its
argument only the group in question,
and returns a string, the
return value of <C>HamiltonianCycleInfo</C> for the vertex degrees computed
from the group.
(In order to speed up the computations,
the function computes the proper normal subgroups that contain the derived
subgroup of the given group, and enters the list of these groups as the
third argument of <C>VertexDegreesGeneratingGraph</C>.)
<P/>
<Ignore Remark="gapfilecomments"><![CDATA[
#############################################################################
##
#F HamiltonianCycleInfoFromGroup( <G> )
##
## For a group <G>, this function returns a string,
## the return value of 'HamiltonianCycleInfo' for the vertex degrees
## computed from the group.
##
]]></Ignore>
<Example><![CDATA[
gap> HamiltonianCycleInfoFromGroup:= function( G )
> local ccl, nsg, der, degrees, classlengths;
> ccl:= ConjugacyClasses( G );
> if IsPerfect( G ) then
> nsg:= [];
> else
> der:= DerivedSubgroup( G );
> nsg:= Concatenation( [ der ],
> IntermediateSubgroups( G, der ).subgroups );
> fi;
> degrees:= VertexDegreesGeneratingGraph( G, ccl, nsg );
> classlengths:= List( ccl, Size );
> return HamiltonianCycleInfo( classlengths, degrees );
> end;;
]]></Example>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Subsection Label="smallsimp">
<Heading>Nonabelian Simple Groups of Order up to <M>10^7</M></Heading>
Representatives of the <M>56</M> isomorphism types of nonabelian simple groups
of order up to <M>10^6</M> can be accessed in &GAP; with the function
<C>AllSmallNonabelianSimpleGroups</C>.
Nothing is printed during these computations,
so the generating graphs of all processed groups satisfy
Pósa's criterion.
<P/>
(On my notebook,
the above computations needed about <M>6300</M> seconds of CPU time.)
<P/>
For simple groups of order larger than <M>10^6</M>, there is not such an easy
way (yet) to access representatives for each isomorphism type.
Therefore, first we compute the orders of nonabelian simple groups
between <M>10^6</M> and <M>10^7</M>.
We see that there are <M>31</M> groups of the type <M>&PSL;(2,q)</M> and
<M>10</M> other nonabelian simple groups with order in the range from
<M>10^6</M> to <M>10^7</M>.
The former groups can be ignored because the generating graphs of any
group <M>&PSL;(2,q)</M> satisfies Pósa's criterion,
see Section <Ref Subsect="psl2q"/>.
For the latter groups, we can apply the character-theoretic method
to prove that the generating graph satisfies Pósa's criterion.
<P/>
<Example><![CDATA[
gap> info:= Filtered( info, x -> not IsBound( x.series ) or
> x.series <> "L" or x.parameter[1] <> 2 );
[ rec( name := "B(3,2) = O(7,2) ~ C(3,2) = S(6,2)",
parameter := [ 3, 2 ], series := "B", shortname := "S6(2)" ),
rec( name := "A(10)", parameter := 10, series := "A",
shortname := "A10" ),
rec( name := "A(2,7) = L(3,7) ", parameter := [ 3, 7 ],
series := "L", shortname := "L3(7)" ),
rec( name := "2A(3,3) = U(4,3) ~ 2D(3,3) = O-(6,3)",
parameter := [ 3, 3 ], series := "2A", shortname := "U4(3)" ),
rec( name := "G(2,3)", parameter := 3, series := "G",
shortname := "G2(3)" ),
rec( name := "B(2,5) = O(5,5) ~ C(2,5) = S(4,5)",
parameter := [ 2, 5 ], series := "B", shortname := "S4(5)" ),
rec( name := "2A(2,8) = U(3,8)", parameter := [ 2, 8 ],
series := "2A", shortname := "U3(8)" ),
rec( name := "2A(2,7) = U(3,7)", parameter := [ 2, 7 ],
series := "2A", shortname := "U3(7)" ),
rec( name := "A(3,3) = L(4,3) ~ D(3,3) = O+(6,3) ",
parameter := [ 4, 3 ], series := "L", shortname := "L4(3)" ),
rec( name := "A(4,2) = L(5,2) ", parameter := [ 5, 2 ],
series := "L", shortname := "L5(2)" ) ]
gap> names:= [ "S6(2)", "A10", "L3(7)", "U4(3)", "G2(3)", "S4(5)",
> "U3(8)", "U3(7)", "L4(3)", "L5(2)" ];;
gap> for tbl in List( names, CharacterTable ) do
> info:= HamiltonianCycleInfoFromCharacterTable( tbl );
> if info <> "Posa for 0th closure" then
> Print( Identifier( tbl ), ": ", info, "\n" );
> fi;
> od;
]]></Example>
</Subsection>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Subsection Label="smallalmostsimple">
<Heading>Nonsimple Groups with Nonsolvable Socle of Order at most <M>10^6</M></Heading>
Let <M>G</M> be a nonsolvable group such that <M>G/N</M> is cyclic
for all nontrivial normal subgroups <M>N</M> of <M>G</M>.
Then the socle Soc<M>(G)</M> of <M>G</M> is the unique minimal normal subgroup.
Moreover, Soc<M>(G)</M> is nonsolvable and thus a direct product of isomorphic
nonabelian simple groups,
and <M>G</M> is isomorphic to a subgroup of Aut<M>(</M>Soc<M>(G))</M>.
<P/>
In order to deal with all such groups <M>G</M> for which additionally
<M>|</M>Soc<M>(G)| \leq 10^6</M> holds,
it is sufficient to run over the simple groups <M>S</M> of order up to
<M>10^6</M> and to consider those subgroups <M>G</M> of Aut<M>(S^n)</M>,
with <M>|S|^n \leq 10^6</M>, for which Inn<M>(G)</M> is the unique
minimal normal subgroup and <M>G / </M>Inn<M>(G)</M> is cyclic.
<P/>
We show that for each such group,
a sufficient closure of the generating graph satisfies Pósa's criterion.
<P/>
<Example><![CDATA[
gap> grps:= AllSmallNonabelianSimpleGroups( [ 1 .. 10^6 ] );;
gap> epi:= "dummy";; # Avoid a message about an unbound variable ...
gap> for simple in grps do
> for n in [ 1 .. LogInt( 10^6, Size( simple ) ) ] do
> # Compute the n-fold direct product S^n.
> soc:= CallFuncList( DirectProduct,
> ListWithIdenticalEntries( n, simple ) );
> # Compute Aut(S^n) as a permutation group.
> aut:= Image( IsomorphismPermGroup( AutomorphismGroup( soc ) ) );
> aut:= Image( SmallerDegreePermutationRepresentation( aut ) );
> # Compute class representatives of subgroups of
> # Aut(S^n)/Inn(S^n).
> socle:= Socle( aut );
> epi:= NaturalHomomorphismByNormalSubgroup( aut, socle );
> # Compute the candidates for G. (By the above computations,
> # we need not consider simple groups.)
> reps:= List( ConjugacyClassesSubgroups( Image( epi ) ),
> Representative );
> reps:= Filtered( reps, x -> IsCyclic( x ) and Size( x ) <> 1 );
> greps:= Filtered( List( reps, x -> PreImages( epi, x ) ),
> x -> Length( MinimalNormalSubgroups( x ) ) = 1 );
> for g in greps do
> # We have to deal with a *transitive* permutation group.
> # (Each group in question acts faithfully on an orbit.)
> if not IsTransitive( g ) then
> g:= First( List( Orbits( g, MovedPoints( g ) ),
> x -> Action( g, x ) ),
> x -> Size( x ) = Size( g ) );
> fi;
> # Check this group G.
> info:= HamiltonianCycleInfoFromGroup( g );
> Print( Name( simple ), "^", n, ".", Size( g ) / Size( soc ),
> ": ", info, "\n" );
> od;
> od;
> od;
A5^1.2: Posa for 2nd closure
A5^2.2: Posa for 0th closure
A5^2.4: Posa for 0th closure
A5^3.3: Posa for 0th closure
A5^3.6: Chvatal for 1st closure, Posa for 2nd closure
PSL(2,7)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,7)^2.2: Posa for 0th closure
PSL(2,7)^2.4: Posa for 0th closure
A6^1.2: Chvatal for 0th closure, Posa for 1st closure
A6^1.2: Chvatal for 4th closure, Posa for 5th closure
A6^1.2: Chvatal for 0th closure, Posa for 1st closure
A6^2.2: Posa for 0th closure
A6^2.4: Posa for 0th closure
A6^2.4: Posa for 0th closure
A6^2.4: Posa for 0th closure
PSL(2,8)^1.3: Posa for 0th closure
PSL(2,8)^2.2: Posa for 0th closure
PSL(2,8)^2.6: Chvatal for 0th closure, Posa for 1st closure
PSL(2,11)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,11)^2.2: Posa for 0th closure
PSL(2,11)^2.4: Posa for 0th closure
PSL(2,13)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,17)^1.2: Chvatal for 0th closure, Posa for 1st closure
A7^1.2: Posa for 1st closure
PSL(2,19)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,16)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,16)^1.4: Chvatal for 0th closure, Posa for 1st closure
PSL(3,3)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSU(3,3)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,23)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,25)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,25)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,25)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,27)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,27)^1.3: Posa for 0th closure
PSL(2,27)^1.6: Chvatal for 0th closure, Posa for 1st closure
PSL(2,29)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,31)^1.2: Chvatal for 0th closure, Posa for 1st closure
A8^1.2: Chvatal for 2nd closure, Posa for 3rd closure
PSL(3,4)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(3,4)^1.2: Chvatal for 1st closure, Posa for 2nd closure
PSL(3,4)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(3,4)^1.3: Posa for 0th closure
PSL(3,4)^1.6: Chvatal for 0th closure, Posa for 1st closure
PSL(2,37)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSp(4,3)^1.2: Chvatal for 1st closure, Posa for 2nd closure
Sz(8)^1.3: Posa for 0th closure
PSL(2,32)^1.5: Posa for 0th closure
PSL(2,41)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,43)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,47)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,49)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,49)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,49)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSU(3,4)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSU(3,4)^1.4: Chvatal for 0th closure, Posa for 1st closure
PSL(2,53)^1.2: Chvatal for 0th closure, Posa for 1st closure
M12^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,59)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,61)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSU(3,5)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSU(3,5)^1.3: Posa for 0th closure
PSL(2,67)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,71)^1.2: Chvatal for 0th closure, Posa for 1st closure
A9^1.2: Chvatal for 2nd closure, Posa for 3rd closure
PSL(2,73)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,79)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,64)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,64)^1.3: Posa for 0th closure
PSL(2,64)^1.6: Chvatal for 0th closure, Posa for 1st closure
PSL(2,81)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,81)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,81)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,81)^1.4: Chvatal for 0th closure, Posa for 1st closure
PSL(2,81)^1.4: Chvatal for 0th closure, Posa for 1st closure
PSL(2,83)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,89)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(3,5)^1.2: Chvatal for 0th closure, Posa for 1st closure
M22^1.2: Posa for 1st closure
PSL(2,97)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,101)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,103)^1.2: Chvatal for 0th closure, Posa for 1st closure
J_2^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,107)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,109)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,113)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,121)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,121)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,121)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,125)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSL(2,125)^1.3: Posa for 0th closure
PSL(2,125)^1.6: Chvatal for 0th closure, Posa for 1st closure
PSp(4,4)^1.2: Chvatal for 0th closure, Posa for 1st closure
PSp(4,4)^1.4: Posa for 0th closure
]]></Example>
<!-- %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -->
<Section Label="psl2q">
<Heading>The Groups <M>&PSL;(2,q)</M></Heading>
We show that the generating graph of any group <M>&PSL;(2,q)</M>,
for <M>q \geq 2</M>, satisfies Pósa's criterion.
Throughout this section,
let <M>q = p^f</M> for a prime integer <M>p</M>, and <M>G = &PSL;(2,q)</M>.
Set <M>k = \gcd(q-1, 2)</M>.
<P/>
<E>Lemma 1:</E> (see <Cite Where="II., § 8" Key="Hup67"/>)
The subgroups of <M>G</M> are
<List>
<Mark>(1)</Mark>
<Item>
cyclic groups of order dividing <M>(q \pm 1)/k</M>,
and their normalizers,
which are dihedral groups of order <M>2 (q \pm 1)/k</M>,
</Item>
<Mark>(2)</Mark>
<Item>
subgroups of Sylow <M>p</M> normalizers, which are semidirect products of
elementary abelian groups of order <M>q</M> with cyclic groups of order
<M>(q-1)/k</M>,
</Item>
<Mark>(3)</Mark>
<Item>
subgroups isomorphic with <M>&PSL;(2, p^m)</M> if <M>m</M> divides <M>f</M>,
and isomorphic with <M>&PGL;(2, p^m)</M> if <M>2 m</M> divides <M>f</M>,
</Item>
<Mark>(4)</Mark>
<Item>
subgroups isomorphic with <M>A_4</M>, <M>S_4</M>, or <M>A_5</M>,
for appropriate values of <M>q</M>.
</Item>
</List>
<P/>
<M>G</M> contains exactly one conjugacy class of cyclic subgroups of each of
the orders <M>(q-1)/k</M> and <M>(q+1)/k</M>,
and each nonidentity element of <M>G</M> is contained in exactly one of these
subgroups or in exactly one Sylow <M>p</M> subgroup of <M>G</M>. <!-- end of lemma -->
<P/>
We estimate the number of elements that are contained in subgroups
of type (3).
<P/>
<E>Lemma 2:</E>
Let <M>n_{sf}(q)</M> denote the number of those nonidentity elements in
<M>G</M> that are contained in proper subgroups of type (3).
Then <M>n_{sf}(q) \leq q^2 (2 p (\sqrt{q}-1) / (p-1) - 1)</M>.
If <M>f</M> is a prime then <M>n_{sf}(q) \leq (2p-1) q^2</M> holds,
and if <M>p = q</M> then we have of course <M>n_{sf}(q) = 0</M>. <!-- end of lemma -->
<P/>
<E>Proof:</E>
The group <M>&PGL;(2, p^m)</M> is equal to <M>&PSL;(2, p^m)</M> for
<M>p = 2</M>, and contains <M>&PSL;(2, p^m)</M> as a subgroup of index two
if <M>p \ne 2</M>.
So the largest element order in <M>&PGL;(2, p^m)</M> is at most <M>p^m+1</M>.
Let <M>C</M> be a cyclic subgroup of order <M>(q + \epsilon)/k</M> in <M>G</M>,
for <M>\epsilon \in \{ \pm 1 \}</M>.
The intersection of <M>C</M> with any subgroup of <M>G</M> isomorphic with
<M>&PGL;(2, p^m)</M> or <M>&PSL;(2, p^m)</M>
is contained in the union of the unique subgroups of the orders
<M>\gcd(|C|, p^m + 1)</M> and <M>\gcd(|C|, p^m - 1)</M> in <M>C</M>.
So <M>C</M> contains at most <M>2 p^m - 2</M> nonidentity elements
that can lie inside subgroups isomorphic with <M>&PGL;(2, p^m)</M> or
<M>&PSL;(2, p^m)</M>.
Hence <M>C</M> contains at most <M>\sum_m (2 p^m - 2)</M> nonidentity elements
in proper subgroups of type (3),
where <M>m</M> runs over the proper divisors of <M>f</M>.
This sum is bounded from above by
<M>\sum_{{m=1}}^{{f/2}} (2 p^m - 2) \leq 2 p (\sqrt{{q}}-1) / (p-1) - 2</M>.
<P/>
The numbers of cyclic subgroups of the orders <M>(q + \epsilon)/k</M> in
<M>G</M> are <M>q (q - \epsilon) / 2</M>,
so <M>G</M> contains altogether <M>q^2</M> such cyclic subgroups.
They contain at most <M>q^2 (2 p (\sqrt{{q}}-1) / (p-1) - 2)</M>
elements inside proper subgroups of the type (3).
<P/>
All elements of order <M>p</M> in <M>G</M> are contained in subgroups of type (3), and there are exactly <M>q^2 - 1</M> such elements.
This yields the claimed bound for <M>n_{sf}(q)</M>.
The better bound for the case that <M>f</M> is a prime follows from
<M>\sum_m (2 p^m - 2) = 2 p - 2</M> if <M>m</M> ranges over the proper
divisors of <M>f</M>.
&endproof; <!-- end of proof -->
<P/>
Using these bounds, we see that the vertex degree of any element in <M>G</M>
that does not lie in subgroups of type (4) is larger than <M>|G|/2</M>.
(In fact we could use the calculations below to derive a better
asymptotic bound, but this is not an issue here.)
<P/>
<E>Lemma 3:</E>
Let <M>s \in G</M> be an element of order larger than <M>5</M>.
Then <M>|\{ g \in G; \langle g, s \rangle = G \}| > |G|/2</M>. <!-- end of lemma -->
<P/>
<E>Proof:</E>
First suppose that the order of <M>s</M> divides <M>(q+1)/k</M> or
<M>(q-1)/k</M>.
If <M>g \in G</M> such that <M>U = \langle s, g \rangle</M>
is a proper subgroup of <M>G</M> then <M>U \leq N_G(\langle s \rangle)</M> or
<M>U</M> lies in a Sylow <M>p</M> normalizer of <M>G</M> or <M>U</M> lies
in a subgroup of type (3).
Since <M>s</M> is contained in at most two Sylow <M>p</M> normalizers
(each Sylow <M>p</M> normalizer contains <M>q</M> cyclic subgroups of order
<M>(q-1)/k</M>,
and <M>G</M> contains <M>q+1</M> Sylow normalizers and <M>q (q+1)/2</M>
cyclic subgroups of order <M>(q-1)/k</M>),
the number of <M>g \in G</M> with the property that
<M>\langle s, g \rangle ¬eq; G</M> is at most
<M>N = 2(q+1)/k + 2 q(q-1)/k + n_{sf}(q) = 2(q^2+1)/k + n_{sf}(q)</M>;
for <M>s</M> of order equal to <M>(q+1)/k</M> or <M>(q-1)/k</M>,
we can set <M>N = 2(q^2+1)/k</M>.
<P/>
Any element <M>s</M> of order <M>p</M> (larger than <M>5</M>),
lies only in a unique Sylow <M>p</M> normalizer and in subgroups
of type (3), so the bound <M>N</M> holds also in this case.
<P/>
For <M>f = 1</M>, <M>N</M> is smaller than <M>|G|/2 = q (q^2-1) / (2 k)</M>
if <M>q \geq 5</M>.
(The statement of the lemma is trivially true for <M>q \leq 5</M>.)
<P/>
For primes <M>f</M>, <M>N</M> is smaller than <M>|G|/2</M>
if <M>q^2 (q-8p) > q+4</M> holds, which is true for <M>p^f > 8p</M>.
Only the following values of <M>p^f</M> with prime <M>f</M> do not satisfy
this condition:
<M>2^2</M> and <M>3^2</M> (where no element of order larger than <M>5</M>
exists),
<M>2^3</M> (where only elements of order equal to <M>q \pm 1</M> must be
considered),
<M>5^2</M> and <M>7^2</M> (where <M>n_{sf}(q) < (p-1) q (q+1)</M> because
in these cases the cyclic subgroups of order <M>(q+1)/k</M> cannot contain
nonidentity elements in subgroups of type (3)).
<P/>
Finally, if <M>f</M> is not a prime then <M>N</M> is smaller than <M>|G|/2</M>
if <M>q^2 (q - 8p (\sqrt{{q}}-1) / (p-1)) > q+4</M> holds,
which is true for <M>q \geq 256</M>.
The only values of <M>p^f</M> with non-prime <M>f</M> that do not satisfy
this condition are <M>2^4</M>, <M>2^6</M>, and <M>3^4</M>.
In all three cases, we have in fact <M>N < |G|/2</M>,
where we have to use the better bound <M>n_{sf}(q) < 16 q^2</M>
in the third case.
&endproof; <!-- end of proof -->
<P/>
In order to show that the generating graph of <M>G</M> satisfies
Pósa's criterion,
it suffices to show that the vertex degrees of involutions is larger than
the number of involutions, and that the vertex degrees of elements of orders
<M>2</M>, <M>3</M>, <M>4</M>, and <M>5</M> are larger than the number of
elements whose order is at most <M>5</M>.
<P/>
<E>Lemma 4:</E>
Let <M>n(q, m)</M> denote the number of elements of order <M>m</M> in <M>G</M>,
and let <M>\varphi(m)</M> denote the number of prime residues modulo <M>m</M>.
<List>
<Item>
We have <M>n(q, 2) = q^2 - 1</M> if <M>q</M> is even
and <M>n(q, 2) \leq q (q+1)/2</M> if <M>q</M> is odd.
</Item>
<Item>
For <M>m \in \{ 3, 4, 5 \}</M>,
we have <M>n(q, m) \leq \varphi(m) q (q+1)/2</M>.
</Item>
<Item>
We have <M>n(q, (q+1)/k) = \varphi((q+1)/k) q (q-1)/2</M>.
</Item>
</List>
<!-- end of lemma -->
<!-- Proof? -->
<P/>
<E>Lemma 5:</E>
If <M>q > 11</M>
then each involution in <M>G</M> has vertex degree larger than <M>n(q, 2)</M>.
<P/>
If <M>\varphi((q+1)/k) \geq 12</M> then each element of order <M>3</M>,
<M>4</M>, or <M>5</M> has vertex degree larger than
<M>\sum_{{m=2}}^5 n(q, m)</M>.
<!-- end of lemma -->
<P/>
<E>Proof:</E>
Let <M>s \in G</M> of order at most <M>5</M>.
For each element <M>g \in G</M> of order <M>(q+1)/k</M>,
<M>U = \langle g, s \rangle</M> is either <M>G</M> or contained in the
dihedral group of order <M>2(q+1)/k</M> that normalizes
<M>\langle g \rangle</M>.
<P/>
If <M>s</M> is an involution then the number of such dihedral groups
that contain <M>s</M> is at most <M>(q+3)/2</M>,
<!-- % concrete: the number is x, where
% x = q/2 if 2|q,
% x = (q-1)/2 if 4|(q-1),
% x = (q+3)/2 if 4|(q+1). -->
and at least
<M>n(q, (q+1)/k) - \varphi((q+1)/k) (q+3)/2 = \varphi((q+1)/k) (q^2-2q-3)/2</M>
elements of order <M>(q+1)/k</M> contribute to the vertex degree of <M>s</M>.
This number is larger than <M>q^2 - 1 \geq n(q, 2)</M>
if <M>q > 11</M> (and hence <M>\varphi((q+1)/k) \geq 3</M>) holds.
<P/>
If <M>s</M> is an element of order <M>3</M>, <M>4</M>, or <M>5</M>
then <M>U ¬eq; G</M> means that <M>s \in \langle g \rangle</M>,
so at least
<M>n(q, (q+1)/k) - 4</M> elements of order <M>(q+1)/k</M>
contribute to the vertex degree of <M>s</M>.
This number is larger than <M>5 q (q+1) > \sum_{{m=2}}^5 n(q, m)</M>
if <M>\varphi((q+1)/k) \geq 12</M>.
&endproof;
<!-- end of proof -->
<P/>
It remains to deal with the values <M>q</M> where
<M>\varphi((q+1)/k) < 12</M>, that is, <M>(q+1)/k \leq 30</M>.
We compute that the statement of Lemma 5 is true also for
prime powers <M>q</M> with <M>11 < q \leq 59</M>.
<P/>
<Example><![CDATA[
gap> TestL2q:= function( t )
> local name, orders, nccl, cl, prim, bds, n, ord;
>
> name:= Identifier( t );
> orders:= OrdersClassRepresentatives( t );
> nccl:= Length( orders );
> cl:= SizesConjugacyClasses( t );
> prim:= PrimitivePermutationCharacters( t );
> bds:= List( LowerBoundsVertexDegrees( cl, prim ), Sum );
> n:= List( [ 1 .. 5 ], i -> Sum( cl{ Filtered( [ 1 .. nccl ],
> x -> orders[x] = i ) } ) );
> if ForAny( Filtered( [ 1 .. nccl ], i -> orders[i] > 5 ),
> i -> bds[i-1] <= Size( t ) / 2 ) then
> Error( "problem with large orders for ", name );
> elif ForAny( Filtered( [ 1 .. nccl ], i -> orders[i] = 2 ),
> i -> bds[i-1] <= n[2] ) then
> Error( "problem with order 2 for ", name, "\n" );
> elif ForAny( Filtered( [ 1 .. nccl ],
> i -> orders[i] in [ 3 .. 5 ] ),
> i -> bds[i-1] <= Sum( n{ [ 2 .. 5 ] } ) ) then
> Error( "problem with order in [ 3 .. 5 ] for ", name );
> fi;
> end;;
gap> for q in Filtered( [ 13 .. 59 ], IsPrimePowerInt ) do
> TestL2q( CharacterTable(
> Concatenation( "L2(", String( q ), ")" ) ) );
> od;
]]></Example>
<P/>
For <M>2 \leq q \leq 11</M>, the statement of Lemma 5 is not true
but Pósa's criterion is satisfied for the generating graphs of the
groups <M>&PSL;(2,q)</M> with <M>2 \leq q \leq 11</M>.
<P/>
<Example><![CDATA[
gap> for q in Filtered( [ 2 .. 11 ], IsPrimePowerInt ) do
> info:= HamiltonianCycleInfoFromGroup( PSL( 2, q ) );
> if info <> "Posa for 0th closure" then
> Print( q, ": ", info, "\n" );
> fi;
> od;
]]></Example>
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
