BeeGass/Group-Theory-Collection

Group Theory Collection

A benchmark of 11.28 million permutation-composition problems over 94 finite groups, split by computational complexity class (TC⁰ vs NC¹).

Given a sequence of group elements, the task is to predict their composition. By Barrington's theorem, iterated composition in any fixed non-solvable group is NC¹-complete, while for solvable groups it lies in ACC⁰ ⊆ TC⁰. Architectures whose expressive power is bounded by TC⁰ — fixed-depth transformers and linear state-space models under standard assumptions — are therefore predicted to fail at length on the 22 non-solvable groups while succeeding on the 72 solvable ones. This dataset operationalizes that prediction as a controlled benchmark: same task, same format, same length distribution, with the group's complexity class as the independent variable.

• Generator, verifier, and docs: BeeGass/Group-Dataset-Generator
• Motivating theory: Merrill, Petty & Sabharwal, The Illusion of State in State-Space Models; Barrington, Bounded-width polynomial-size branching programs recognize exactly those languages in NC¹

At a glance
Task	composition (word problem): sequence of group elements → their product
Configs	94 permutation groups across 10 families
Rows	11,280,000 (per config: 100,000 train / 20,000 test)
Complexity split	72 solvable (TC⁰) / 22 non-solvable (NC¹-complete)
Sequence lengths	uniform on [3, 1024], all lengths present in every split
Format	Apache Arrow (datasets save_to_disk layout) + one metadata.json per config
Size	≈ 17 GB
Version	v2 (2026-08, deterministic regeneration); v1 frozen at revision 878908af
License	MIT

Quick start

import json
import numpy as np
from datasets import load_dataset
from huggingface_hub import hf_hub_download

GROUP = "s5"  # any of the 94 config names below

ds = load_dataset("BeeGass/Group-Theory-Collection", name=GROUP, split="test")

# Rows carry element INDICES. The index -> permutation table lives in the
# config's metadata.json (load_dataset does not fetch it for you):
meta = json.load(open(hf_hub_download(
    "BeeGass/Group-Theory-Collection", f"data/{GROUP}/metadata.json", repo_type="dataset"
)))
perms = {int(k): np.array(v) for k, v in meta["permutation_map"].items()}

# Recompute a target to see the convention in action:
row = ds[0]
result = np.arange(meta["group_degree"])
for i in row["input_sequence"].split():
    result = result[perms[int(i)]]
assert np.array_equal(result, perms[int(row["target"])])

# Filter configs by complexity class via metadata:
assert meta["complexity_class"] in ("tc0", "nc1")

Streaming, other access routes, and length filtering:

# Stream without downloading the full split
ds = load_dataset("BeeGass/Group-Theory-Collection", name="m12", split="train", streaming=True)

# Equivalent path-based loading
ds = load_dataset("BeeGass/Group-Theory-Collection", data_dir="data/s5")

# Pin a revision for exact reproducibility:
#   v2 data release: 2f336519055a1117ddb852a112d815b75a27e61e
#   v1 (frozen):     878908af8299019d3fe0a2cc180af576e011f465
ds = load_dataset(
    "BeeGass/Group-Theory-Collection", name="s5",
    revision="2f336519055a1117ddb852a112d815b75a27e61e",
)

# Length curriculum / analysis
short = ds["train"].filter(lambda x: x["sequence_length"] <= 32)

Worked examples

The dataset supports two consumption modes, and the generator repo's API covers both: train from scratch on the published index rows, or benchmark a pretrained LLM on rendered prompts whose answers score against these same targets. Both examples below were run as-is; the quoted numbers are their real output.

Train from scratch: state tracking with dense supervision

The composition task is a running-state problem, so supervise the running product at every prefix, not just the final target — permutation_map lets you compute every prefix label locally. (With final-target supervision alone, small models tend to memorize rows instead of learning the group: an identical setup trained this way sat at chance on held-out rows.)

Full training script (PyTorch; runs on CPU in ~10 minutes)

import json
import numpy as np
import torch
import torch.nn as nn
from datasets import load_dataset
from huggingface_hub import hf_hub_download

