---
pretty_name: OpenFrontiers
language:
- en
license: other
license_name: mixed-source-terms
license_link: https://huggingface.co/datasets/FlippyDora/OpenFrontiers/blob/main/NOTICE.md
task_categories:
- text-retrieval
tags:
- mathematics
- open-problems
- scientific-research
- lean4
- msc2020
size_categories:
- 10K<n<100K
configs:
- config_name: problems
  default: true
  data_files:
  - split: train
    path: data/problems.parquet
- config_name: catalogues
  data_files:
  - split: train
    path: data/catalogues.parquet
- config_name: archive
  data_files:
  - split: train
    path: data/archive.parquet
- config_name: all_records
  data_files:
  - split: train
    path:
    - data/problems.parquet
    - data/catalogues.parquet
    - data/archive.parquet
---

# OpenFrontiers: research-problem corpus

A structured snapshot of the OpenFrontiers research-problem index, including mathematical
and scientific problem statements, source attribution, MSC 2020 mappings, collected
Lean 4 material and research-status evidence. The exact snapshot date, counts and
coverage are in [statistics.json](statistics.json).

The Lean-stated evaluation benchmark built from this corpus is released separately as
[OpenFrontiers-Bench](https://huggingface.co/datasets/FlippyDora/OpenFrontiers-Bench)
(200 items) and its evaluated subset
[OpenFrontiers-HQ50](https://huggingface.co/datasets/FlippyDora/OpenFrontiers-HQ50).

The default `problems` configuration contains every published problem in the database,
including solved, disputed and status-unassessed records. It is **not a claim that
every row is currently an unsolved problem**, nor a complete census of any discipline.
One row corresponds to one indexed problem record; a paper can contain multiple
subquestions in the same record. Overlapping formulations from different sources
are retained with their own provenance. Unique IDs do not imply mathematical deduplication.

`catalogues` retains source problem-number indices, workshop lists, document listings,
journals and archived redirects. These rows have `problem_statement: null`; they are
not additional extracted problems. `linked_problem_ids` connects a catalogue entry
to an indexed problem. Different catalogues may point to the same item.
`archive` retains nonpublished historical research records separately. `all_records`
combines these three disjoint row sets with exactly the same schema.

`train` is a Hugging Face storage split name only. No train/test separation or
evaluation-contamination control has been performed.

## Load

Install the versions in `requirements.txt`. From the dataset directory:

```python
from datasets import load_dataset

# Reads the configurations in this dataset card.
ds = load_dataset(".", name="problems", split="train")
row = ds[0]  # a Python dictionary, including nested dictionaries and lists

# Explicit file loading is also supported.
ds = load_dataset("parquet", data_files="data/problems.parquet", split="train")
math = ds.filter(lambda r: r["field"]["main"] == "math")
open_math = math.filter(lambda r: r["status"] == "open")

# From the Hugging Face Hub:
ds = load_dataset("FlippyDora/OpenFrontiers", name="problems", split="train")
```

The equivalent JSONL files have one JSON dictionary per UTF-8 line. Use the supplied
loader for exact string preservation and explicit nullable types:

```python
from load_jsonl import load_jsonl
ds = load_jsonl("data/problems.jsonl")
```

The helper uses `json.loads` and `Dataset.from_generator` with `features.json`.
This avoids the generic JSON loader's automatic date inference before string
casting (observed with the pinned version), which can change `2026-09-08` into
`2026-09-08 00:00:00`. Standard Python `json.loads` also reads the JSONL verbatim.
The default Parquet configurations preserve these strings without a custom loader.

These formats and configurations follow the official
[Hugging Face loading documentation](https://huggingface.co/docs/datasets/loading)
and [dataset configuration documentation](https://huggingface.co/docs/hub/datasets-data-files-configuration).

## Dictionary fields

All rows have all keys. Unknown scalar values are JSON `null` / Python `None`;
empty lists mean no collected items. Missing data is not converted into invented
statements or proofs. [schema.json](schema.json) defines every key and type;
[features.json](features.json) defines the matching Hugging Face schema.

| Field | Meaning |
| --- | --- |
| `id`, `record_kind`, `slug`, `title` | Stable namespaced identifier, row type and problem identity. |
| `field.main`, `field.sub` | Broad discipline and subject, e.g. `math`, `number theory`. Original field name, slug and discipline are also retained. |
| `additional_fields` | Additional subject mappings without duplicating the primary field. |
| `msc2020` | MSC codes plus mapping basis and evidence. Editorial/inferred mappings are distinguished from source mappings. A missing narrow code is not invented. |
| `problem_statement` | Existing Markdown/LaTeX statement, preserved verbatim. May be a summary or excerpt; see provenance. |
| `status` | Existing editorial status: `open`, `unassessed`, `partially-solved`, `solved`, `disputed`, `withdrawn`. Catalogue status can also include source review labels. |
| `source` | Collection key, source title/type/URL/citation/DOI/arXiv ID, recorded license wording and notes. |
| `lean4_statement` | Existing Lean 4 material, or the first deterministic linked upstream source file when the database has no Lean attachment. Can be a fragment, a whole file, or a proposition definition. |
| `proof`, `proof_status` | Accepted full-solution submission text if collected; otherwise null / `not-recorded`. Acceptance is editorial, not mathematical certification. |
| `lean4_proof`, `lean4_proof_status` | An accepted solution's existing verified proof, bound to the current stored target and known verification profile; otherwise null / `not-recorded`. |
| `lean4_target` | Separately stored target proposition, if available. |
| `formalizations` | Every collected attachment/linked Lean file, with code, language, hash, source URL, license, toolchain/commit where known, lexical placeholder flags and verification/correspondence status. |
| `contributions` | Collected submissions, public comments and public AI attempts. Rejected/partial/unverified attempts remain contributions rather than canonical proofs. |
| `teaser`, `background`, `partial_results`, `why_it_matters` | Existing contextual research text, preserved verbatim. |
| `references` | All collected citations, links, notes and original ordering. |
| `provenance`, `source_status_json` | Import/status dates, original record IDs and evidence; dated upstream status claims remain separate from local verification. |
| `review_state`, `horizon`, `difficulty`, `tags` | Original editorial/research labels; not a benchmark difficulty scale. |
| `posed_by`, `posed_year`, `prize_amount_usd`, `prize_sponsor` | Existing historical information; no fresh financial or historical verification. |
| `quality_flags`, `linked_problem_ids` | Missing full text, known formula issues, unverified source claims, source-file enrichment and catalogue links. |
| `dates`, `snapshot_at` | Stored record dates and dataset snapshot timestamp in ISO format. |
| `metadata_json` | JSON-encoded ancillary metadata. Catalogue rows retain their original index metadata; problem rows retain their original database ID/number and format-audit details. |

## Formal statements and proofs

FormalConjectures source files are retained at the pinned commit recorded in
`statistics.json`; their own Lean toolchain and dependency manifest are in `metadata/`.
The full upstream repository is required to compile source files with their imports.
Those files can contain multiple conjectures, solved helper lemmas, `answer(sorry)`,
or admitted declarations. A file's presence does not establish a proof of the
associated natural-language problem. All variants are preserved in `formalizations`.

This export does **not** execute Lean. Lexical `sorry`/`admit`/`axiom` flags mask nested
comments and strings, but are not a Lean parser or proof checker. Old source-side
"verified" labels are retained as claims in `source_status_json`, not promoted to
locally verified proofs. If a source reports a proof whose text was not collected,
the text remains null and a quality flag records that gap.

For any existing local verification receipt, the exporter requires the known
`lean4-core-4.19.0-v1` profile, matching target and proof content hashes, a current
matching target, and an explicit axiom list contained in `propext`, `Classical.choice`,
`Quot.sound`. Only accepted full-solution submissions can populate canonical proof
fields. Even `verified-target-only` does not certify correspondence between the
Lean target and the natural-language problem. Multiple attempts remain available
in `contributions`; when multiple qualifying solutions exist, the most recently
created qualifying submission is selected deterministically.

## Collection, coverage and limitations

The export uses a repeatable-read, read-only database snapshot plus existing source
catalogues and pinned source artifacts. It preserves the corpus, rather than
silently dropping uncertain or older records. No new open-problem status review
is implied by export time. The metadata folder preserves source registries,
selection decisions, import manifests, MSC taxonomy, review evidence and known
format issues. Source catalogues are partial and differ in scope.

The sources include ICM Conjectures, COLT, TheoremDB, AIM Problem Lists, Erdős Problems,
Clay, Wikipedia subject lists, specialist collections and selected journal/workshop
articles. Source descriptions and license wording appear in `metadata/sources.json`.
These are not rankings or endorsements. Some inherited records are summaries rather
than complete standalone formulations; `provenance.has_full_text` and quality flags
make recorded gaps filterable. Source-reported solved or open status can be outdated.

Markdown/LaTeX and Unicode are preserved, including known upstream formatting
problems rather than silently rewriting mathematics. Site-relative figure/document
links remain verbatim; `metadata/asset-manifest.json` records referenced assets and
`metadata/aim-documents.json` maps cached AIM documents to original URLs. Binary PDFs
and figures are not bundled in this text dataset. Some records therefore require
the cited source for figures or complete context.

Operational accounts, sessions, credentials, private AI prompts, private attempts,
payments and usage logs are outside the research-data export. Public research
authorship/citations are retained. There are no inferred demographic annotations.

## Reuse and upload

This is a **mixed-source dataset**, not a blanket CC0/Apache-licensed corpus.
See [NOTICE.md](NOTICE.md), each row's `source.license`, attachment licenses and
original source notices. Technical upload readiness does not establish unrestricted
redistribution or training rights for every source. The dataset preserves all
existing research records so downstream users can apply source-specific policies.

Authenticate using the Hugging Face CLI, then preview the upload file list:

```sh
hf auth login
python upload.py --repo-id OWNER/DATASET
# When ready, this creates/updates a private dataset repository:
python upload.py --repo-id OWNER/DATASET --upload
# To choose public visibility when creating a NEW repository, also pass --public.
```

The upload helper checks `checksums.sha256` and the successful validation report
before sending files. No upload occurs without `--upload`. Existing repository
visibility is not changed by this helper. Uploading does not delete older remote
files, so a new versioned repository is the simplest way to publish an exact snapshot.

## Reproducibility and validation

`input-manifest.json` records input hashes. `validation.json` records the completed
schema, count, reference, content-preservation and JSONL/Parquet/Hugging Face loading
checks. `checksums.sha256` covers all packaged files except itself. Export scripts
and pinned dependencies are in `reproduce/`. Archived TypeScript scripts use
`.ts.txt` names so this package does not alter the application's build; restore
their `.ts` extension under `scripts/dataset/` in the application repository to run them.

To rebuild from the application repository, first stop its preview if it shares
the embedded database, then take a read-only research snapshot (or use a fully
offline database copy through `PGLITE_DATA_DIR`). Restart the preview afterward.
Never open the embedded database from two processes at once.

```sh
node --import tsx scripts/dataset/snapshot.ts .tmp/hf-dataset-snapshot.json
python scripts/dataset/export.py --snapshot .tmp/hf-dataset-snapshot.json \
  --formal-root PATH/TO/PINNED/formal-conjectures-COMMIT \
  --theorem-snapshot PATH/TO/theorem-all.json --output datasets/NEW-VERSION
python scripts/dataset/verify.py --snapshot .tmp/hf-dataset-snapshot.json \
  --dataset datasets/NEW-VERSION
```

Inputs must be the matching saved versions, not a fresh download at a moving branch.
The raw application database and source-account API responses are not included in
the upload package. JSONL and Parquet data rows can be checked independently without
those private operational inputs.