The IGP24 Stage 1 Dataset brings together polynomial submissions contributed by participating teams during Stage 1 of the Inverse Galois Problem (IGP24) competition. It reflects the collective mathematical and computational efforts of the competition community, compiled and released by SAIR Foundation. Version v1, 2026.

IGP24 asked participants to construct irreducible integer polynomials of degree 24 realizing transitive Galois groups and their possible signatures. Each verified polynomial is identified by its competition signature (t, r): t identifies the group 24Tt, and r is the number of real roots.

The sharded collection contains all polynomial records meeting the export criteria, including multiple records for the same pair and team. A separate minimal collection contains one selected record per included (label, r) pair.

The repository also includes scoring data and a replay script that reproduce the official leaderboard snapshot's scores and ranks. These numerical inputs complement the polynomial collections without changing their records or schema.

This dataset is licensed under the Creative Commons Attribution-ShareAlike 4.0 International license (CC BY-SA 4.0). See License.

Dataset at a Glance

Item	Value
Eligible polynomial records in the sharded export	50,428,828
Records with `scoring_disc_type = exact_nfdisc`	49,827,337
Records with `scoring_disc_type = mixed_disc`	601,491
JSONL shards	51
Combined shard size	27,374,719,262 bytes, approximately 27.37 GB
Records in the one-record-per-pair collection	163,910
Pairs in the export's reference universe	165,836
Pairs absent from the one-record-per-pair collection	1,926
Export window, start inclusive	June 15, 2026, 10:00:00 UTC
Export window, end exclusive	August 16, 2026, 12:00:00 UTC

Counts and export boundaries are recorded in records-export.json and minimal-summary.json. The source snapshot is igp24-record-export-20260821T131447Z: the export uses that snapshot's recorded computation results, not necessarily the results already available at the submission deadline.

Repository Layout

README.md
LICENSE
SHA256SUMS
data/
    minimal_records.jsonl
    missing_pairs.jsonl
    records/
        part-00001.jsonl
        ...
        part-00051.jsonl
    scoring/
        scoring_inputs.jsonl.gz
        baseline.jsonl
        teams.json
        official_leaderboard.json
        reference_pair_scores.jsonl.gz
        reference_leaderboard.json
        export_report.json
        provenance.json
        lmfdb_baseline.csv
        valid_pairs.csv
scripts/
    reproduce_leaderboard.py
    test_replay.py
docs/
    leaderboard-reproduction.md
reports/
    records-export.json
    minimal-summary.json
    independent-audit.json
    leaderboard-validation.md
    leaderboard-validation.json

The dataset card explicitly maps the minimal and records configurations to their polynomial files. Scoring inputs, missing-pair classifications, and audit reports have different schemas and are not mixed into either configuration. scripts/ contains optional standalone tools, not a custom Hugging Face dataset loader.

Sharded Records

data/records/part-00001.jsonl through data/records/part-00051.jsonl contain all 50,428,828 records eligible under this export's filters. The first 50 shards each contain 1,000,000 records; the last contains 428,828. Records are emitted in ascending primary-store sequence, according to the export report. This is not a documented score ranking or guaranteed chronological ordering.

Each line is one polynomial record, not an entire batch submission. The same pair and team can appear repeatedly, and different record IDs can contain identical coefficients. Do not treat row counts as counts of unique polynomials, batch submissions, or newly discovered pairs.

One Record per Pair

minimal_records.jsonl contains 163,910 selected records, one for each included (label, r) pair, using the same schema as the shards. It is approximately 76.9 MB and is the smaller starting point for exploring pair coverage.

The minimal collection is derived by grouping the complete sharded export by (label, r) and retaining one record with the smallest scoring_disc_abs in each group. Values are compared numerically, not as text, regardless of whether their type is exact_nfdisc or mixed_disc. A mixed-discriminant record can therefore be selected even when exact-discriminant records exist for the same pair. Equal minimum values retain one record; exact records are not guaranteed preference over mixed records in a tie.

Minimal refers to the smallest exported discriminant value per pair, not necessarily the smallest exact number-field discriminant. Exact computations are not available for every record, and a mixed discriminant is not necessarily the exact discriminant of its number field. This selection rule does not rerun those computations or claim a minimum over number fields outside the exported collection. The retained team_number identifies the team for that record, not every team that found the pair.