GROUP, MAX_LEN = "c10", 64          # train short, evaluate longer
ds = load_dataset("BeeGass/Group-Theory-Collection", name=GROUP)
meta = json.load(open(hf_hub_download(
    "BeeGass/Group-Theory-Collection", f"data/{GROUP}/metadata.json", repo_type="dataset"
)))
order, degree = meta["group_order"], meta["group_degree"]
perms = {int(k): np.array(v) for k, v in meta["permutation_map"].items()}
index_of = {tuple(perms[i]): i for i in range(order)}
PAD, IGNORE = order, -100

def encode(row):
    """labels[t] = index of p_1 . ... . p_(t+1); labels[-1] == int(row["target"])."""
    ids = [int(t) for t in row["input_sequence"].split()]
    state, labels = np.arange(degree), []
    for i in ids:
        state = state[perms[i]]                  # same fold as the decode recipe above
        labels.append(index_of[tuple(state)])
    return {"ids": ids, "labels": labels}

train = ds["train"].filter(lambda r: r["sequence_length"] <= MAX_LEN).map(encode)

def collate(batch):
    width = max(len(r["ids"]) for r in batch)
    x = torch.full((len(batch), width), PAD, dtype=torch.long)
    y = torch.full((len(batch), width), IGNORE, dtype=torch.long)
    for i, r in enumerate(batch):
        x[i, : len(r["ids"])] = torch.tensor(r["ids"])
        y[i, : len(r["labels"])] = torch.tensor(r["labels"])
    return x, y

loader = torch.utils.data.DataLoader(train, batch_size=128, shuffle=True, collate_fn=collate)

class Composer(nn.Module):
    """Recurrent baseline: an RNN can carry the running product in its state.

    Swap this module for your transformer or SSM to probe the TC0/NC1
    boundary — fixed-depth parallel architectures are the ones predicted to
    fail at length where this recurrent baseline succeeds.
    """

    def __init__(self, order, d=128):
        super().__init__()
        self.emb = nn.Embedding(order + 1, d)    # + PAD
        self.rnn = nn.LSTM(d, d, batch_first=True)
        self.head = nn.Linear(d, order)

    def forward(self, x):
        hidden, _ = self.rnn(self.emb(x))
        return self.head(hidden)

model = Composer(order)
opt = torch.optim.AdamW(model.parameters(), lr=1e-3)
for epoch in range(30):
    for x, y in loader:
        logits = model(x)
        loss = nn.functional.cross_entropy(logits.flatten(0, 1), y.flatten(), ignore_index=IGNORE)
        opt.zero_grad(); loss.backward(); opt.step()

@torch.no_grad()
def final_accuracy(rows):
    hits = total = 0
    for x, y in torch.utils.data.DataLoader(rows, batch_size=256, collate_fn=collate):
        last = (x != PAD).sum(1) - 1
        idx = torch.arange(len(x))
        pred = model(x).argmax(-1)[idx, last]
        hits += (pred == y[idx, last]).sum().item(); total += len(x)
    return hits / total

test = ds["test"].map(encode)
in_dist = test.filter(lambda r: r["sequence_length"] <= MAX_LEN)
longer = test.filter(lambda r: MAX_LEN < r["sequence_length"] <= 4 * MAX_LEN)
print(f"len<={MAX_LEN}: {final_accuracy(in_dist):.3f} | len {MAX_LEN+1}-{4*MAX_LEN}: {final_accuracy(longer):.3f}")

Measured output of that script, run verbatim (CPU, ~10 min; training loss falls from 2.30, chance level, to below 0.01):

len<=64: 1.000 | len 65-256: 0.999

The LSTM baseline learns the group and generalizes to 4× its training length, because a recurrent state can implement the group's multiplication directly. The experiment this benchmark exists for: replace Composer with a fixed-depth transformer or SSM, sweep GROUP across the TC⁰/NC¹ boundary (say c10, d10, s5, a5, m11), and compare accuracy-versus-length curves per class.

Benchmark a pretrained LLM: rendered prompts via the generator API

