Skip to content

\(\mathrm{M}_{22}\) as a subgroup of Mathieu group M23 (Presentation 1)

The presentation comes from the ATLAS of Group Representations. The subgroup generators come from the corresponding ATLAS program.

The script includes the additional relation \((abab^2ab^2)^6 = 1\), which its source marks as redundant and useful. We do not verify that this relation is redundant here.

The computation

The recorded run took about 282 milliseconds. The animation shows its progress, with the number of active nodes and the proportion of defined edges.

Progress of the Todd–Coxeter computation.

Claim

Let \(u\) and \(v\) be the two subgroup words listed in the code below. If

\[ H = \langle u,v \rangle \cong \mathrm{M}_{22}, \]

then

\[ [\mathrm{M}_{23}:H] = 23. \]

We verify the claimed index, but not the claimed isomorphism type. In the code, uppercase letters denote inverses. The presentation replaces A by a, since \(a^2=1\), and B represents \(b^{-1}\).

ATLAS subgroup generators for M22

The ATLAS subgroup page gives a and bababbab as generators for M22, but the second word is incorrect. Expanding the corresponding straightline program gives bababbbab, with one extra b. The correct pair is therefore a and bababbbab, generating a subgroup of index \(23\) in M23.

The word babaBab used in the code is equivalent to bababbbab: B denotes \(b^{-1}\), which equals \(b^3\) because \(b^4=1\).

The code

The following script includes the full presentation and can be run on its own.

Code
from datetime import timedelta

from libsemigroups_pybind11 import (
    Presentation,
    ToddCoxeter,
    congruence_kind,
    presentation,
)
from libsemigroups_pybind11.words import parse_relations

# Enable the empty word and inverses so the presentation defines a group.
p = Presentation("abAB")
p.contains_empty_word(True)
presentation.add_inverse_rules(p, "ABab")

# Add the defining relations
presentation.add_rule(p, parse_relations("a^2"), "")
presentation.add_rule(p, parse_relations("b^4"), "")
presentation.add_rule(p, parse_relations("(ab)^23"), "")
presentation.add_rule(p, parse_relations("(ab^2)^6"), "")
presentation.add_rule(p, parse_relations("(ABab)^6"), "")
presentation.add_rule(p, parse_relations("(abaBab^2)^4"), "")
presentation.add_rule(p, parse_relations("(ab)^3aBab^2(abaB)^2(ab)^3(aB)^3"), "")
presentation.add_rule(
    p, parse_relations("(abab^2ab^2)^6"), ""
)  # Is redundant, but very useful.
presentation.add_rule(p, parse_relations("(abab^2)^3(ab^2aB)^2abab^2abaBab^2"), "")
presentation.replace_subword(p, "A", "a")
p.alphabet("Bab")

# M22, order 443520, expected index 23.
# Source: https://brauer.maths.qmul.ac.uk/Atlas/spor/M23/words/M23G1-max1W1
# ATLAS output words simplified using a^2 = b^4 = 1; B denotes b^-1.
tc = ToddCoxeter(congruence_kind.onesided, p)
for word in (
    "a",
    "babaBab",
):
    tc.add_generating_pair(word, "")

tc.report_every(timedelta(milliseconds=3.3))

actual_index = tc.number_of_classes()
print(f"The index of M22 is {actual_index}")
if actual_index != 23:
    raise RuntimeError(f"expected index 23, got {actual_index}")

The output

Truncated output from the Python script
++++++++++++++++++++++++++++++++
#0: ToddCoxeter: RUN 0 START (strategy() = hlt)
#0: ToddCoxeter: |A| = 3, |R| = 13, |u| + |v| ∈ [2, 48], ∑(|u| + |v|) = 246
++++++++++++++++++++++++++++++++
#0: ToddCoxeter: HLT 0.0 START
#0: ToddCoxeter: HLT 0.0.0        |       active |          killed |        defined
#0: ToddCoxeter: nodes            |            7 |               0 |              7
#0: ToddCoxeter:                  |       active |         missing |     % complete
#0: ToddCoxeter: edges            |            8 |              13 |          38.1%
#0: ToddCoxeter: time             | run 0 = 26µs | all runs = 26µs | elapsed = 90µs
++++++++++++++++++++++++++++++++
#1: ToddCoxeter: HLT 0.0.1        |       active |         killed |       defined
[... lines omitted ...]
#1: ToddCoxeter:                   |        active |          missing |      % complete
#1: ToddCoxeter: edges             |            69 |                0 |          100.0%
#1: ToddCoxeter: diff 0.1.69       |            +0 |               +0 |           +0.0%
#1: ToddCoxeter: diff 0.1.0        |           +61 |              -13 |          +61.9%
#1: ToddCoxeter: phase 0.1 = 281ms | run 0 = 281ms | all runs = 281ms | elapsed = 281ms
++++++++++++++++++++++++++++++++
#0: ToddCoxeter: RUN 0 STOP (finished)
#0: ToddCoxeter: run 0                |     lookahead |       lookbehind |             hlt |       felsch
#0: ToddCoxeter: num. phases          |             0 |                0 |               1 |            0
#0: ToddCoxeter: time spent in phases |        - (0%) |           - (0%) |     275ms (98%) |       - (0%)
#0: ToddCoxeter: phase 0.1 = 282ms    | run 0 = 282ms | all runs = 282ms | elapsed = 282ms
The index of M22 is 23

The computed index is the claimed index: \(23\).

Note

The output and timings may vary between machines, but the final result should be the same.