The minimal collection contains 163,769 exact records and 141 mixed records. For example, it retains a 915-digit mixed value for (24T24992, 20), while an exact record for a different polynomial at that pair has a 1,942-digit value. For (24T24993, 16), the retained mixed value has 481 digits and an exact candidate has 874 digits. These examples compare different polynomials; they do not claim that a mixed value is smaller than the exact discriminant of the same polynomial.

The minimal and records dataset configurations separate these two collections. Each has a single split named train; this is a file-loading label, not a train/test partition. The minimal collection is derived from the sharded collection, so the two are not independent datasets.

Missing Pairs

missing_pairs.jsonl has a separate schema: label, t, r, and status. It lists the 1,926 reference pairs absent from the minimal collection:

1,880 are classified as unsolved.
46 are classified as matched_baseline.

These are classifications in the supplied export, not claims about mathematical impossibility or future discoveries. Absent from this export does not necessarily mean undiscovered: the 46 matched_baseline entries must not be counted as unsolved. The reference-universe accounting is 163,910 + 1,926 = 165,836.

Export Scope and Filtering

The export report starts from 53,138,006 primary-store rows and records these exclusions:

Exclusion counter	Records
Before the start of the export window	18,252
Verification status not `ok`	215,514
Discriminant status not `ok`	8,492
LMFDB baseline pair without an exact discriminant source	187,957
LMFDB baseline pair without a strict baseline improvement	2,278,963

All other exclusion counters in the report are zero, including rows at or after the cutoff, invalid pairs, unavailable selected discriminants, and discriminants at most one. The report's exclusion counts plus the 50,428,828 emitted records sum to the 53,138,006 source rows.

In particular, a baseline pair must have a successfully computed exact number-field discriminant strictly below the frozen LMFDB baseline to be included. Non-baseline records can use exact or mixed discriminants. Inclusion does not establish that every retained row independently added points to a team's final score.

Record Schema

The shards and minimal_records.jsonl use JSON Lines: one JSON object per line, with these seven fields.

Field	JSON type	Meaning
`id`	String	Polynomial record ID, not a batch submission ID.
`label`	String	Degree-24 transitive Galois group label, such as `24T4`.
`r`	Integer	Number of real roots. It is even and lies between 0 and 24; possible values depend on the group. Together with `label`, it identifies the pair.
`team_number`	String	Competition team associated with this record, such as `IGP24-T00027`. Team names and member identities are not included in these rows.
`coefficients`	Array of strings	Exactly 25 decimal integer strings in ascending powers: `a_0, a_1, ..., a_24`. The constant term comes first; `a_0` is nonzero and `a_24` is `"1"`.
`scoring_disc_type`	String	Type of the discriminant exported for this record: `exact_nfdisc` or `mixed_disc`.
`scoring_disc_abs`	String	Absolute discriminant value corresponding to this record's `scoring_disc_type`, encoded as a decimal integer string.

The polynomial is a_0 + a_1*x + ... + a_24*x^24. Keep coefficient and discriminant strings intact when loading the data. Floating-point conversion can permanently lose precision; some decimal discriminants also exceed default integer-string conversion limits in recent Python versions.

The seven-field polynomial records do not include computed_label, computed_r, verification status, submission timestamps, comments, prime hints, points, or separate polynomial/exact/mixed discriminant columns. These are not additional columns in the polynomial files. The separately documented scoring data supplies timestamps, batch ordering, both exact and mixed discriminants, and other scoring inputs for its reduced candidate set. It does not add these fields to every polynomial record. The status field in missing_pairs.jsonl has a different purpose and must not be joined as a verification result for polynomial records.

User-Provided Submission Notes

Participants could attach one free-text note to a batch containing multiple polynomials. These notes may contain source attribution or ordinary comments; a non-empty note is not by itself evidence that the polynomials came from an external source. The notes are user-provided statements, not organizer-verified provenance.

A separate note export is planned to preserve the original text and link each batch to its polynomial record IDs, without rewriting or classifying the notes. That export is not included in this revision. The file data/scoring/provenance.json describes the scoring export's source snapshot and implementation, not participants' submission notes.

Example Record