The generator package renders these exact composition tasks as natural-language prompts (cycle or one-line notation), parses free-form completions back to element indices, and scores them against the same targets. Task files are self-describing JSONL (each carries its own element table), and gdg verify recomputes every target and answer before you spend model calls on a file.

# pip install git+https://github.com/BeeGass/Group-Dataset-Generator
from gdg.bench import registry
from gdg.bench.generate import generate_tasks
from gdg.bench.render import get_renderer

spec = registry.get("s5")
manifest, tasks = generate_tasks(spec, lengths=(4, 16, 64), n=50, seed=0, renderer_name="cycle")
renderer = get_renderer(manifest.renderer)

correct = 0
for task in tasks:
    completion = my_llm(task.prompt)             # your model call goes here
    predicted = renderer.parse_answer(completion, spec, manifest.elements)
    correct += predicted == task.target          # None (unparseable) scores wrong
print(f"accuracy: {correct / len(tasks):.3f}")

A rendered cycle prompt looks like:

Compute the product (0 4 3 2) . (0 1)(2 3) . (0 2)(1 3) . (0 3)(2 4) in the group S5, a permutation group on 5 points labelled 0 to 4. Compose so that the rightmost factor acts on a point first. Answer in cycle notation.

with reference answer (0 4 1)(2 3). parse_answer accepts any valid spelling of the same permutation (cycle notation is not unique), returns an element index rather than a string, and returns None on junk instead of raising, so one garbled completion cannot abort a sweep. Sanity-checked as-is: an oracle that replays each task's reference answer scores 1.000; a model that answers "banana" scores 0.000.

The same harness works offline from files: gdg generate --group s5 --lengths 4,16,64 --n 50 --renderer cycle --out s5.jsonl writes the tasks (prompts, answers, and the element table) as JSONL, gdg verify s5.jsonl proves the file self-consistent, and three renderers ship (cycle, inline one-line arrays, index raw indices — the published corpus format).

Dataset structure

Data instances

One real row from s5 (test split):

{
  "input_sequence": "43 13 115",
  "target": "7",
  "sequence_length": 3,
  "group_degree": 5,
  "group_order": 120,
  "group_type": "symmetric"
}

Read: elements 43, 13, 115 of S₅ compose to element 7 (indices into permutation_map). Typical rows are much longer — lengths are uniform on [3, 1024].

Data fields

field	type	description
input_sequence	string	Space-separated element indices, in composition order (see convention below)
target	string	Index of the composed element. A string, not an int, because it keys permutation_map, whose JSON keys are strings
sequence_length	int64	Number of indices in input_sequence; uniform on [3, 1024] inclusive
group_degree	int64	Number of points the group acts on (constant per config)
group_order	int64	Number of elements in the group (constant per config)
group_type	string	Family name, e.g. "symmetric", "psl", "mathieu" (constant per config)

Each config directory additionally ships a metadata.json with: permutation_map (index → permutation in one-line notation — the decoder ring for the row fields), group_name, group_type, group_parameters, group_order, group_degree, solvable, complexity_class ("tc0" or "nc1"), num_train_samples, num_test_samples, min_seq_length, max_seq_length, the composition convention in prose, the master seed, and the producing gdg_version.

Data splits

Every one of the 94 configs has the same split sizes:

split	rows per config	total rows
train	100,000	9,400,000
test	20,000	1,880,000

Train and test are drawn from disjoint deterministic RNG streams (no leakage by construction). Rows are i.i.d. samples; there is no length stratification between splits, and both splits cover every length in [3, 1024].

Repository layout

data/<config>/
  metadata.json                      # permutation_map + group facts + provenance
  dataset_dict.json
  train/ data-00000-of-00001.arrow   # + dataset_info.json, state.json
  test/  data-00000-of-00001.arrow   # + dataset_info.json, state.json

All 94 configs are declared in this card's YAML, so load_dataset(..., name="<config>") works out of the box. Class membership is machine-readable from each config's complexity_class metadata field and enumerated in the inventory tables below.

Composition convention

For an input sequence [p₁, p₂, p₃] the target is:

