README.md

---
license: cc-by-nc-nd-4.0
pretty_name: RegexPSPACE
eprint: "2510.09227"
task_categories:
- text-classification
- text-generation
tags:
- regex
- minimization
- equivalence
- PSPACE
size_categories:
- 1K<n<10K
configs:
- config_name: default
  data_files:
  - split: test
    path: data/test-*
  - split: fewshot
    path: data/fewshot-*
dataset_info:
  features:
  - name: idx
    dtype: int64
  - name: query
    dtype: string
  - name: tree_length
    dtype: int64
  - name: depth
    dtype: int64
  - name: minimized_regex
    dtype: string
  - name: minimized_tree_length
    dtype: int64
  - name: minimized_depth
    dtype: int64
  - name: equivalent_regex
    dtype: string
  - name: not_equivalent_regex
    dtype: string
  - name: positive_example
    dtype: string
  - name: negative_example
    dtype: string
  splits:
  - name: test
    num_bytes: 206502
    num_examples: 1685
  - name: fewshot
    num_bytes: 208420
    num_examples: 1685
  download_size: 192074
  dataset_size: 414922
---

# Dataset Card for Dataset Name

This dataset, RegexPSPACE, is a new benchmark of PSPACE-complete regex problems designed to evaluate the complex reasoning capabilities of Large Language Models (LLMs).

## 1. Dataset Details

#### Dataset Description

RegexPSPACE is the first benchmark designed to evaluate the reasoning capabilities of Large Language Models (LLMs) on PSPACE-complete regular expression (regex) problems.
The benchmark is grounded in two specific PSPACE-complete tasks: equivalence decision (RegexEQ) and minimization (RegexMin).

The dataset was constructed through a rigorous process of double-exponential space exploration and a sound filtering process, curating 1,685 challenging problems from over a million initial instances.
This research provides the first empirical investigation into the spatial computational limitations of LLMs, offering a new framework for evaluating their advanced reasoning capabilities.

- **Curated by:** Hyundong Jin, Joonghyuk Hahn, Yo-sub Han
- **Language(s) (NLP):** Regular Languages
- **License:** ```cc-by-nc-nd-4.0```

#### Dataset Sources

- **Repository:** https://github.com/hyundong98/RegexPSPACE
- **Paper:** https://arxiv.org/abs/2510.09227

## 2. Uses

#### Direct Use

The primary intended use of RegexPSPACE is for benchmarking the reasoning abilities of AI models, particularly Large Language Models (LLMs) and Large Reasoning Models (LRMs).
It is designed for researchers and developers to:

- Evaluate model performance on tasks requiring high spatial and computational complexity.
- Analyze failure patterns in complex, formal reasoning scenarios.
- Study the scaling effects of model size on advanced reasoning capabilities.

## 3. Dataset Structure

The dataset is divided into a test split and a fewshot split. 
Since we plan to release the larger initial dataset separately, we constructed this benchmark by preserving its original data splits. 
The test split, intended for benchmarking, was derived from the original test set. The fewshot split was sourced from the original train set. 
Each instance contains a challenging regex problem and its associated ground-truth solutions for different tasks.

The following describes the features of the dataset.

- ```idx``` (int64): A unique identifier for the data instance.
- ```query``` (string): The input regular expression for the primary task.
- ```tree_length``` (int64): The length of the syntax tree for the query regex.
- ```depth``` (int64): The depth of the syntax tree for the query regex.
- ```minimized_regex``` (string): The ground-truth solution for the minimization task.
- ```minimized_tree_length``` (int64): The tree length of the minimized_regex.
- ```minimized_depth``` (int64): The tree depth of the minimized_regex.
- ```equivalent_regex``` (string): A distinct but semantically equivalent regex, used for the equivalence task.
- ```not_equivalent_regex``` (string): A non-equivalent regex, used for the equivalence task.
- ```positive_example``` (string): A string that matches the query regex.
- ```negative_example``` (string): A string that does not match the query regex.

## 4. Dataset Creation

#### Curation Rationale

The dataset was created to fill a gap in LLM evaluation by providing a benchmark that specifically targets the spatial complexity and reasoning limits of models.
Existing benchmarks often focus on knowledge or linguistic capabilities, whereas RegexPSPACE uses the formal, high-complexity nature of PSPACE-complete problems to probe the deeper computational reasoning of LLMs.

#### Data Collection and Processing

The data is entirely synthetically generated.
The process began with over a million initial regex instances.
These instances were subjected to a double-exponential space exploration and a sound filtering process to select for problems that are both challenging and unambiguous.
This ensures a high-quality evaluation set.

#### Who are the source data producers?

The source data was generated by a computational process designed by the dataset curators: Hyundong Jin.

#### Annotations

This dataset does not contain human annotations.
The target fields (e.g., minimized_regex) are ground-truth solutions generated and verified by the same computational process that created the problems.

#### Personal and Sensitive Information

The dataset contains no personal, private, or sensitive information. All data is synthetically generated and pertains to abstract mathematical and computational concepts.

## 5. Citation

<!-- If there is a paper or blog post introducing the dataset, the APA and Bibtex information for that should go in this section. -->

**BibTeX:**
```
@misc{JinHH2025,
      title={RegexPSPACE: A Benchmark for Evaluating LLM Reasoning on PSPACE-complete Regex Problems}, 
      author={Hyundong Jin and Joonghyuk Hahn and Yo-Sub Han},
      year={2025},
      eprint={2510.09227},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2510.09227}, 
}
```

**APA:**
Jin, H., Hahn, J., & Han, Y. (2025). RegexPSPACE: A Benchmark for Evaluating LLM Reasoning on PSPACE-complete Regex Problems. arXiv preprint arXiv:2510.09227.

## 6. Glossary

- PSPACE-complete: A class of computational problems that are the "hardest" problems in the PSPACE complexity class. These problems require a polynomial amount of memory to solve.

- RegexMin (Minimization): The task of finding the shortest possible regular expression that is semantically equivalent to a given regex.

- RegexEQ (Equivalence): The task of determining whether two different regular expressions describe the same set of strings.

## 7. More Information

For more details, please refer to the official [GitHub repository](https://github.com/hyundong98/RegexPSPACE) and the [accompanying paper](https://arxiv.org/abs/2510.09227).

## 8. Dataset Card Contact

For questions or feedback about the dataset, please use the contact information provided in the paper or open an issue on the [GitHub repository](https://github.com/hyundong98/RegexPSPACE).