This is the first record in minimal_records.jsonl, formatted across multiple lines here for readability. In the file, each object occupies one line.

{
  "id": "igp24_sub_d3e6c5a7d67c45c9",
  "label": "24T4",
  "r": 0,
  "team_number": "IGP24-T00027",
  "coefficients": [
    "1640311",
    "-1171523",
    "334441",
    "-5366655",
    "7995595",
    "-7598977",
    "4194661",
    "-1317710",
    "1452287",
    "-88672",
    "506411",
    "74076",
    "117119",
    "1956",
    "108008",
    "-54870",
    "52354",
    "-19718",
    "10110",
    "-2504",
    "899",
    "-126",
    "39",
    "-2",
    "1"
  ],
  "scoring_disc_type": "exact_nfdisc",
  "scoring_disc_abs": "5778292780092292736147826999664306640625"
}

Verification and Discriminants

The competition's Magma verifier checks irreducibility and degree, then identifies the Galois group and the number of real roots. PARI/GP computes discriminants separately. The Evaluation Setup describes the protocol and reference programs.

exact_nfdisc: the absolute number-field discriminant from a successful exact computation.
mixed_disc: a discriminant value from the competition's mixed-discriminant procedure. It is not necessarily an exact number-field discriminant.

The exported type describes the value in that individual row. It is distinct from the pair-level source used in competition scoring. For a non-baseline pair, a scoring candidate that triggers mixed fallback can cause the pair to use mixed discriminants even when other candidates have successful exact computations.

Despite its name, scoring_disc_abs is not guaranteed to equal the value used for that record in final leaderboard scoring. A row may export an exact value while its pair is scored using mixed values; that row's mixed value is not included in the seven-field polynomial record. The polynomial files alone therefore do not contain all the information needed to reproduce the final leaderboard. The scoring data and replay script supply the additional inputs. An unavailable exact discriminant must not be interpreted as zero.

The frozen LMFDB baseline CSV is supplied separately for reference. Its applicable terms remain separate from those of this release.

Reading the Files

Start with the minimal configuration rather than downloading all 27.37 GB of shards. Both configurations support Hugging Face load_dataset; streaming reads records without downloading the whole collection first. Coefficients and discriminants remain strings.

python3 -m pip install datasets huggingface_hub

from datasets import load_dataset
from huggingface_hub import HfApi

repo_id = "SAIRfoundation/IGP24-stage1"
revision = HfApi().dataset_info(repo_id, revision="docs/dataset-layout").sha
records = load_dataset(
    repo_id, "minimal", split="train", streaming=True,
    revision=revision, token=True,
)
print("Repository revision:", revision)
record = next(iter(records))
print(record["label"], record["r"], record["team_number"])
print(record["scoring_disc_type"], record["scoring_disc_abs"])

Change "minimal" to "records" to stream the complete sharded collection. Authenticate with hf auth login using an account authorized to access the dataset. The examples currently select the docs/dataset-layout review branch, not the published main branch. Once approved and merged, main can be used instead. Save the printed commit hash and use that fixed hash as revision when repeating an analysis; resolving a branch again later may select a newer version.

To download a raw file for Python's standard JSON parser, use hf_hub_download with repo_type="dataset" and a path such as data/minimal_records.jsonl or data/records/part-00001.jsonl. Process JSONL records line by line. Do not convert large integer strings to floating-point numbers.

The configuration names and data payloads are preserved across this layout change. The new layout relocates direct file paths; older commit-pinned downloads still use the paths present at those older revisions.

Reproducing the Leaderboard

Download only the scoring data and tools; the 27.37 GB of polynomial shards are not required:

from huggingface_hub import HfApi, snapshot_download

repo_id = "SAIRfoundation/IGP24-stage1"
revision = HfApi().dataset_info(repo_id, revision="docs/dataset-layout").sha
snapshot_download(
    repo_id=repo_id, repo_type="dataset", revision=revision, token=True,
    local_dir="igp24-stage1",
    allow_patterns=[
        "README.md", "LICENSE", "SHA256SUMS", "data/scoring/*",
        "scripts/*", "docs/*", "reports/leaderboard-validation*",
    ],
)
print("Repository revision:", revision)

From the downloaded igp24-stage1 directory, run:

