---
license: other
language:
- en
tags:
- LOOM
- English
- CoT
- code
- math
---
# LOOM: Language-Only Operational Microworlds

**LOOM** is a synthetic natural-language reasoning dataset designed to teach language models the deep structures behind code and math without exposing source code, formal equations, or symbolic programming syntax.

Instead of showing code or math notation, LOOM trains models on **ordinary-language microworlds** where the hidden logic is algorithmic: state changes, causal chains, conditionals, invariants, iteration, and reverse reasoning.

The dataset is intended as a **pre-code / pre-math reasoning substrate**. It teaches the model to simulate rules, track hidden states, infer causes, and produce step-by-step logical traces.

## What LOOM Teaches

LOOM examples are designed to implicitly train the following skills:

- **State tracking**: following how objects change across events.
- **Causal chaining**: propagating effects through multiple rules.
- **Conditionals**: reasoning through if/else-style branches.
- **Invariants**: understanding conserved quantities or balanced properties.
- **Iteration**: reasoning about repeated actions until completion.
- **Reverse reasoning**: inferring causes from observed outcomes.
- **Chain-of-thought traces**: producing intermediate reasoning before the final answer.

## What LOOM Avoids

The dataset intentionally avoids:

- Source code
- Programming syntax
- Formal equations
- Mathematical notation
- Code-like operators
- Formulaic symbolic reasoning

The surface text is plain natural language. The computational and mathematical structure remains latent.

## Dataset Structure

Each example is a JSONL object with the following fields:

- `instruction`: The task prompt.
- `world`: The rules describing the microworld.
- `event`: The triggering event or observed state.
- `question`: What the model must infer.
- `reasoning`: A step-by-step natural-language logical trace.
- `final_answer`: The final outcome.

## Example

```json
{
  "instruction": "Determine the outcome of the event based on the world rules. Provide a step-by-step logical trace before the final answer.",
  "world": "Whenever the silver mirror reflects, it triggers the dormant shadow. Whenever the dormant shadow awakens, it triggers the golden seed.",
  "event": "The silver mirror reflects.",
  "question": "What is the final consequence for the golden seed?",
  "reasoning": "First, the silver mirror reflects. Because the silver mirror reflected, the dormant shadow is triggered. Because the dormant shadow awakened, the golden seed is triggered.",
  "final_answer": "The golden seed is triggered."
}
```

## Categories

### 1. Causal Chains

Teaches transitive reasoning and state propagation.

Example pattern:

> Whenever A acts, it triggers B.  
> Whenever B acts, it triggers C.  
> A acts.  
> Therefore, C is triggered.

### 2. Conditionals

Teaches branching logic.

Example pattern:

> If A happens, B happens.  
> If A does not happen, C happens.

### 3. Invariants

Teaches conservation-style reasoning.

Example pattern:

> The total balance between A and B is preserved.  
> If A gains something, B must lose it.

### 4. Iteration

Teaches repeated actions, termination conditions, and cumulative effects.

Example pattern:

> The ritual repeats until the required number of actions has occurred.

### 5. Reverse Logic

Teaches abduction and backtracking.

Example pattern:

> The outcome happened.  
> What must have caused it?

## Loading the Dataset

```python
from datasets import load_dataset

ds = load_dataset(
    "YOUR_USERNAME/loom",
    data_files={"train": "loom_dataset.jsonl"},
    split="train",
)

print(ds[0])
```

Replace `YOUR_USERNAME` with your Hugging Face username.

## Intended Use

LOOM can be used for:

- Reasoning-focused continued pretraining
- Chain-of-thought style supervision
- Synthetic reasoning warm-up before code or math training
- Evaluation of rule-following and hidden-state tracking
- Data augmentation for abstract reasoning tasks

It is not intended to replace real code or math datasets. It is intended to teach the underlying operational reasoning that makes those domains easier to learn.

## Generation

This dataset was procedurally generated using combinatorial natural-language templates. Each example is constructed from randomized entities, actions, conditions, and causal relations.

The generation process creates millions of unique examples while preserving logical consistency between:

- the world rules,
- the event,
- the reasoning trace,
- and the final answer.

## Limitations

LOOM is synthetic and stylized. Its language is intentionally simple and rule-based. It may contain repeated structures, artificial phrasing, and limited semantic diversity compared with natural web text.

The dataset teaches abstract reasoning patterns, but it does not teach real programming syntax, libraries, APIs, or advanced mathematical formalism.

## Citation

```bibtex
@misc{loom2026,
  title={LOOM: Language-Only Operational Microworlds},
  author={Gugu8},
  year={2026},
  howpublished={Hugging Face Datasets}
}
```