• Mathematical notation: p₁ ∘ p₂ ∘ p₃
• Operational reading: result(x) = p₁(p₂(p₃(x))) — the last element listed acts on the point first

Permutations are stored in one-line notation, so p[i] is the image of i:

result = np.arange(degree)
for i in input_sequence.split():
    result = result[permutation_map[i]]

Worked example in S₃ with a = [1,2,0] = (0 1 2) and b = [1,0,2] = (0 1):

sequence	result	cycle notation
[a, b]	[2,1,0]	(0 2)
[b, a]	[0,2,1]	(1 2)

These differ, so the example distinguishes this convention from its reverse. Checking the first: b(0) = 1, then a(1) = 2, giving result(0) = 2.

Correction. Revisions of this card before 2026-08-07 described the opposite order, in both the composition formula and its operational gloss ("First apply p₁"). That was wrong. The data was always correct and is unchanged; only the description was wrong. Recomputing 300 test rows per group confirms the convention above matches 300/300 for s5, a5 and m11, while the old wording matched 3, 6 and 0 respectively.

Group inventory

Correction. Earlier revisions of this card headlined a 58 / 36 split. The correct split is 72 / 22, which is what the enumerated tables below have always shown.

TC⁰ configs (solvable) — 72

family	configs	orders	notes
Symmetric	S3, S4	6, 24	solvable for n ≤ 4
Alternating	A3, A4	3, 12	solvable for n ≤ 4
Cyclic	C2–C30 (all 29)	2–30	abelian
Dihedral	D3–D20 (all 18)	6–40	symmetries of regular polygons
Klein	V4	4	≅ Z₂², smallest non-cyclic abelian group
Quaternion	Q8, Q16, Q32	8, 16, 32	non-abelian 2-groups; correct in v2 — in v1 all three were dihedral, see Erratum below
Elementary abelian	Z2^k (k≤5), Z3^k (k≤4), Z5^k (k≤4)	2–625	regular representations
Frobenius	F20, F21	20, 21	C5⋊C4 and C7⋊C3, natural Frobenius actions
PSL	PSL(2,2), PSL(2,3)	6, 12	the two solvable PSLs (≅ S3, A4)

NC¹ configs (non-solvable) — 22

family	configs	orders	notes
Symmetric	S5–S9	120–362,880	non-solvable for n ≥ 5
Alternating	A5–A9	60–181,440	simple for n ≥ 5
PSL	PSL(2,q) for q ∈ {4,5,7,8,9,11}; PSL(3,q) for q ∈ {2,3,4,5}	60–372,000	simple (PSL(2,4) ≅ A5, PSL(3,2) ≅ PSL(2,7))
Mathieu	M11, M12	7,920, 95,040	sporadic simple; sharply 4-/5-transitive

Every solvability label was verified computationally (derived series for all 94 groups), and every group's isomorphism type was pinned by discriminating invariants during the 2026-08 audit — including the sharp transitivity of the Mathieu groups and the element-order spectra separating PSL(3,4) from A₈ and the quaternion groups from dihedral ones.

Benchmarking guidance

• The independent variable is complexity_class. Hold the renderer, length distribution and training protocol fixed; compare accuracy-vs-length curves between TC⁰ and NC¹ configs.
• Degree-matched comparisons. Rendered prompt width scales with group_degree. Degrees 5–13 and 21 have both solvable and non-solvable configs (e.g. degree 5: C5, D5, F20, Z5 vs A5, PSL(2,4), S5), letting you hold width fixed across the class boundary.
• Dedupe before averaging per class. Several configs realise the same group (next section). In particular psl3_2 ≡ psl2_7 (identical tables) and a5 ≡ psl2_4 (same subgroup of Sym(5)) each appear twice within a single degree cohort.
• Duplicates within tiny configs are expected. A group of order 2 has only 2^L length-L words, so exact-duplicate rows in configs like c2 are a birthday certainty at short lengths, not a data defect.
• Length generalization. All lengths 3–1024 are present in both splits, so you can train short / test long entirely within the published data.

Isomorphic duplicates