python3 scripts/reproduce_leaderboard.py \
  --data data/scoring \
  --out ./leaderboard-replayed

Use a new output directory for each run. The script uses only Python's standard library, with no database, network access, Magma, or PARI/GP required after downloading the files. It writes the reconstructed leaderboard, pair scores, and a validation report, and exits nonzero if comparison fails.

The published validation independently replays 163,910 scored pairs and matches the scores, to six decimal places, and ranks of all 140 official leaderboard entries, including LMFDB. The comparison target is the official leaderboard snapshot in official_leaderboard.json, generated at 2026-09-22T05:39:56Z. See the validation report and machine-readable checks.

The scoring inputs contain 1,978,899 reduced scoring candidate records, selected from the same frozen primary snapshot as the polynomial export. They preserve the first-successful-candidate-per-team/batch/pair rule, pair-level exact/mixed selection, baseline rules, and numerical ordering needed to reproduce scores. They are not a second complete submission archive, and their candidate count must not be added to the polynomial-record count. The displayed scoreable-pair counts are supplied separately from the primary-data export; they are checked against the official snapshot but are not independently derived from the reduced scoring candidates by the replay script.

For scoring file schemas, selection rules, and limitations, see Leaderboard Reproduction.

Integrity and Provenance

SHA256SUMS is the single checksum manifest for the repository. It covers all published files except itself, including all 51 shards, the minimal and missing-pair files, scoring data, scripts, documentation, and reports. Paths are relative to the repository root. After downloading all files, verify them from that root on Linux with:

sha256sum -c SHA256SUMS

On macOS use shasum -a 256 -c SHA256SUMS. For a selective download, Linux users can add --ignore-missing to check only the files downloaded; this does not certify that the full dataset is present.

The records export report also records each shard's row count, byte size, and hash; its original shard basenames now refer to files under data/records/. The independent audit reports recomputing every shard's hash and line count, plus structural and LMFDB checks on a sample of 52,000 records. This is an integrity and sampled structural audit, not a new Magma/PARI computation for every released polynomial.

The scoring export report and provenance identify the frozen source and scoring implementation revision. The leaderboard validation checks scoring reconstruction, not new mathematical verification of the polynomials.

For reproducible work, record the repository commit, the collection used, and the relevant file checksums alongside your analysis.

License

The data and documentation in this repository are licensed under the Creative Commons Attribution-ShareAlike 4.0 International license (CC BY-SA 4.0).

You may share and adapt the material, including for commercial purposes, subject to the license terms. You must give appropriate credit, provide a link to the license, and indicate any changes. If you share adapted material, you must license your contributions under CC BY-SA 4.0 or a compatible license permitted by its terms. You may not impose additional legal or technological restrictions on the freedoms granted by the license.

This summary does not replace the full license. Separately licensed material retains its own applicable terms; this license does not relicense third-party software used in the competition.

Community Contributions and Acknowledgments

This dataset was made possible by the contributions of the IGP24 Stage 1 participants. We thank all participating teams for their mathematical ideas, computational work, and polynomial submissions, and the competition co-organizers for their guidance.

Each polynomial record includes the submitting team's team_number, preserving record-level attribution. When discussing specific results from the dataset, we encourage users to acknowledge the relevant teams and cite the original mathematical sources where known.

We also acknowledge the LMFDB project and the developers of Magma and PARI/GP, whose data and software supported the competition's baseline and verification workflow.

Citation

SAIR Foundation and IGP24 Stage 1 Participants. 2026. IGP24 Stage 1 Dataset. Version v1. Hugging Face. SAIRfoundation/IGP24-stage1.

@misc{sair_igp24_stage1_2026,
  author       = {{SAIR Foundation} and {IGP24 Stage 1 Participants}},
  title        = {{IGP24 Stage 1 Dataset}},
  year         = {2026},
  howpublished = {Hugging Face},
  note         = {Version v1},
  url          = {https://huggingface.co/datasets/SAIRfoundation/IGP24-stage1}
}

Specify whether your work used the sharded records, the minimal collection, the scoring data, or a combination, and identify the exact repository revision. Citation does not replace compliance with the license.

Related Resources

Downloads last month: 41

Total file size:

27.7 GB