README.md

---
pretty_name: Multi-Strategy Algorithmic Tasks
license: cc-by-4.0
language:
  - en
task_categories:
  - text-generation
tags:
  - synthetic
  - reasoning
  - algorithmic-reasoning
  - strategy
  - datasets
size_categories:
  - 1M<n<10M
---

# Multi-Strategy Algorithmic Tasks

A synthetic benchmark of parseable algorithmic problems with multiple valid
solution strategies for each task. Each example contains a problem,a strategy-specific
solution trace, and the strategy used to generate that trace.

The benchmark accompanies
*[Uncovering Latent Reasoning Strategies in Language Models](https://arxiv.org/abs/2607.17674)*,
which studies the problem of recovering mixtures of strategies implicitly represented in language models.
The benchmark provides a controlled setting for studying strategy recovery, representation, routing,
and controllable generation.

## Load the dataset

```python
from datasets import load_dataset

dataset = load_dataset("awni00/multi-strategy-algorithmic-tasks")
example = dataset["train"][0]
```

The release contains:

| Split | Rows |
| --- | ---: |
| `train` | 1,000,000 |
| `validation` | 10,000 |
| `test` | 10,000 |

Release version: `v1.0.0`.

To select one task family:

```python
sorting = dataset.filter(
    lambda example: example["task_name"] == "sorting_algorithms"
)
```

## Fields

| Field | Description |
| --- | --- |
| `task_name` | Algorithmic task family |
| `strategy_id` | Namespaced strategy sampled to generate the trace |
| `input_text` | Rendered problem instance |
| `reasoning_trace` | Complete strategy-specific solution trace, including the final answer |

Example:

```python
{
    "task_name": "multidigit_addition",
    "strategy_id": "multidigit_addition:left-to-right-partials",
    "input_text": "560+342",
    "reasoning_trace": (
        "p100:500+300=800 ; p10:60+40=100 ; "
        "p1:0+2=2 ; sum=800+100+2=902"
    ),
}
```

## Tasks and strategies

The generator first samples one of the six task families uniformly. It then
samples a strategy uniformly within that task family.

| Task | Problem | Strategies |
| --- | --- | --- |
| `list_summation` | Sum four integers from 0 to 9 | `left-to-right`, `right-to-left`, `pairwise` |
| `sorting_algorithms` | Sort five integers from 0 to 9 | `bubble-sort`, `selection-sort`, `insertion-sort`, `merge-sort`, `heap-sort` |
| `grid_pathfinding` | Monotone shortest paths on a 6×6 grid | `right-first`, `down-first`, `alternating` |
| `linear_equation_solving` | Solve integer equations of the form `ax+b=c` | `subtract-then-divide`, `divide-then-subtract`, `inverse-ops` |
| `base_conversion` | Convert integers from 1 to 255 to base 2, 4, 8, or 16 | `repeated-division`, `via-binary`, `decomposition` |
| `multidigit_addition` | Add two three-digit nonnegative integers | `right-to-left-carry`, `left-to-right-partials`, `rounding-decomposition` |

The public `strategy_id` includes the task namespace, for example
`grid_pathfinding:alternating`. There are 20 strategies in total across the six tasks.

`strategy_id` is the strategy selected by the generator. On some inputs,
multiple strategies produce the same observable trace.
This is most common when a problem requires only a few steps or different
algorithms happen to traverse identical intermediate states.

## License

The dataset is released under the
[Creative Commons Attribution 4.0 International License](https://creativecommons.org/licenses/by/4.0/).

## Citation

```bibtex
@misc{altabaa2026uncovering,
  title         = {Uncovering Latent Reasoning Strategies in Language Models},
  author        = {Awni Altabaa and John Lafferty},
  year          = {2026},
  eprint        = {2607.17674},
  archivePrefix = {arXiv},
  primaryClass  = {cs.LG},
  url           = {https://arxiv.org/abs/2607.17674}
}
```

Code associated with the paper is available at
[Awni00/latent-strategies-in-lms](https://github.com/Awni00/latent-strategies-in-lms).