Skip to content

\(L_2(7)\) as a subgroup of Mathieu group M24

The presentation comes from the ATLAS Magma file, with the additional relation \([a,b^{-1}abab]^5=1\) enabled as in the overview. The ATLAS source marks this relation as redundant. We do not verify that this relation is redundant here.

The subgroup generators come from the corresponding ATLAS program.

The computation

The recorded run took about 41.647 seconds. 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 L_2(7), \]

then

\[ [\mathrm{M}_{24}:H] = 1,457,280. \]

We verify the claimed index, but not the claimed isomorphism type. In the code, uppercase letters denote inverses: A represents \(a^{-1}\) and B represents \(b^{-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^3"), "")
presentation.add_rule(p, parse_relations("(ab)^23"), "")
presentation.add_rule(p, parse_relations("(ABab)^12"), "")
# [a, bab] = a^-1 (bab)^-1 a (bab).
presentation.add_rule(p, parse_relations("(ABABabab)^5"), "")
presentation.add_rule(p, parse_relations("(ababaB)^3(abaBaB)^3"), "")
# [a, b^-1 a b a b]^5 = 1, marked redundant in the ATLAS source.
presentation.add_rule(p, parse_relations("(ABABAbaBabab)^5"), "")
presentation.add_rule(p, parse_relations("(ab(abaB)^3)^4"), "")

presentation.replace_word_with_new_generator(p, presentation.longest_subword_reducing_length(p))
presentation.replace_word_with_new_generator(p, presentation.longest_subword_reducing_length(p))
presentation.sort_each_rule(p)
presentation.sort_rules(p)

# L2(7), order 168, expected index 1457280.
# Source: https://brauer.maths.qmul.ac.uk/Atlas/spor/M24/words/M24G1-max9W1
# ATLAS output words simplified using a^2 = b^3 = 1; B denotes b^-1.
tc = ToddCoxeter(congruence_kind.onesided, p)
# Felsch settings from the original m24.py enumeration.
tc.strategy(tc.options.strategy.felsch)
tc.def_version(tc.options.def_version.two)
tc.def_policy(tc.options.def_policy.discard_all_if_no_space)
tc.use_relations_in_extra(True)
tc.def_max(10000)
tc.lower_bound(1457280)
for word in (
    "a",
    "baBabaBabaBabaBaBababaBabaBababababaBabaBabaBabaB",
):
    tc.add_generating_pair(word, "")

tc.report_every(timedelta(seconds=1))

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

The output

Truncated output from the Python script
++++++++++++++++++++++++++++++++
#0: ToddCoxeter: RUN 0 START (strategy() = felsch)
#0: ToddCoxeter: |A| = 6, |R| = 14, |u| + |v| ∈ [2, 45], ∑(|u| + |v|) = 178
++++++++++++++++++++++++++++++++
#0: ToddCoxeter: FELSCH 0.0 START
#0: ToddCoxeter: FELSCH 0.0.0     |        active |           killed |         defined
#0: ToddCoxeter: nodes            |           164 |               29 |             193
#0: ToddCoxeter:                  |        active |          missing |      % complete
#0: ToddCoxeter: edges            |           232 |              752 |           23.6%
#0: ToddCoxeter: time             | run 0 = 107µs | all runs = 107µs | elapsed = 175µs
++++++++++++++++++++++++++++++++
#1: ToddCoxeter: FELSCH 0.0.1       |         active |            killed |          defined
#1: ToddCoxeter: nodes              |      2,083,767 |           254,278 |        2,338,059
#1: ToddCoxeter: diff 0.0.0         |     +2,083,603 |          +254,249 |       +2,337,866
#1: ToddCoxeter:                    |         active |           missing |       % complete
#1: ToddCoxeter: edges              |      8,320,554 |         4,182,048 |            66.6%
[... lines omitted ...]
#1: ToddCoxeter: diff 0.1.41         |              +0 |                 +0 |             +0.0%
#1: ToddCoxeter: diff 0.1.0          |      +8,743,448 |               -752 |            +76.4%
#1: ToddCoxeter: phase 0.1 = 41.192s | run 0 = 41.192s | all runs = 41.192s | elapsed = 41.192s
++++++++++++++++++++++++++++++++
#0: ToddCoxeter: FELSCH 0.1.43       |          active |             killed |           defined
#0: ToddCoxeter: nodes               |       1,457,280 |         74,443,085 |        75,900,365
#0: ToddCoxeter: diff 0.1.42         |              +0 |                 +0 |                +0
#0: ToddCoxeter: diff 0.1.0          |      +1,457,116 |        +74,443,056 |       +75,900,172
#0: ToddCoxeter:                     |          active |            missing |        % complete
#0: ToddCoxeter: edges               |       8,743,680 |                  0 |            100.0%
#0: ToddCoxeter: diff 0.1.42         |              +0 |                 +0 |             +0.0%
#0: ToddCoxeter: diff 0.1.0          |      +8,743,448 |               -752 |            +76.4%
#0: ToddCoxeter: phase 0.1 = 41.399s | run 0 = 41.400s | all runs = 41.400s | elapsed = 41.400s
++++++++++++++++++++++++++++++++
#0: ToddCoxeter: RUN 0 STOP (finished)
#0: ToddCoxeter: run 0                |       lookahead |         lookbehind |               hlt |        felsch
#0: ToddCoxeter: num. phases          |               0 |                  0 |                 0 |             1
#0: ToddCoxeter: time spent in phases |          - (0%) |             - (0%) |            - (0%) | 41.152s (99%)
#0: ToddCoxeter: phase 0.1 = 41.647s  | run 0 = 41.647s | all runs = 41.647s | elapsed = 41.647s
The index of L2(7) is 1457280

The computed index is the claimed index: \(1,457,280\).

Note

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