Some configs name the same group twice. psl3_2 and psl2_7 are the same permutation group with the same element indexing (PSL(3,2) is constructed by delegation to PSL(2,7)); a5 and psl2_4 are the same subgroup of Sym(5) with different element indexings; a3/c3/z3_1, a4/psl2_3, d3/s3/psl2_2, v4/z2_2, c2/z2_1 and c5/z5_1 likewise coincide. Abstractly (with different actions), PSL(2,4) = PSL(2,5) = A5 and PSL(2,9) = A6, so the 22 non-solvable configs realise 18 distinct abstract groups. Distinct actions are distinct datapoints by design — prompt width and index space differ — but any per-class average or degree-matched comparison should dedupe these clusters rather than weight a group by how many names it carries. The full machine-readable map ships in the generator repo as gdg.bench.registry.SAME_PERMUTATION_GROUP and ISOMORPHISM_CLASSES.

Dataset creation

Rows are generated, not collected. For each row, an RNG is derived from (schema, split, config, row_index, master_seed) via BLAKE2b → PCG64, the sequence length is drawn uniformly from [3, 1024], element indices are drawn uniformly from the group, and the target is computed by one shared composition routine. Every row is therefore independently regenerable, and the corpus is bit-reproducible from the generator at seed = 0 (gdg 0.2.0).

Verification before release: all 94 element tables were regenerated and checked against v1 element-for-element (87 identical; exactly the 7 repaired configs changed); group axioms, solvability (derived series), and isomorphism-type invariants were verified computationally for every group; targets were recomputed from the shipped permutation_map for sampled rows of every family under the documented convention; sequence-length marginals were confirmed uniform on [3, 1024] in all 188 splits; and the generator's full test suite (924 tests, including Hub-backed validation of this artifact) passes.

Leaderboard

Open-weight models evaluated on freshly generated composition tasks from this dataset's groups (spanning both complexity classes), scored end to end by the generator repository's runner: local llama.cpp inference, temperature 0, a 4,096-token reasoning budget, and identical tasks for every model (seed 0). Full protocol, per-task receipts and submission instructions live in the generator repository under docs/LEADERBOARD.md.

#	Model	Quant.	Score	TC0	NC1	L50 TC0	L50 NC1	Unparsed	Truncated
1	gpt-oss-20b	MXFP4	0.390	0.355	0.413	4	8	101	258
2	Qwen3-4B-Instruct-2507	Q8_0	0.318	0.340	0.303	4	4	88	324
3	Qwen3.6-35B-A3B	UD-Q4_K_XL	0.132	0.185	0.097	0	2	101	487
4	Qwen3.6-27B	UD-Q4_K_XL	0.080	0.120	0.053	0	0	102	500
5	LFM2.5-2.6B	Q8_0	0.078	0.115	0.053	0	2	210	391
6	Llama-3.1-8B-Instruct	Q6_K	0.020	0.030	0.013	0	0	274	253

Score is the macro-average over 25 (group, sequence-length) cells; L50 is the largest tested length still reaching 0.5 accuracy for that class; Truncated counts completions that exhausted the token budget.

Exact scores per model, group and sequence length

Accuracy over 20 tasks per cell.

gpt-oss-20b — score 0.390 (TC0 0.355, NC1 0.413); 258/500 truncated at the 4,096-token budget

group (class)	len 2	len 4	len 8	len 16	len 32
c10 (TC0)	0.75	0.75	0.30	0.10	0.05
d10 (TC0)	0.80	0.50	0.25	0.00	0.05
psl2_9 (NC1)	0.90	0.75	0.30	0.00	0.00
s5 (NC1)	1.00	0.75	0.70	0.20	0.00
m11 (NC1)	0.85	0.45	0.30	0.00	0.00

Qwen3-4B-Instruct-2507 — score 0.318 (TC0 0.340, NC1 0.303); 324/500 truncated at the 4,096-token budget

group (class)	len 2	len 4	len 8	len 16	len 32
c10 (TC0)	0.90	0.60	0.10	0.10	0.00
d10 (TC0)	0.90	0.70	0.00	0.00	0.10
psl2_9 (NC1)	0.70	0.70	0.00	0.00	0.00
s5 (NC1)	1.00	0.95	0.15	0.10	0.00
m11 (NC1)	0.75	0.20	0.00	0.00	0.00

