---
license: mit
task_categories:
- text-generation
- text2text-generation
language:
- en
tags:
- code
- reasoning
- chain-of-thought
- verifiable
- execution-verified
- python
- sft
pretty_name: Verifiable Code Reasoning
size_categories:
- 10K<n<100K
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-*
  - split: validation
    path: data/validation-*
dataset_info:
  features:
  - name: id
    dtype: string
  - name: difficulty
    dtype: string
  - name: category
    dtype: string
  - name: problem
    dtype: string
  - name: signature
    dtype: string
  - name: reasoning
    dtype: string
  - name: code
    dtype: string
  - name: tests
    dtype: string
  - name: verified
    dtype: bool
  - name: language
    dtype: string
  - name: code_hash
    dtype: string
  - name: sft_text
    dtype: string
  - name: meta
    dtype: string
  splits:
  - name: train
    num_bytes: 25363
    num_examples: 24
  - name: validation
    num_bytes: 1318
    num_examples: 1
  download_size: 34096
  dataset_size: 26681
---

# Verifiable Code Reasoning

**Execution-verified** Python coding problems with step-by-step chain-of-thought.

Only solutions that **pass sandboxed unit tests** are kept. Failed executions are discarded.

| Property | Detail |
|----------|--------|
| Verification | Multiprocess sandbox + timeout + multi-test |
| Dedup | Example id + normalized code hash |
| Balance | Category and difficulty quotas |
| Resume | Hub checkpoints (train.jsonl, progress.json) |
| License | MIT |

**Current size:** 25 verified examples (target 1,000,000).

## Schema

| Field | Description |
|-------|-------------|
| problem | Natural language problem |
| signature | Python function signature |
| reasoning | Numbered chain-of-thought |
| code | Reference solution |
| tests | JSON string of input/output test list |
| category | array, hashmap, dp, ... |
| difficulty | easy / medium / hard |
| sft_text | Ready-to-train text block |
| verified | Always true in this release |
| code_hash | Deduplication key |

Note: `tests` is stored as a JSON string so Arrow/HF keeps a uniform schema
across problems whose outputs are ints, bools, or lists.

## Load

```python
from datasets import load_dataset
import json
ds = load_dataset("smshahbaj/verifiable-code-reasoning")
row = ds["train"][0]
print(row["sft_text"][:400])
tests = json.loads(row["tests"])
```

## SFT format (sft_text)

```text
### Problem
...

### Reasoning
...

### Solution
```python
...
```
```

## Construction

1. 25 algorithmic generator families
2. At least 3 unit tests per example
3. Sandbox execution filter (fail = drop)
4. Quotas against template collapse
5. Checkpoint upload every 2000 new verifies

## Intended use

- SFT on code + reasoning
- Process / outcome reward modeling
- Filtering noisy synthetic traces

## Limitations

- Coverage equals the generator bank (not full competitive programming)
- Python only
- Always validate downstream models on real held-out benchmarks

## Citation

```bibtex
@misc{verifiable_code_reasoning,
  title  = {Verifiable Code Reasoning},
  author = {smshahbaj},
  year   = {2026},
  url    = {https://huggingface.co/datasets/smshahbaj/verifiable-code-reasoning}
}
```