README.md

# Qwen 3.7 Max Thinking — Distilled Reasoning Dataset

**5,000 high-quality, no-duplicate chain-of-thought reasoning traces** for knowledge distillation, fine-tuning, or research. Each example contains a problem, a detailed step-by-step thinking trace (mirroring the Qwen 3.7 Max Thinking reasoning style), and a final answer.

## Dataset Format

**File:** `qwen3.7_max_thinking_dataset.jsonl`  
**Format:** JSON Lines (one JSON object per line)  
**Encoding:** UTF-8 (ASCII-safe content — no special Unicode characters)

### Schema

```json
{
  "problem":        "The input question or task prompt",
  "thinking_trace": "Multi-step chain-of-thought reasoning trace with self-verification",
  "answer":         "The final concise answer"
}
```

### Example

```json
{
  "problem": "A car starts at 9 m/s and accelerates at 10 m/s^2 for 7s. Find distance and final velocity.",
  "thinking_trace": "Using kinematics equations:\nv_f = v_0 + a*t = 9 + 10*7 = 79 m/s\nd = v_0*t + 0.5*a*t^2 = 9*7 + 0.5*10*7^2\n  = 63 + 0.5*10*49 = 308.0 m\nCheck: v_avg = (9+79)/2 = 44.0 m/s, d = v_avg*t = 308.0 m [OK]",
  "answer": "Distance = 308.0m, Final velocity = 79 m/s"
}
```

## Category Distribution

| Category | Count | Percentage |
|---|---|---|
| Coding & Algorithms | ~1,200 | ~24% |
| Mathematics (algebra, quadratics, probability, geometry, sequences, combinatorics, stats) | ~1,200 | ~24% |
| Scientific Reasoning (physics, chemistry, biology) | ~830 | ~17% |
| Number Theory (primality, GCD, modular exponentiation) | ~590 | ~12% |
| Data Analysis (linear regression, trend estimation) | ~590 | ~12% |
| Agentic & Multi-Step Planning | ~290 | ~6% |
| Logic & Puzzles (liar puzzles, water jug, Monty Hall, Latin squares) | ~270 | ~5% |
| Commonsense Causal Reasoning | ~10 | <1% |
| Creative / Fermi Estimation | ~10 | <1% |
| Prompt Engineering / Agent Workflows | ~10 | <1% |

## Reasoning Style

The thinking traces follow the **Qwen 3.7 Max Thinking paradigm**:

1. **Problem decomposition** — break the problem into manageable steps
2. **Formula recall** — state the relevant equation or approach
3. **Step-by-step computation** — perform each operation with intermediate values
4. **Self-verification** — check the result via alternative method or substitution
5. **Final answer extraction** — present the clean final answer

This style is optimized for **knowledge distillation** where a smaller student model learns to mimic the extended reasoning process of a larger teacher model.

## Key Properties

| Property | Value |
|---|---|
| Total examples | 5,000 |
| Duplicate problems | 0 (SHA-256 problem-level dedup) |
| Duplicate entries | 0 (SHA-256 full-entry dedup) |
| Min thinking trace length | 44 chars |
| Max thinking trace length | 456 chars |
| Avg thinking trace length | ~199 chars |
| File size | ~1.76 MB |
| Output encoding | UTF-8, ASCII-safe |

## Use Cases

- **Knowledge distillation** — train a smaller model to produce step-by-step reasoning
- **Supervised fine-tuning (SFT)** — teach chain-of-thought reasoning
- **Reasoning benchmark** — evaluate model reasoning quality
- **Prompt engineering research** — study structured reasoning patterns
- **Agent training data** — multi-step planning and tool-use reasoning

## Generation

The dataset was generated programmatically by `generate_dataset.py` using templated generators with randomized parameters across 10 reasoning domains. Each call produces a unique combination of numeric values, problem text, and computed outputs, then filters through a SHA-256 deduplication pipeline at both the entry and problem levels.

### Regenerate or Extend

```bash
python generate_dataset.py
```

Modify the generator functions or weights in the script to adjust:
- Category balance
- Difficulty ranges
- Problem types
- Total count (default 5,000)