--- license: mit task_categories: - text-generation language: - en tags: - mathematics - group-theory - permutations - symbolic-reasoning - algebra - sequence-modeling - state-space-models - computational-complexity pretty_name: Group Theory Collection size_categories: - 10M 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: ```python # 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) ```python 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. ```python # 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): ```json { "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// 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="")` 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`: ```python 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](https://github.com/BeeGass/Group-Dataset-Generator) 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 ```bibtex @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](https://github.com/BeeGass/Group-Dataset-Generator).