Qwen3.6-35B-A3B — score 0.132 (TC0 0.185, NC1 0.097); 487/500 truncated at the 4,096-token budget

group (class)	len 2	len 4	len 8	len 16	len 32
c10 (TC0)	0.30	0.35	0.10	0.10	0.10
d10 (TC0)	0.45	0.25	0.05	0.00	0.15
psl2_9 (NC1)	0.15	0.00	0.00	0.00	0.00
s5 (NC1)	0.75	0.20	0.10	0.00	0.00
m11 (NC1)	0.25	0.00	0.00	0.00	0.00

Qwen3.6-27B — score 0.080 (TC0 0.120, NC1 0.053); 500/500 truncated at the 4,096-token budget

group (class)	len 2	len 4	len 8	len 16	len 32
c10 (TC0)	0.30	0.20	0.05	0.10	0.15
d10 (TC0)	0.25	0.05	0.05	0.05	0.00
psl2_9 (NC1)	0.00	0.00	0.10	0.00	0.00
s5 (NC1)	0.25	0.10	0.10	0.05	0.00
m11 (NC1)	0.05	0.15	0.00	0.00	0.00

LFM2.5-2.6B — score 0.078 (TC0 0.115, NC1 0.053); 391/500 truncated at the 4,096-token budget

group (class)	len 2	len 4	len 8	len 16	len 32
c10 (TC0)	0.25	0.15	0.10	0.10	0.10
d10 (TC0)	0.30	0.05	0.05	0.05	0.00
psl2_9 (NC1)	0.05	0.00	0.05	0.00	0.00
s5 (NC1)	0.50	0.10	0.00	0.00	0.00
m11 (NC1)	0.10	0.00	0.00	0.00	0.00

Llama-3.1-8B-Instruct — score 0.020 (TC0 0.030, NC1 0.013); 253/500 truncated at the 4,096-token budget

group (class)	len 2	len 4	len 8	len 16	len 32
c10 (TC0)	0.10	0.05	0.00	0.05	0.10
d10 (TC0)	0.00	0.00	0.00	0.00	0.00
psl2_9 (NC1)	0.05	0.00	0.00	0.05	0.00
s5 (NC1)	0.00	0.00	0.00	0.10	0.00
m11 (NC1)	0.00	0.00	0.00	0.00	0.00

Versions

• v2 (current). All 94 configs regenerated with per-item deterministic sampling (gdg export-hf, master seed 0). Corrects the seven defective v1 configs (psl2_4, psl2_8, psl2_9, psl3_4, q8, q16, q32); the other 87 configs keep their v1 element indexing exactly, with freshly sampled rows. Adds complexity_class and provenance fields to metadata.json, and removes the duplicated TC0/ and NC1/ trees.
• v1 (frozen). The July 2025 upload, pinned at Hub revision 878908af. Cite it by that revision; it is not bit-reproducible from source (its generator used a global RNG seed), and its seven defective configs are documented in the errata below.

Layout change in v2. v1 shipped TC0/ and NC1/ directory trees that duplicated data/ byte-for-byte (16.99 GB); v1's card marked them as slated for removal, and v2 removed them. Since their removal, load_dataset(..., data_dir="TC0/...") and data_dir="NC1/..." stop working; load_dataset(name=...) and data_dir="data/..." are unaffected. Use the complexity_class metadata field instead.

Known issues and errata

Erratum: four PSL configs were defective in v1

In v1 (Hub revision 878908af), psl2_4, psl2_8, psl2_9 and psl3_4 did not contain the group their name claims; v2 rebuilds all four correctly. The v1 generator built these groups from elementary matrices with prime-field coefficients, which over GF(p^n) with n > 1 generate only a proper subgroup.

