---
license: agpl-3.0
license_name: sspl-1.0
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
  - split: validation
    path: data/validation-*
dataset_info:
  features:
  - name: messages
    list:
    - name: role
      dtype: string
    - name: content
      dtype: string
  - name: metadata
    struct:
    - name: topic_path
      list: string
    - name: checker_score
      dtype: int64
  splits:
  - name: train
    num_bytes: 135701582
    num_examples: 18098
  - name: validation
    num_bytes: 16079590
    num_examples: 2012
  download_size: 151672373
  dataset_size: 151781172
---

# pythink-20k

**High-quality Python reasoning traces for training rigorous, step-by-step thinking.**

`pythink-20k` is a quality-controlled, synthetic, curated dataset of **20,000 executable Python reasoning plans**. Each example teaches a model to
break down complex problems into structured, verifiable steps using a consistent execution trace style.

This is an initial release focused on getting an initial dataset out for testing and experimentation.  I expect that the quality is pretty good, but
quality is currently limited by the ability for existing models to represent thoughts as Python code.

## Why?

Current LLMs have very unstructured, undisciplined thoughts which are poorly comprehensible and often inefficient.  Using a programming
language for thinking makes thoughts easier to audit, more structured, and more consistent.

Why Python?
- LLMs are excellent at Python already
- Python is more token-efficient than JSON, typescript, or other languages

## What’s in the Data?

Each example contains a full Python-based reasoning trace that:

- Uses short, action-oriented `# Next:` comments
- Performs actual modeling, calculation, validation, or simulation in code
- Stays in "plan mode" (does not output raw implementation code in other languages)
- Ends with a clean `finalAnswer`

The training data treats the **entire reasoning trace** as its response.  This dataset will NOT train a model to answer the question.  The whole
point is to train the model to consider **how the question should be thought about**, instead of rushing to reach a conclusion.

The outputs are generally executable Python code, meaning than many of the responses can be executed to get the real output.

### Example Format

```json
{
  "messages": [
    {
      "role": "user",
      "content": "Design a system that programmatically generates a TLS 2048-bit RSA certificate with 90-day validity..."
    },
    {
      "role": "assistant",
      "content": "# Next: validate RSA certificate requirements...\nrsaKeyBits = 2048\nvalidityDays = 90\n..."
    }
  ],
  "metadata": {
    "topic_path": ["coding", "Network Servers and Daemons", "TLS/SSL Termination"],
    "checker_score": 10
  }
}
```

## Key Features

- **20k high-quality traces** (filtered with automated quality gate)
- Strong emphasis on **executable reasoning** rather than descriptive text
- Diverse domains: mathematics, coding, physics, philosophy, biology, and more
- Includes rich metadata (`checker_score`, topic path)
- Clean chat format ready for SFT

## Intended Use

This dataset is designed for:

- Supervised fine-tuning of reasoning models
- Training models to produce structured, verifiable reasoning traces
- Research on executable chain-of-thought and code-as-reasoning
- Building the foundation for more advanced agentic and memory-augmented systems

## Data Quality

All examples passed a multi-criteria quality filter including:
- Minimum checker score
- Presence of executable steps and validation logic
- Avoidance of target-language code leakage
- Reasonable length and structure

## Limitations

- Some traces may still contain minor stylistic inconsistencies.
- Focused on reasoning structure rather than factual correctness.

## License

AGPL-3.0

## Citation

If you use this dataset, please cite:

```bibtex
@misc{pythink-20k,
  author = {NuclearManD},
  title  = {pythink-20k: High-Quality Python Reasoning Traces},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/datasets/NuclearManD/pythink-20k}}
}
```

## Future Releases

Planned improvements include:
- Higher quality filtering and human review
- Preference data (chosen vs rejected reasoning traces)
- Multi-turn and agentic reasoning examples

---

**Built as part of ongoing work on rigorous reasoning systems.**