{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Generation of sporadic simple groups by $\\pi$- and $\\pi'$-subgroups\n",
"\n",
"* Author: Thomas Breuer\n",
"* Version: OSCAR version 1.0\n",
"* Last modified: April 11, 2024\n",
"\n",
"We show the computations that are needed in order to prove the following statements from the paper\n",
"[Finite groups can be generated by a $\\pi$-subgroup and a $\\pi'$-subgroup](https://arxiv.org/abs/2103.17216).\n",
"\n",
"
\n",
"\n",
"### Proposition 2.2:\n",
"\n",
"Let $S$ be a sporadic simple group and let $P$ be a Sylow $2$-subgroup of $S$.\n",
"If $1 \\neq x \\in S$, then $S = \\langle P, x^g \\rangle$ for some $g \\in S$.\n",
"\n",
"
\n",
"\n",
"### Theorem 7.1:\n",
"\n",
"Let $S$ be a sporadic simple group and let $p \\leq q$ be primes each dividing $|S|$.\n",
"Then $S$ can be generated by a Sylow $p$-subgroup and a Sylow $q$-subgroup.\n",
"\n",
"
\n",
"\n",
"### A stronger version of Theorem 7.1:\n",
"\n",
"Let $S$ be a sporadic simple group, $p$ be a prime dividing $|S|$, and $P$ be a Sylow $p$-subgroup of $S$.\n",
"If $1 \\neq x \\in S$, then $S = \\langle P, x^g \\rangle$ for some $g \\in S$.\n",
"\n",
"
\n",
"\n",
"We will use [OSCAR](https://oscar.computeralgebra.de) for the computations."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\r",
" ___ ____ ____ _ ____\n",
" / _ \\ / ___| / ___| / \\ | _ \\ | Combining ANTIC, GAP, Polymake, Singular\n",
"| | | |\\___ \\| | / _ \\ | |_) | | Type \"?Oscar\" for more information\n",
"| |_| | ___) | |___ / ___ \\| _ < | Manual: https://docs.oscar-system.org\n",
" \\___/ |____/ \\____/_/ \\_\\_| \\_\\ | Version 1.0.0\n"
]
}
],
"source": [
"using Oscar"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"First we show Proposition 2.2.\n",
"Let $S$ be a sporadic simple group, fix a Sylow $2$-subgroup $P$ of $S$, and let $x$ be a nonidentity element in $S$. We use known information about maximal subgroups of $S$ to show that $x^S$ is not a subset of the union\n",
"of those maximal subgroups in $S$ that contain $P$.\n",
"\n",
"
\n",
"\n",
"Let $M$ be a maximal subgroup of $S$ with the property $P \\leq M$. The number of $S$-conjugates of $M$ that contain $P$ is equal to $|N_S(P)|/|N_M(P)| \\leq [N_S(P):P]$, thus these subgroups can contain at most $[N_S(P):P] |x^S \\cap M|$ elements from the class $x^S$.\n",
"\n",
"
\n",
"\n",
"Thus the number of elements in $x^S$ that generate a proper subgroup of $S$ together with $P$ is bounded from above by $[N_S(P):P] \\sum_M |x^S \\cap M|$, where the sum is taken over representatives $M$ of conjugacy classes of maximal subgroups of odd index in $S$.\n",
"\n",
"
\n",
"\n",
"Let $1_M^S$ denote the permutation character of the action of $S$ on the cosets of $M$. We have $|x^S \\cap M| = |x^S| 1_M^S(x) / 1_M^S(1)$.\n",
"Hence we are done when we show that\n",
"$$\n",
"[N_S(P):P] \\sum_M 1_M^S(x) / 1_M^S(1) < 1\n",
"$$\n",
"holds.\n",
"\n",
"
\n",
"\n",
"The numbers $[N_S(P):P]$ can be read off from [Wil98, Table I](http://dx.doi.org/10.1006/jabr.1998.7450).\n",
"Here we use the fact that the character table of the Sylow $2$-normalizer of $S$ is available except if $S$ is one of $Co_1$, $J_4$, $F_{3+}$, $B$, or $M$, and that the Sylow $2$-subgroup is self-normalizing in these cases."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[\"M11\", \"M12\", \"J1\", \"M22\", \"J2\", \"M23\", \"HS\", \"J3\", \"M24\", \"McL\", \"He\", \"Ru\", \"Suz\", \"ON\", \"Co3\", \"Co2\", \"Fi22\", \"HN\", \"Ly\", \"Th\", \"Fi23\", \"Co1\", \"J4\", \"F3+\", \"B\", \"M\"]\n"
]
}
],
"source": [
"spor_names = all_character_table_names(is_sporadic_simple => true,\n",
" is_duplicate_table => false; ordered_by = order);\n",
"println(spor_names)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Co1\n",
"J4\n",
"F3+\n",
"B\n",
"M\n"
]
}
],
"source": [
"normindices = Dict(\"Co1\" => 1, \"J4\" => 1, \"F3+\" => 1, \"B\" => 1, \"M\" => 1);\n",
"for name in spor_names\n",
" n = character_table(\"$(name)N2\")\n",
" if n == nothing\n",
" println(name)\n",
" else\n",
" two_part = 1\n",
" ord = order(n)\n",
" while iseven(ord)\n",
" ord = div(ord, 2)\n",
" two_part = 2 * two_part\n",
" end\n",
" normindices[name] = div(order(n), two_part)\n",
" end\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For all sporadic simple groups $S$ except the Monster group, the primitive permutation characters $1_M^S$ can be computed from the data about maximal subgroups contained in the library of character tables.\n",
"\n",
"
\n",
"\n",
"Here we omit the computations for the Baby Monster group because they need a long time, due to the fact that the class fusion of one maximal subgroup is currently not known. (It turns out that the result does not depend on the class fusion, but computing this is lengthy.)\n",
"\n",
"
\n",
"\n",
"We see that the left hand side of the above inequality is always less than or equal to $3/5$, in particular it is less than $1$."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Any[\"J2\", 3//5]\n"
]
}
],
"source": [
"maxbound = [];\n",
"for name in filter(x -> x != \"M\" && x != \"B\", spor_names)\n",
" t = character_table(name)\n",
" mx = [character_table(m) for m in maxes(t)]\n",
" odd = filter(s -> isodd(div(order(t), order(s))), mx)\n",
" primperm = [trivial_character(s)^t for s in odd]\n",
" wsum = normindices[name] * sum(pi -> [ZZ(x.data) // degree(pi) for x in values(pi)], primperm)\n",
" push!(maxbound, [name, maximum(wsum[2:length(wsum)])])\n",
"end\n",
"sort!(maxbound, by = x -> -x[2]);\n",
"println(maxbound[1])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The Monster group is known to contain exactly five classes of maximal subgroups of odd index, of the following structures.\n",
"\n",
"
\n",
"\n",
"$2^{1+24}.Co_1$ (the normalizer of a $2B$ element in the Monster),\n",
"$2^{10+16}.O_{10}^+(2)$,\n",
"$2^{2+11+22}.(M_{24} \\times S_3)$,\n",
"$2^{5+10+20}.(S_3 \\times L_5(2))$,\n",
"$[2^{39}].(L_3(2) \\times 3S_6)$.\n",
"\n",
"
\n",
"\n",
"The corresponding permutation characters are known, see [the documentation of the character table library](http://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/doc2/chap8.html#X8337F3C682B6BE63).\n",
"First we read the information about the known primitive permutation characters of the Monster into the Julia session, and extract the primitive permutation characters of odd degree."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"46"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"filename = string(GAP.Globals.Filename(GAP.Globals.DirectoriesPackageLibrary(GAP.Obj(\"ctbllib\"),GAP.Obj(\"data\")), GAP.Obj(\"prim_perm_M.json\")));\n",
"str = read(filename, String);\n",
"monster_prim_data = Oscar.JSON.parse(str; inttype = BigInt)[2];\n",
"length(monster_prim_data)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"t = character_table(\"M\");\n",
"monstermaxindices = [];\n",
"monstermaxtables = [];\n",
"for entry in monster_prim_data\n",
" if length(entry) == 1\n",
" s = character_table(entry[1])\n",
" push!(monstermaxtables, s)\n",
" push!(monstermaxindices, div(order(t), order(s)))\n",
" else\n",
" push!(monstermaxtables, nothing)\n",
" push!(monstermaxindices, entry[2][1])\n",
" end\n",
"end;\n",
"odd_prim = Vector{ZZRingElem}[];\n",
"for i in 1:length(monster_prim_data)\n",
" if isodd(monstermaxindices[i])\n",
" if monstermaxtables[i] != nothing\n",
" push!(odd_prim, [ZZ(x.data) for x in trivial_character(monstermaxtables[i])^t])\n",
" else\n",
" push!(odd_prim, Vector{ZZRingElem}(monster_prim_data[i][2]))\n",
" end\n",
" end\n",
"end;\n",
"length(odd_prim)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we can use the same approach as before."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"12784979//103007903752128375"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"wsum = normindices[\"M\"] * sum(pi -> [x // pi[1] for x in values(pi)], odd_prim);\n",
"mx = maximum(wsum[2:length(wsum)])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Next we show Theorem 7.1 and its stronger version stated above. Let us first assume that $S$ is not the Monster.\n",
"\n",
"
\n",
"\n",
"As a first step, we generalize the approach from the above computations in order to check for which prime divisors $p$ of $|S|$ and for which nontrivial conjugacy classes $x^S$ of $S$ the group $S$ is generated by a Sylow $p$-subgroup $P$ together with a conjugate of $x$.\n",
"\n",
"
\n",
"\n",
"The upper bound $[N_S(P):P]$ for $|N_S(P)|/|N_M(P)|$, for a maximal subgroup $M$ of $S$ that contains $P$, is not good enough in some of the cases considered here. Instead of it, we compute the upper bound $u(S, M, p)$\n",
"which is defined as follows; we assume that we know $|N_S(P)|$.\n",
"\n",
"
\n",
"\n",
"- If $P$ is cyclic then we can compute $|N_M(P)|$ from the character table of $M$, and set $u(S, M, p) = |N_S(P)| / |N_M(P)|$.\n",
"- Otherwise, if $P$ is normal in $M$, we set $u(S, M, p) = |N_S(P)| / |M|$.\n",
"- Otherwise, if we know a subgroup $U$ of $M$ such that $P$ is a proper normal subgroup of $U$, we set $u(S, M, p) = |N_S(P)| / |U|$.\n",
"- Otherwise, we set $u(S, M, p) = |N_S(P)| / |P|$."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"function upper_bound( tblS, tblM, p )\n",
" facts = collect(factor(order(tblS)))\n",
" pos = findfirst(x -> x[1] == p, facts)\n",
"\n",
" ppart = p^facts[pos][2]\n",
" ppartposS = filter(i -> orders_class_representatives(tblS)[i] == ppart, 1:nrows(tblS))\n",
" if 0 < length(ppartposS)\n",
" # P is cyclic.\n",
" if tblM == nothing\n",
" return (orders_centralizers(tblS)[ppartposS[1]] * euler_phi(ppart)\n",
" // length(ppartposS)) // ppart\n",
" else\n",
" ppartposM = filter(i -> orders_class_representatives(tblM)[i] == ppart, 1:nrows(tblM))\n",
" return (orders_centralizers(tblS)[ppartposS[1]] * euler_phi(ppart)\n",
" // length(ppartposS)) //\n",
" (orders_centralizers(tblM)[ppartposM[1]] * euler_phi(ppart)\n",
" // length(ppartposM))\n",
" end\n",
" end\n",
"\n",
" # Compute |N_S(P)|.\n",
" n = character_table(\"$(identifier(tblS))N$p\")\n",
" if n != nothing\n",
" N_S = order(n)\n",
" elseif p == 2\n",
" N_S = ppart * normindices[identifier(tblS)]\n",
" elseif identifier(tblS) == \"M\" && p == 3\n",
" # The Sylow 3-normalizer is contained in 3^(3+2+6+6):(L3(3)xSD16)\n",
" N_S = ppart * 2^6\n",
" elseif identifier(tblS) == \"F3+\" && p == 3\n",
" N_S = ppart * 8\n",
" else\n",
" error(\"cannot compute |N_S(P)|\")\n",
" end\n",
"\n",
" if tblM == nothing\n",
" return N_S // ppart\n",
" elseif sum(class_lengths(tblM)[class_positions_of_pcore(tblM, p)]) == ppart\n",
" # P is normal in M.\n",
" return N_S // order(tblM)\n",
" end\n",
" \n",
" # Inspect known character tables of subgroups of M.\n",
" f = N_S // ppart\n",
" for subname in Oscar.names_of_fusion_sources(tblM)\n",
" u = character_table(subname)\n",
" if class_positions_of_kernel(known_class_fusion(u, tblM)[2]) == [1] &&\n",
" sum([order(u) // x for x in orders_centralizers(u)[class_positions_of_pcore(u, p)]]) == ppart\n",
" f = min(f, N_S // order(u));\n",
" end\n",
" end\n",
"\n",
" return f;\n",
"end;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We run over the sporadic simple groups (except the Monster), and collect in the list `badcases_strong` those \"bad\" prime divisors $p$ of $|S|$ and conjugacy class representatives $x$ of nonidentity elements in $S$ for which\n",
"$$\\sum_M u(S, M, p) 1_M^S(x) / 1_M^S(1) \\geq 1$$\n",
"holds, where the sum is taken over representatives $M$ of conjugacy classes of maximal subgroups of $S$ whose index in $S$ is coprime to $p$. In these cases, we have to find other arguments.\n",
"\n",
"
\n",
"\n",
"For the proof of Theorem 7.1 in [the abovementioned paper](https://arxiv.org/abs/2103.17216),\n",
"we can discard all those entries from the list of \"bad\" $p$ and $x$ where $x$ is not a $q$-element, for some prime $q$, or where another nonidentity $q$-element exists that does not occur in the list. This is done by collecting a second list `badcases_thm` of the remaining \"bad\" cases.\n",
"\n",
"
\n",
"\n",
"For the proof of the stronger version, we will later explicitly compute group elements from the classes in question that generate $S$ together with a Sylow $p$-subgroup.\n",
"\n",
"(The only technical complication is that the class fusion of maximal subgroups of the type $(2^2 \\times F_4(2)):2$ of the Baby Monster is currently not known, thus we cannot simply induce the trivial character in this case. However, the permutation character is uniquely determined by the two character tables.)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"badcases_thm = [];\n",
"badcases_strong = [];\n",
"for name in filter(x -> x != \"M\" && x != \"B\", spor_names)\n",
" t = character_table(name)\n",
" orders = orders_class_representatives(t)\n",
" n = nrows(t)\n",
" mx = [character_table(m) for m in maxes(t)]\n",
" for p in prime_divisors(order(t))\n",
" primperm = []\n",
" good = filter(s -> mod(order(t) // order(s), p) != 0, mx)\n",
" for s in good\n",
" if known_class_fusion(s, t)[1]\n",
" push!(primperm, [ZZ(x.data) for x in trivial_character(s)^t]) \n",
" else\n",
" ind = Set([induce(trivial_character(s), t, map)\n",
" for map in possible_class_fusions(s, t)])\n",
" length(ind) == 1 || error(\"permutation character not uniquely determined\")\n",
" push!(primperm, [ZZ(x.data) for x in pop!(ind)]) \n",
" end\n",
" end\n",
" weighted = []\n",
" for i in 1:length(good)\n",
" bd = upper_bound(t, good[i], p)\n",
" pi = primperm[i]\n",
" push!(weighted, [bd * pi[j] // pi[1] for j in 1:length(pi)])\n",
" end\n",
" sumx = sum(weighted)\n",
" badpos = filter(i -> sumx[i] >= 1, 2:length(sumx))\n",
" if length(badpos) != 0\n",
" # We have to deal with this case for the stronger variant of Theorem 1.7.\n",
" push!(badcases_strong, (name, p, copy(badpos)))\n",
" for i in copy(badpos)\n",
" facts = collect(factor(orders[i]))\n",
" if length(facts) == 1\n",
" q = facts[1][1]\n",
" # If we know some `q`-element for which the bound is good enough\n",
" # then we need not deal with this class for Theorem 1.7.\n",
" if any(j -> mod(orders[j], q) == 0 &&\n",
" length(collect(factor(orders[j]))) == 1 &&\n",
" !(j in badpos), 2:n)\n",
" setdiff!(badpos, i)\n",
" end\n",
" end\n",
" end\n",
" length(badpos) != 0 && push!(badcases_thm, (name, p, badpos))\n",
" end\n",
" end\n",
"end;"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2-element Vector{Any}:\n",
" (\"M23\", 3, [3])\n",
" (\"HS\", 3, [4, 11])"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"badcases_thm"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"18-element Vector{Any}:\n",
" (\"M11\", 5, [2])\n",
" (\"M12\", 5, [3, 4])\n",
" (\"M22\", 5, [2])\n",
" (\"M22\", 3, [2])\n",
" (\"J2\", 3, [2])\n",
" (\"M23\", 5, [2])\n",
" (\"M23\", 7, [2])\n",
" (\"M23\", 3, [2, 3])\n",
" (\"HS\", 5, [2, 3, 5])\n",
" (\"HS\", 3, [2, 3, 4, 5, 6, 7, 9, 11])\n",
" (\"M24\", 5, [2, 4])\n",
" (\"M24\", 7, [2, 4])\n",
" (\"He\", 5, [2])\n",
" (\"Co2\", 3, [2, 3])\n",
" (\"Fi22\", 5, [2])\n",
" (\"Fi22\", 7, [2])\n",
" (\"Fi23\", 5, [2, 3, 5])\n",
" (\"Fi23\", 7, [2])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"badcases_strong"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Most of these open cases can be ruled out by constructing the group $S$ and a Sylow $p$-subgroup $P$ in question and then finding explicit elements $x$ such that $S$ is generated by $P$ and $x$. For that, we use the data from the\n",
"[ATLAS of Group Representations](http://brauer.maths.qmul.ac.uk/Atlas/v3).\n",
"\n",
"
\n",
"\n",
"The following function tries to find random elements from all conjugacy classes of nonidentity elements that have the desired property. It returns $P$ and the list of class representatives that generate together with $P$ if such\n",
"elements were found.\n",
"Thus the function will not return if the generation property does not hold."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"function prove_generation(name, prg, p)\n",
" S = atlas_group(name)\n",
" P = sylow_subgroup(S, p)[1]\n",
" reps = evaluate(prg, gens(S))\n",
" good = elem_type(S)[]\n",
" for x in filter(!isone, reps)\n",
" U = P\n",
" g = x\n",
" while order(U) < order(S)\n",
" g = x^rand(S)\n",
" U = sub(S, vcat(gens(P), [g]))[1]\n",
" end\n",
" push!(good, g)\n",
" end\n",
" return (P, good)\n",
"end;"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"no classes script for (\"He\", 5, [2])\n",
"no classes script for (\"Fi22\", 5, [2])\n",
"no classes script for (\"Fi22\", 7, [2])\n",
"no classes script for (\"Fi23\", 5, [2, 3, 5])\n",
"no classes script for (\"Fi23\", 7, [2])\n"
]
}
],
"source": [
"for (name, p, badpos) in badcases_strong\n",
" prg = atlas_program(name, :classes)\n",
" if prg == nothing\n",
" println(\"no classes script for \", (name, p, badpos))\n",
" else\n",
" prove_generation(name, prg, p)\n",
" end\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the remaining cases, we show only the generation property for the class representatives in the list. These are involutions from the class `2A`, and for the group $Fi_{23}$ and $p = 5$ additionally elements from the classes `2B` and `3A`.\n",
"\n",
"
\n",
"\n",
"A `2A` element in the group $He$ can be found as the fifth power of any element of order $10$."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"S = atlas_group(\"He\");\n",
"x = rand(S);\n",
"while order(x) != 10 x = rand(S); end\n",
"x = x^5;\n",
"P5 = sylow_subgroup(S, 5)[1];\n",
"g = x^rand(S);\n",
"U = sub(S, vcat(gens(P5), [g]))[1]\n",
"while order(U) != order(S)\n",
" g = x^rand(S)\n",
" U = sub(S, vcat(gens(P5), [g]))[1]\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A `2A` element in the group $Fi_{22}$ can be found as the $15$-th power of any element of order $30$."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"S = atlas_group(\"Fi22\");\n",
"x = rand(S);\n",
"while order(x) != 30 x = rand(S); end\n",
"x = x^15;\n",
"P5 = sylow_subgroup(S, 5)[1];\n",
"g = x^rand(S);\n",
"U = sub(S, vcat(gens(P5), [g]))[1]\n",
"while order(U) != order(S)\n",
" g = x^rand(S)\n",
" U = sub(S, vcat(gens(P5), [g]))[1]\n",
"end\n",
"P7 = sylow_subgroup(S, 7)[1];\n",
"g = x^rand(S);\n",
"U = sub(S, vcat(gens(P7), [g]))[1]\n",
"while order(U) != order(S)\n",
" g = x^rand(S);\n",
" U = sub(S, vcat(gens(P7), [g]))[1]\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A `2A` element in the group $Fi_{23}$ can be found as the $21$-st power of any element of order $42$."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"S = atlas_group(\"Fi23\");\n",
"x = rand(S);\n",
"while order(x) != 42 x = rand(S); end\n",
"x = x^21;\n",
"P5 = sylow_subgroup(S, 5)[1];\n",
"g = x^rand(S);\n",
"U = sub(S, vcat(gens(P5), [g]))[1]\n",
"while order(U) != order(S)\n",
" g = x^rand(S)\n",
" U = sub(S, vcat(gens(P5), [g]))[1]\n",
"end\n",
"P7 = sylow_subgroup(S, 7)[1];\n",
"g = x^rand(S);\n",
"U = sub(S, vcat(gens(P7), [g]))[1]\n",
"while order(U) != order(S)\n",
" g = x^rand(S);\n",
" U = sub(S, vcat(gens(P7), [g]))[1]\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A `2B` element in the group $Fi_{23}$ can be found as the $30$-th power of any element of order $60$."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"x60 = rand(S);\n",
"while order(x60) != 60 x60 = rand(S); end\n",
"x = x60^30;\n",
"g = x^rand(S);\n",
"U = sub(S, vcat(gens(P5), [g]))[1]\n",
"while order(U) != order(S)\n",
" g = x^rand(S)\n",
" U = sub(S, vcat(gens(P5), [g]))[1]\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A `3A` element in the group $Fi_{23}$ can be found as the $20$-th power of any element of order $60$."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"x = rand(S);\n",
"while order(x) != 60 x = rand(S); end\n",
"x = x60^20;\n",
"g = x^rand(S);\n",
"U = sub(S, vcat(gens(P5), [g]))[1]\n",
"while order(U) != order(S)\n",
" g = x^rand(S)\n",
" U = sub(S, vcat(gens(P5), [g]))[1]\n",
"end"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the open case for the Baby Monster, we have to show that the group is generated by a `2A` element and an element of order $7$. This can be done character-theoretically, for example as follows. There are such elements $x$ and $y$ whose product $x y$ has order $47$, and the only proper subgroups of the Baby Monster that contain elements\n",
"of order $47$ are contained in maximal subgroups of the type $47:23$. Thus $x$ and $y$ generate the Baby Monster."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1-element Vector{String}:\n",
" \"47:23\""
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"t = character_table(\"B\");\n",
"ords = orders_class_representatives(t);\n",
"pos7 = filter(i -> ords[i] == 7, 1:length(ords))\n",
"pos47 = filter(i -> ords[i] == 47, 1:length(ords))\n",
"class_multiplication_coefficient(t, 2, pos7[1], pos47[1]) != 0\n",
"filter(x -> mod(order(character_table(x)), 47) == 0, maxes(t))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now consider the case that $S$ is the Monster, which is special because the complete list of classes of maximal subgroups of $S$ was not known at the time when the paper was written. At that time, we knew $44$ classes of maximal subgroups, and we knew that each possible additional maximal subgroup is almost simple and has socle $L_2(13)$, $U_3(4)$, $U_3(8)$, or $Sz(8)$. This implies that we knew all those maximal subgroups that contain a Sylow $p$-subgroup of $S$ except in the case $p = 19$, where maximal subgroups with socle $U_3(8)$ may arise.\n",
"\n",
"
\n",
"\n",
"Thus let us first consider that at least one of $p$, $r$ is different from $19$. In this situation, we use the same approach as for the other sporadic simple groups. The only complication is that not all permutation characters $1_M^S$, for the relevant maximal subgroups $M$ of $S$, are known; however, if this happens then the character table of $M$ is known, and we can compute the possible permutation characters, and take the common upper bounds for these characters. In each case, we get that the claimed property holds."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"t = character_table(\"M\");\n",
"orders = orders_class_representatives(t);\n",
"for p in setdiff(prime_divisors(order(t)), [19])\n",
" goodpos = filter(i -> mod(monstermaxindices[i], p) != 0, 1:length(monster_prim_data))\n",
" sumx = zeros(ZZRingElem, ncols(t))\n",
" for i in goodpos\n",
" if length(monster_prim_data[i]) == 2\n",
" # We know the permutation character but not the subgroup table.\n",
" bd = upper_bound(t, nothing, p)\n",
" sumx = sumx + [bd * ZZ(x) // monstermaxindices[i] for x in monster_prim_data[i][2]]\n",
" else\n",
" s = monstermaxtables[i]\n",
" if known_class_fusion(s, t)[1]\n",
" # We can compute the permutation character.\n",
" bd = upper_bound(t, s, p)\n",
" sumx = sumx + [bd * ZZ(x.data) // monstermaxindices[i] for x in trivial_character(s)^t]\n",
" else\n",
" # We get only candidates for the permutation character.\n",
" cand = Set([[ZZ(x.data) for x in induce(trivial_character(s), t, map)]\n",
" for map in possible_class_fusions(s, t)])\n",
" # For each column, take the maximum of the possible values. \n",
" mat = matrix(ZZ, collect(cand))\n",
" mx = [maximum(mat[1:nrows(mat), i]) for i in 1:ncols(mat)]\n",
" bd = upper_bound(t, s, p)\n",
" sumx = sumx + [bd * x // monstermaxindices[i] for x in mx]\n",
" end\n",
" end\n",
" end\n",
" badpos = filter(i -> sumx[i] >= 1, 2:length(sumx));\n",
" if length(badpos) > 0\n",
" error(\"p = $p: check open cases in $badpos\");\n",
" end\n",
"end;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, let $p = r = 19$. The group $S$ has exactly one class of elements of order $19$. Let $x$ be such an element. From the character table of $S$, we compute that there exist conjugates $y$ of $x$ such that $x y$ has order $71$. Since $\\langle x, y \\rangle = \\langle x, x y \\rangle$ holds and no maximal subgroup of $S$ has order divisible by $19 \\cdot 71$, we have $\\langle x, y \\rangle = S$."
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1-element Vector{Int64}:\n",
" 63"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pos19 = filter(i -> orders[i] == 19, 1:length(orders))"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2-element Vector{Int64}:\n",
" 169\n",
" 170"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"pos71 = filter(i -> orders[i] == 71, 1:length(ords))"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"true"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"class_multiplication_coefficient(t, pos19[1], pos19[1], pos71[1]) != 0"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"false"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"any(x -> mod(order(t) // x, 19 * 71) == 0, monstermaxindices)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"false"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"any(x -> mod(order(character_table(x)), 71) == 0, [\"L2(13)\", \"U3(4)\", \"U3(8)\", \"Sz(8)\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*Remark* added in December 2023:\n",
"\n",
"Meanwhile the complete list of conjugacy classes of maximal subgroups of the Monster group is known, due to [a paper by Dietrich, Lee, and Popiel](http://export.arxiv.org/abs/2304.14646).\n",
"The result is that there are two more classes than had been known before, which consist of groups of the structure $L_2(13).2$ and $U_3(4).4$, respectively."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Julia 1.8.5",
"language": "julia",
"name": "julia-1.8"
},
"language_info": {
"file_extension": ".jl",
"mimetype": "application/julia",
"name": "julia",
"version": "1.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}