config	should be	v1 actually contained
psl2_4	PSL(2,4), order 60	a solvable group of order 10 (D5)
psl2_8	PSL(2,8), order 504	a solvable group of order 18 (D9)
psl2_9	PSL(2,9), order 360	A5, order 60
psl3_4	PSL(3,4), order 20160	PSL(2,7), order 168, acting intransitively

If you ran a TC⁰-versus-NC¹ comparison on v1, exclude these four and re-run on v2. Two of them were solvable groups labelled non-solvable, and psl2_4 acts on 5 points, so it falls in the degree-matched cohort against S5 and A5. The other two were non-solvable but duplicated a5 and psl2_7, adding no new information.

All PSL configs with prime q — psl2_2, psl2_3, psl2_5, psl2_7, psl2_11, psl3_2, psl3_3, psl3_5 — were never affected, and their element indexing is unchanged between v1 and v2.

Erratum: three quaternion configs were dihedral in v1

In v1 (Hub revision 878908af), q8, q16 and q32 did not contain generalized quaternion groups; v2 rebuilds all three correctly. The v1 generator dropped the b² = a^(2^(k-2)) relation — every a^i b element it built squared to the identity — so the enumerated group satisfied the dihedral presentation instead:

config	should be	v1 actually contained
q8	Q8, order 8 — exactly one involution	D4, order 8 — five involutions, regular representation
q16	Q16, order 16 — exactly one involution	D8, order 16 — nine involutions, regular representation
q32	Q32, order 32 — exactly one involution	D16, order 32 — seventeen involutions, regular representation

v1's orders, degrees and targets were internally consistent, and dihedral 2-groups are solvable, so the TC⁰ placement still held — but every "quaternion" conclusion drawn from v1 is really about dihedral groups, which in v1 duplicated d4, d8 and d16 abstractly. You can verify from the v1 data alone: count the elements p of q8's v1 permutation_map with p[p] = identity — five involutions, where a generalized quaternion group has exactly one. The v2 tables do.

In total 87 of the 94 v1 configs were correct as labelled; v2 corrects all seven, so every v1 target for those seven is void, and the other 87 configs keep their v1 element indexing exactly.

Limitations

• Synthetic and exhaustive by construction. Rows are i.i.d. uniform draws; there is no natural-language noise, distribution shift, or annotation ambiguity. This is by design (the benchmark isolates a single computational property) but means results do not speak to natural-data robustness.
• Index-based format. The published rows use element indices, suited to training from scratch. Prompting a pretrained LLM requires rendering elements concretely (e.g. cycle notation); the generator repo ships three reference renderers and a verifier so rendered prompts stay consistent with these targets.
• Duplicate abstract groups. See Isomorphic duplicates: naive per-class averages overweight A5, A6 and PSL(2,7).
• Class labels are per group, not per row. Short sequences over a non-solvable group are still easy; the NC¹-hardness prediction concerns length scaling, not individual rows.

Citation

@dataset{gass2026grouptheorycollection,
  author    = {Gass, Bryan},
  title     = {Group Theory Collection: permutation composition over 94 finite
               groups, split by {TC}$^0$/{NC}$^1$ complexity},
  year      = {2026},
  version   = {2.0},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/BeeGass/Group-Theory-Collection}
}

@software{gass2026gdg,
  author = {Gass, Bryan},
  title  = {Group Dataset Generator},
  year   = {2026},
  url    = {https://github.com/BeeGass/Group-Dataset-Generator}
}

@inproceedings{merrill2024illusion,
  title     = {The Illusion of State in State-Space Models},
  author    = {Merrill, William and Petty, Jackson and Sabharwal, Ashish},
  booktitle = {Proceedings of the 41st International Conference on Machine Learning},
  year      = {2024},
  note      = {arXiv:2404.08819}
}

@article{barrington1989bounded,
  title   = {Bounded-width polynomial-size branching programs recognize exactly
             those languages in {NC}$^1$},
  author  = {Barrington, David A.},
  journal = {Journal of Computer and System Sciences},
  volume  = {38},
  number  = {1},
  pages   = {150--164},
  year    = {1989}
}

License

MIT.

Contact

Questions, issues, or contributions: open a discussion on this dataset repository or an issue on the generator repo.